From 9f22b07578e22804303d94208c626c2ab095e8a9 Mon Sep 17 00:00:00 2001 From: JackNoordhuis Date: Wed, 13 Sep 2023 23:27:05 +1000 Subject: [PATCH 1/2] update publish package workflow: tag latest on release publish --- .github/workflows/package-publish.yml | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/.github/workflows/package-publish.yml b/.github/workflows/package-publish.yml index e753698..210d419 100644 --- a/.github/workflows/package-publish.yml +++ b/.github/workflows/package-publish.yml @@ -3,8 +3,8 @@ name: Publish Package on: push: branches: [dist] - tags: - - '*' + release: + types: [published] permissions: contents: read @@ -69,7 +69,7 @@ jobs: NODE_AUTH_TOKEN: ${{ secrets.NPM_AUTH_TOKEN }} - name: Publish ${{ github.ref_name }} to npm registry - if: github.event_name == 'tag' + if: github.event_name == 'release' run: | npm config set allow-same-version true npm config set git-tag-version false From 7e958f48055dfbc8b4a5dcf2428bec81e6500d2e Mon Sep 17 00:00:00 2001 From: JackNoordhuis Date: Wed, 13 Sep 2023 13:28:14 +0000 Subject: [PATCH 2/2] [create-pull-request] update tsc build dist files --- index.d.ts | 6 ++ index.js | 7 ++ src/Component.d.ts | 19 ++++++ src/Component.js | 7 ++ src/Global.d.ts | 15 +++++ src/Global.js | 2 + src/Plugin.d.ts | 12 ++++ src/Plugin.js | 36 ++++++++++ src/Store.d.ts | 24 +++++++ src/Store.js | 159 +++++++++++++++++++++++++++++++++++++++++++++ 10 files changed, 287 insertions(+) create mode 100644 index.d.ts create mode 100644 index.js create mode 100644 src/Component.d.ts create mode 100644 src/Component.js create mode 100644 src/Global.d.ts create mode 100644 src/Global.js create mode 100644 src/Plugin.d.ts create mode 100644 src/Plugin.js create mode 100644 src/Store.d.ts create mode 100644 src/Store.js diff --git a/index.d.ts b/index.d.ts new file mode 100644 index 0000000..0c7c6a7 --- /dev/null +++ b/index.d.ts @@ -0,0 +1,6 @@ +export { type KnownClassConstructor, type KnownConstructor, type AlpineComponentConstructor, type AlpineDataContext, type AlpineData, AlpineComponent } from './src/Component'; +export { type ComponentList, ComponentStore, transformToAlpineData, makeAlpineConstructor } from './src/Store'; +export * as Globals from './src/Global'; +export { AlpineComponents, componentsPlugin } from './src/Plugin'; +import { componentsPlugin } from './src/Plugin'; +export default componentsPlugin; diff --git a/index.js b/index.js new file mode 100644 index 0000000..b3d2128 --- /dev/null +++ b/index.js @@ -0,0 +1,7 @@ +export { AlpineComponent } from './src/Component'; +export { ComponentStore, transformToAlpineData, makeAlpineConstructor } from './src/Store'; +export * as Globals from './src/Global'; +export { AlpineComponents, componentsPlugin } from './src/Plugin'; +import { componentsPlugin } from './src/Plugin'; +export default componentsPlugin; +//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyJpbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFJQSxPQUFPLEVBTU4sZUFBZSxFQUNmLE1BQU0saUJBQWlCLENBQUE7QUFFeEIsT0FBTyxFQUVOLGNBQWMsRUFDZCxxQkFBcUIsRUFDckIscUJBQXFCLEVBQ3JCLE1BQU0sYUFBYSxDQUFBO0FBRXBCLE9BQU8sS0FBSyxPQUFPLE1BQU0sY0FBYyxDQUFDO0FBRXhDLE9BQU8sRUFDTixnQkFBZ0IsRUFDaEIsZ0JBQWdCLEVBQ2hCLE1BQU0sY0FBYyxDQUFDO0FBTXRCLE9BQU8sRUFBQyxnQkFBZ0IsRUFBQyxNQUFNLGNBQWMsQ0FBQztBQUM5QyxlQUFlLGdCQUFnQixDQUFDIn0= \ No newline at end of file diff --git a/src/Component.d.ts b/src/Component.d.ts new file mode 100644 index 0000000..9804e51 --- /dev/null +++ b/src/Component.d.ts @@ -0,0 +1,19 @@ +export type KnownClassConstructor = new (...args: any[]) => T; +export type KnownGenericConstructor = (...args: any[]) => T; +export type KnownConstructor = KnownGenericConstructor | KnownClassConstructor; +export type AlpineComponentConstructor = (...args: any[]) => any; +export declare interface AlpineDataContext { + init?(): void; + [stateKey: string]: any; +} +export declare type AlpineData = AlpineDataContext | string | number | boolean; +export declare abstract class AlpineComponent implements AlpineDataContext { + $data: this; + $el: HTMLElement; + $refs: Record; + $store: AlpineData; + $dispatch: (event: string, data?: any) => void; + $id: (name: string, key?: number | string) => string; + $nextTick: (callback?: () => void) => Promise; + $watch: (property: K, callback: (newValue: V, oldValue: V) => void) => void; +} diff --git a/src/Component.js b/src/Component.js new file mode 100644 index 0000000..f685936 --- /dev/null +++ b/src/Component.js @@ -0,0 +1,7 @@ +var AlpineComponent = (function () { + function AlpineComponent() { + } + return AlpineComponent; +}()); +export { AlpineComponent }; +//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiQ29tcG9uZW50LmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiQ29tcG9uZW50LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQTRDQTtJQUFBO0lBd0RBLENBQUM7SUFBRCxzQkFBQztBQUFELENBQUMsQUF4REQsSUF3REMifQ== \ No newline at end of file diff --git a/src/Global.d.ts b/src/Global.d.ts new file mode 100644 index 0000000..bc06de1 --- /dev/null +++ b/src/Global.d.ts @@ -0,0 +1,15 @@ +import type { Alpine as AlpineType } from 'alpinejs'; +import type { ComponentStore } from "./Store"; +import type { AlpineComponentConstructor } from "./Component"; +export declare interface AlpineComponentMixins { + Components: ComponentStore; + component: (name: string) => AlpineComponentConstructor; +} +export declare type AlpineWithComponents = AlpineType & AlpineComponentMixins; +export declare type Alpine = AlpineType | AlpineWithComponents; +declare global { + interface Window { + Alpine: Alpine; + AlpineComponents: ComponentStore; + } +} diff --git a/src/Global.js b/src/Global.js new file mode 100644 index 0000000..9c3a2b4 --- /dev/null +++ b/src/Global.js @@ -0,0 +1,2 @@ +export {}; +//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiR2xvYmFsLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiR2xvYmFsLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiIifQ== \ No newline at end of file diff --git a/src/Plugin.d.ts b/src/Plugin.d.ts new file mode 100644 index 0000000..c488b53 --- /dev/null +++ b/src/Plugin.d.ts @@ -0,0 +1,12 @@ +import type * as Globals from './Global'; +import { type ComponentList } from "./Store"; +export declare namespace AlpineComponents { + interface Options { + components: ComponentList; + startAlpine: boolean; + logErrors: boolean; + } + const defaultOptions: Options; + function bootstrap(options?: Partial, alpine?: Globals.Alpine): void; +} +export declare function componentsPlugin(alpine: Globals.Alpine): void; diff --git a/src/Plugin.js b/src/Plugin.js new file mode 100644 index 0000000..ab8bbb0 --- /dev/null +++ b/src/Plugin.js @@ -0,0 +1,36 @@ +var __assign = (this && this.__assign) || function () { + __assign = Object.assign || function(t) { + for (var s, i = 1, n = arguments.length; i < n; i++) { + s = arguments[i]; + for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) + t[p] = s[p]; + } + return t; + }; + return __assign.apply(this, arguments); +}; +import { ComponentStore } from "./Store"; +export var AlpineComponents; +(function (AlpineComponents) { + AlpineComponents.defaultOptions = { + components: {}, + startAlpine: true, + logErrors: false + }; + function bootstrap(options, alpine) { + if (options === void 0) { options = AlpineComponents.defaultOptions; } + if (alpine === void 0) { alpine = window.Alpine; } + var opts = __assign(__assign({}, AlpineComponents.defaultOptions), options); + window.AlpineComponents = new ComponentStore(alpine, opts.components, opts.logErrors); + if (opts.startAlpine) { + alpine.start(); + } + } + AlpineComponents.bootstrap = bootstrap; +})(AlpineComponents || (AlpineComponents = {})); +export function componentsPlugin(alpine) { + AlpineComponents.bootstrap({ + startAlpine: false + }, alpine); +} +//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiUGx1Z2luLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiUGx1Z2luLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7Ozs7Ozs7Ozs7O0FBQ0EsT0FBTyxFQUVOLGNBQWMsRUFDZCxNQUFNLFNBQVMsQ0FBQztBQUVqQixNQUFNLEtBQVcsZ0JBQWdCLENBOEJoQztBQTlCRCxXQUFpQixnQkFBZ0I7SUFRbkIsK0JBQWMsR0FBWTtRQUN0QyxVQUFVLEVBQUUsRUFBRTtRQUNkLFdBQVcsRUFBRSxJQUFJO1FBQ2pCLFNBQVMsRUFBRSxLQUFLO0tBQ2hCLENBQUM7SUFFRixTQUFnQixTQUFTLENBQ3hCLE9BQTBDLEVBQzFDLE1BQXNDO1FBRHRDLHdCQUFBLEVBQUEsVUFBNEIsK0JBQWM7UUFDMUMsdUJBQUEsRUFBQSxTQUF5QixNQUFNLENBQUMsTUFBTTtRQUV0QyxJQUFNLElBQUkseUJBQ04saUJBQUEsY0FBYyxHQUNkLE9BQU8sQ0FDVixDQUFDO1FBRUYsTUFBTSxDQUFDLGdCQUFnQixHQUFHLElBQUksY0FBYyxDQUFDLE1BQU0sRUFBRSxJQUFJLENBQUMsVUFBVSxFQUFFLElBQUksQ0FBQyxTQUFTLENBQUMsQ0FBQztRQUV0RixJQUFJLElBQUksQ0FBQyxXQUFXLEVBQUU7WUFDckIsTUFBTSxDQUFDLEtBQUssRUFBRSxDQUFDO1NBQ2Y7SUFDRixDQUFDO0lBZGUsMEJBQVMsWUFjeEIsQ0FBQTtBQUVGLENBQUMsRUE5QmdCLGdCQUFnQixLQUFoQixnQkFBZ0IsUUE4QmhDO0FBT0QsTUFBTSxVQUFVLGdCQUFnQixDQUFDLE1BQXNCO0lBQ3RELGdCQUFnQixDQUFDLFNBQVMsQ0FBQztRQUMxQixXQUFXLEVBQUUsS0FBSztLQUNsQixFQUFFLE1BQU0sQ0FBQyxDQUFDO0FBQ1osQ0FBQyJ9 \ No newline at end of file diff --git a/src/Store.d.ts b/src/Store.d.ts new file mode 100644 index 0000000..44b541d --- /dev/null +++ b/src/Store.d.ts @@ -0,0 +1,24 @@ +import type * as Impl from "./Component"; +import type * as Globals from './Global'; +import { AlpineComponent } from "./Component"; +export type ComponentList = { + [name: string]: Impl.KnownConstructor; +}; +export declare class ComponentStore { + private alpine; + private logErrors; + private initialized; + private components; + constructor(alpine: Globals.Alpine, components?: ComponentList, logErrors?: boolean); + private init; + component(name: string): Impl.AlpineComponentConstructor; + registerAll(components: ComponentList): void; + register(name: string, component: Impl.KnownConstructor): void; + register(component: Impl.KnownClassConstructor, name?: string): void; + private registerConstructorAsAlpineData; + private static getObjectData; + private static getClassData; + private logRegisterFailure; +} +export declare function transformToAlpineData(instance: T): object; +export declare function makeAlpineConstructor(component: Impl.KnownClassConstructor): Impl.AlpineComponentConstructor; diff --git a/src/Store.js b/src/Store.js new file mode 100644 index 0000000..af07e10 --- /dev/null +++ b/src/Store.js @@ -0,0 +1,159 @@ +var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) { + if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) { + if (ar || !(i in from)) { + if (!ar) ar = Array.prototype.slice.call(from, 0, i); + ar[i] = from[i]; + } + } + return to.concat(ar || Array.prototype.slice.call(from)); +}; +import { AlpineComponent } from "./Component"; +var ReservedNames = ['abstract', 'arguments', 'await', 'boolean', 'break', 'byte', 'case', + 'catch', 'char', 'class', 'const', 'continue', 'debugger', 'default', 'delete', 'do', 'double', 'else', + 'enum', 'eval', 'export', 'extends', 'false', 'final', 'finally', 'float', 'for', 'function', 'goto', + 'if', 'implements', 'import', 'in', 'instanceof', 'int', 'interface', 'let', 'long', 'native', 'new', + 'null', 'package', 'private', 'protected', 'public', 'return', 'short', 'static', 'super', 'switch', + 'this', 'throw', 'throws', 'transient', 'true', 'try', 'typeof', 'var', 'void', 'volatile', 'while', + 'with', 'yield']; +var RegisterComponentFailure; +(function (RegisterComponentFailure) { + RegisterComponentFailure[RegisterComponentFailure["GenericMustHaveFunctionAsSecond"] = 0] = "GenericMustHaveFunctionAsSecond"; + RegisterComponentFailure[RegisterComponentFailure["NameMustBeProvidedForComponentWithNoDefault"] = 1] = "NameMustBeProvidedForComponentWithNoDefault"; + RegisterComponentFailure[RegisterComponentFailure["UnknownArgumentTypes"] = 2] = "UnknownArgumentTypes"; + RegisterComponentFailure[RegisterComponentFailure["ReservedName"] = 3] = "ReservedName"; +})(RegisterComponentFailure || (RegisterComponentFailure = {})); +var ComponentStore = (function () { + function ComponentStore(alpine, components, logErrors) { + var _this = this; + if (components === void 0) { components = {}; } + if (logErrors === void 0) { logErrors = false; } + this.alpine = alpine; + this.logErrors = logErrors; + this.initialized = false; + this.components = {}; + Object.entries(components).forEach(function (_a) { + var name = _a[0], component = _a[1]; + _this.register(name, component); + }); + window.addEventListener('alpine:init', function () { + _this.init(); + }); + } + ComponentStore.prototype.init = function () { + var _this = this; + if (this.initialized) { + return; + } + this.alpine.Components = this; + this.alpine.component = this.component; + document.dispatchEvent(new CustomEvent('alpine-components:init')); + Object.entries(this.components) + .forEach(function (_a) { + var name = _a[0]; + return _this.registerConstructorAsAlpineData(name); + }); + this.initialized = true; + }; + ComponentStore.prototype.component = function (name) { + return this.components[name]; + }; + ComponentStore.prototype.registerAll = function (components) { + var _this = this; + Object.entries(components) + .forEach(function (_a) { + var name = _a[0], component = _a[1]; + return _this.register(name, component); + }); + }; + ComponentStore.prototype.register = function (nameOrComponentClass, constructorOrComponentName) { + if (constructorOrComponentName === void 0) { constructorOrComponentName = ''; } + var component; + if (typeof nameOrComponentClass === 'string') { + if (typeof constructorOrComponentName === 'string') { + this.logRegisterFailure(RegisterComponentFailure.GenericMustHaveFunctionAsSecond); + return; + } + component = ComponentStore.getObjectData(nameOrComponentClass, constructorOrComponentName); + } + else if (typeof nameOrComponentClass === 'function') { + component = ComponentStore.getClassData(nameOrComponentClass, constructorOrComponentName); + if (component.name === "") { + this.logRegisterFailure(RegisterComponentFailure.NameMustBeProvidedForComponentWithNoDefault); + } + } + else { + this.logRegisterFailure(RegisterComponentFailure.UnknownArgumentTypes); + return; + } + if (ReservedNames.includes(component.name)) { + this.logRegisterFailure(RegisterComponentFailure.ReservedName); + } + this.components[component.name] = component.constructor; + if (this.initialized) { + this.registerConstructorAsAlpineData(component.name); + } + }; + ComponentStore.prototype.registerConstructorAsAlpineData = function (name) { + this.alpine.data(name, this.component(name)); + }; + ComponentStore.getObjectData = function (name, component) { + return { + name: name, + constructor: ((component.prototype instanceof AlpineComponent) ? + makeAlpineConstructor(component) : component) + }; + }; + ComponentStore.getClassData = function (component, name) { + var resolvedName = (name !== undefined ? name : component.prototype.name); + return { + name: resolvedName, + constructor: makeAlpineConstructor(component) + }; + }; + ComponentStore.prototype.logRegisterFailure = function (reason) { + if (!this.logErrors) { + return; + } + switch (reason) { + case RegisterComponentFailure.GenericMustHaveFunctionAsSecond: + console.error("Second argument must be a constructor function for component."); + break; + case RegisterComponentFailure.NameMustBeProvidedForComponentWithNoDefault: + console.error("Component name must be provided when class doesn't specify a default."); + break; + case RegisterComponentFailure.UnknownArgumentTypes: + console.error("Cannot register component with provided argument types. Check Typescript definitions for usage."); + break; + case RegisterComponentFailure.ReservedName: + console.error("Cannot register component with name matching a reserved keyword."); + break; + } + }; + return ComponentStore; +}()); +export { ComponentStore }; +export function transformToAlpineData(instance) { + var methodNames = []; + for (var prototype = Object.getPrototypeOf(instance); prototype.constructor.name !== 'Object'; prototype = Object.getPrototypeOf(prototype)) { + Object.getOwnPropertyNames(prototype).forEach(function (name) { + if (methodNames.includes(name)) { + return; + } + methodNames.push(name); + }); + } + return __spreadArray(__spreadArray([], methodNames, true), Object.getOwnPropertyNames(instance), true).reduce(function (obj, name) { + obj[name] = instance[name]; + return obj; + }, {}); +} +export function makeAlpineConstructor(component) { + return function () { + var args = []; + for (var _i = 0; _i < arguments.length; _i++) { + args[_i] = arguments[_i]; + } + return transformToAlpineData(new (component.bind.apply(component, __spreadArray([void 0], args, false)))()); + }; +} +//# sourceMappingURL=data:application/json;base64,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 \ No newline at end of file