@vnejs/module 0.0.14 → 0.0.15

package/dist/index.d.ts

@@ -0,0 +1,39 @@
+import type { Observer } from "@vnejs/observer";
+import type { VnePluginConstantsMapRegistry, VnePluginEventsMapRegistry, VnePluginParamsMapRegistry, VnePluginSettingsMapRegistry } from "@vnejs/shared";
+export type { ModuleGlobalState, ModuleGlobalStateRegistry, ModuleInject, ModuleMedia, ModuleShared } from "./types.js";
+import type { ModuleGlobalStateRegistry, ModuleInject, ModuleMedia, ModuleShared } from "./types.js";
+export declare class Module {
+    isReady: boolean;
+    isOnlyLocalState: boolean;
+    EVENTS: VnePluginEventsMapRegistry;
+    CONST: VnePluginConstantsMapRegistry;
+    SETTINGS: VnePluginSettingsMapRegistry;
+    PARAMS: VnePluginParamsMapRegistry;
+    observer?: Observer;
+    on: (...args: Parameters<Observer["subscribe"]>) => undefined;
+    emit: (...args: Parameters<Observer["emit"]>) => Promise<unknown[]> | undefined;
+    emitOne: (...args: Parameters<Observer["emitOne"]>) => Promise<unknown> | undefined;
+    emitReal: (...args: Parameters<Observer["emitReal"]>) => Promise<unknown> | undefined;
+    shared?: ModuleShared;
+    media?: ModuleMedia;
+    name: string;
+    globalState: ModuleGlobalStateRegistry;
+    state: unknown;
+    inject: ({ observer, state, shared, media }?: ModuleInject) => void;
+    subscribe: () => void;
+    init: () => Promise<void>;
+    setState: (state?: unknown) => void;
+    updateState: (state?: Record<string, unknown>) => void;
+    setDefaultState: () => void;
+    setStateFromGlobalState: ({ [this.name]: state }: ModuleGlobalStateRegistry) => void;
+    getState: () => unknown;
+    getDefaultState: () => {};
+    waitCheck: (checkFunc: () => boolean) => Promise<void>;
+    waitRerenderCheck: (checkFunc: () => boolean) => Promise<void>;
+    waitIsReady: () => Promise<void>;
+    waitTimeout: (time: number) => Promise<void>;
+    waitImmediate: () => Promise<void>;
+    waitRender: () => Promise<number>;
+    waitRerender: () => Promise<void>;
+    getIsReady: () => boolean;
+}

package/dist/index.js

@@ -0,0 +1,62 @@
+import { VNE } from "@vnejs/shared";
+export class Module {
+    isReady = false;
+    isOnlyLocalState = false;
+    EVENTS = VNE.EVENTS;
+    CONST = VNE.CONST;
+    SETTINGS = VNE.SETTINGS;
+    PARAMS = VNE.PARAMS;
+    observer;
+    on = (...args) => this.observer?.subscribe(...args);
+    emit = (...args) => this.observer?.emit(...args);
+    emitOne = (...args) => this.observer?.emitOne(...args);
+    emitReal = (...args) => this.observer?.emitReal(...args);
+    shared;
+    media;
+    name;
+    globalState;
+    state;
+    inject = ({ observer, state, shared, media } = {}) => {
+        this.observer = observer;
+        this.globalState = state ?? {};
+        this.setState(this.getDefaultState() || {});
+        this.shared = shared;
+        this.media = media;
+    }; // abstract
+    subscribe = () => { }; // implement
+    init = async () => { }; // implement
+    setState = (state = {}) => {
+        if (this.isOnlyLocalState) {
+            this.state = state;
+        }
+        else {
+            this.globalState[this.name] = state;
+            this.state = this.globalState[this.name];
+        }
+    }; // abstract
+    updateState = (state = {}) => this.setState({ ...this.state, ...state });
+    setDefaultState = () => this.setState(this.getDefaultState());
+    setStateFromGlobalState = ({ [this.name]: state }) => this.setState(state);
+    getState = () => this.state;
+    getDefaultState = () => ({}); // implement
+    waitCheck = async (checkFunc) => {
+        while (!checkFunc())
+            await this.waitTimeout(0);
+    };
+    waitRerenderCheck = async (checkFunc) => {
+        while (!checkFunc())
+            await this.waitRerender();
+    };
+    waitIsReady = () => this.waitCheck(this.getIsReady);
+    waitTimeout = (time) => new Promise((resolve) => setTimeout(resolve, time));
+    waitImmediate = () => new Promise((resolve) => {
+        const maybeSetImmediate = globalThis.setImmediate;
+        if (typeof maybeSetImmediate === "function")
+            maybeSetImmediate(resolve);
+        else
+            setTimeout(resolve, 0);
+    });
+    waitRender = () => new Promise((resolve) => requestAnimationFrame(resolve));
+    waitRerender = () => new Promise((resolve) => requestAnimationFrame(() => setTimeout(resolve, 0)));
+    getIsReady = () => this.isReady;
+}

package/dist/types.d.ts

@@ -0,0 +1,29 @@
+import type { Observer } from "@vnejs/observer";
+/**
+ * Extend in consumer packages via module augmentation:
+ *
+ * @example
+ * declare module "@vnejs/module" {
+ *   interface ModuleShared {
+ *     settings: Record<string, unknown>;
+ *     lang: string;
+ *   }
+ *   interface ModuleGlobalState {
+ *     text: { tokens: string[] };
+ *   }
+ * }
+ */
+export interface ModuleShared {
+}
+/** Global module state registry; defaults to string-keyed records per module name. */
+export interface ModuleGlobalState {
+}
+export type ModuleGlobalStateRegistry = ModuleGlobalState & Record<string, unknown>;
+/** Media bucket id → path/key → url or asset path. */
+export type ModuleMedia = Record<string, Record<string, string>>;
+export type ModuleInject = {
+    observer?: Observer;
+    state?: ModuleGlobalStateRegistry;
+    shared?: ModuleShared;
+    media?: ModuleMedia;
+};

package/dist/types.js

@@ -0,0 +1 @@
+export {};

package/package.json

@@ -1,19 +1,26 @@
 {
   "name": "@vnejs/module",
-  "version": "0.0.14",
+  "version": "0.0.15",
   "description": "",
-  "main": "index.js",
-  "types": "index.d.ts",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "files": [
+    "dist"
+  ],
   "scripts": {
     "test": "echo \"Error: no test specified\" && exit 1",
-    "build": "tsc -p tsconfig.json",
-    "publish:major": "npm version major && npm publish --access public --legacy-peer-deps",
-    "publish:minor": "npm version minor && npm publish --access public --legacy-peer-deps",
-    "publish:patch": "npm version patch && npm publish --access public --legacy-peer-deps"
+    "build": "rm -rf dist && tsc -p tsconfig.json",
+    "publish:major": "npm run build && npm version major && npm publish --access public --legacy-peer-deps",
+    "publish:minor": "npm run build && npm version minor && npm publish --access public --legacy-peer-deps",
+    "publish:patch": "npm run build && npm version patch && npm publish --access public --legacy-peer-deps"
   },
   "author": "",
   "license": "ISC",
   "peerDependencies": {
+    "@vnejs/observer": "~0.0.1",
     "@vnejs/shared": "~0.0.9"
+  },
+  "devDependencies": {
+    "typescript": "^6.0.3"
   }
 }

package/index.d.ts

@@ -1 +0,0 @@
-export * from "./modules/module";

package/index.js

@@ -1 +0,0 @@
-export * from "./modules/module";

package/index.ts

@@ -1,2 +0,0 @@
-export * from "./modules/module";
-

package/modules/module.d.ts

@@ -1,44 +0,0 @@
-import type { VnePluginConstants, VnePluginEvents, VnePluginParams, VnePluginSettings, VneNamespace } from "@vnejs/shared";
-export type ModuleInject = {
-    on?: (...args: unknown[]) => unknown;
-    emit?: (...args: unknown[]) => unknown;
-    emitOne?: (...args: unknown[]) => unknown;
-    emitReal?: (...args: unknown[]) => unknown;
-    state?: Record<string, unknown>;
-    shared?: unknown;
-    media?: unknown;
-};
-export declare class Module {
-    isReady: boolean;
-    isOnlyLocalState: boolean;
-    EVENTS: Record<VneNamespace, VnePluginEvents>;
-    CONST: Record<VneNamespace, VnePluginConstants>;
-    SETTINGS: Record<VneNamespace, VnePluginSettings>;
-    PARAMS: Record<VneNamespace, VnePluginParams>;
-    on?: ModuleInject["on"];
-    emit?: ModuleInject["emit"];
-    emitOne?: ModuleInject["emitOne"];
-    emitReal?: ModuleInject["emitReal"];
-    shared?: unknown;
-    media?: unknown;
-    name: string;
-    globalState: Record<string, unknown>;
-    state: unknown;
-    inject: ({ on, emit, emitOne, emitReal, state, shared, media }?: ModuleInject) => void;
-    subscribe: () => void;
-    init: () => Promise<void>;
-    setState: (state?: unknown) => void;
-    updateState: (state?: Record<string, unknown>) => void;
-    setDefaultState: () => void;
-    setStateFromGlobalState: ({ [this.name]: state }: Record<string, unknown>) => void;
-    getState: () => unknown;
-    getDefaultState: () => {};
-    waitCheck: (checkFunc: () => boolean) => Promise<void>;
-    waitRerenderCheck: (checkFunc: () => boolean) => Promise<void>;
-    waitIsReady: () => Promise<void>;
-    waitTimeout: (time: number) => Promise<void>;
-    waitImmediate: () => Promise<void>;
-    waitRender: () => Promise<number>;
-    waitRerender: () => Promise<void>;
-    getIsReady: () => boolean;
-}

package/modules/module.js

@@ -1,59 +0,0 @@
-import { VNE } from "@vnejs/shared";
-export class Module {
-    constructor() {
-        this.isReady = false;
-        this.isOnlyLocalState = false;
-        this.EVENTS = VNE.EVENTS;
-        this.CONST = VNE.CONST;
-        this.SETTINGS = VNE.SETTINGS;
-        this.PARAMS = VNE.PARAMS;
-        this.inject = ({ on, emit, emitOne, emitReal, state, shared, media } = {}) => {
-            // observer
-            this.on = on;
-            this.emit = emit;
-            this.emitOne = emitOne;
-            this.emitReal = emitReal;
-            // state
-            this.globalState = state ?? {};
-            this.setState(this.getDefaultState() || {});
-            this.shared = shared;
-            this.media = media;
-        }; // abstract
-        this.subscribe = () => { }; // implement
-        this.init = async () => { }; // implement
-        this.setState = (state = {}) => {
-            if (this.isOnlyLocalState) {
-                this.state = state;
-            }
-            else {
-                this.globalState[this.name] = state;
-                this.state = this.globalState[this.name];
-            }
-        }; // abstract
-        this.updateState = (state = {}) => this.setState({ ...this.state, ...state });
-        this.setDefaultState = () => this.setState(this.getDefaultState());
-        this.setStateFromGlobalState = ({ [this.name]: state }) => this.setState(state);
-        this.getState = () => this.state;
-        this.getDefaultState = () => ({}); // implement
-        this.waitCheck = async (checkFunc) => {
-            while (!checkFunc())
-                await this.waitTimeout(0);
-        };
-        this.waitRerenderCheck = async (checkFunc) => {
-            while (!checkFunc())
-                await this.waitRerender();
-        };
-        this.waitIsReady = () => this.waitCheck(this.getIsReady);
-        this.waitTimeout = (time) => new Promise((resolve) => setTimeout(resolve, time));
-        this.waitImmediate = () => new Promise((resolve) => {
-            const maybeSetImmediate = globalThis.setImmediate;
-            if (typeof maybeSetImmediate === "function")
-                maybeSetImmediate(resolve);
-            else
-                setTimeout(resolve, 0);
-        });
-        this.waitRender = () => new Promise((resolve) => requestAnimationFrame(resolve));
-        this.waitRerender = () => new Promise((resolve) => requestAnimationFrame(() => setTimeout(resolve, 0)));
-        this.getIsReady = () => this.isReady;
-    }
-}

package/modules/module.ts

@@ -1,98 +0,0 @@
-import { VNE } from "@vnejs/shared";
-import type { VnePluginConstants, VnePluginEvents, VnePluginParams, VnePluginSettings, VneNamespace } from "@vnejs/shared";
-
-export type ModuleInject = {
-  on?: (...args: unknown[]) => unknown;
-  emit?: (...args: unknown[]) => unknown;
-  emitOne?: (...args: unknown[]) => unknown;
-  emitReal?: (...args: unknown[]) => unknown;
-  state?: Record<string, unknown>;
-  shared?: unknown;
-  media?: unknown;
-};
-
-export class Module {
-  isReady = false;
-  isOnlyLocalState = false;
-
-  EVENTS: Record<VneNamespace, VnePluginEvents> = VNE.EVENTS;
-  CONST: Record<VneNamespace, VnePluginConstants> = VNE.CONST;
-  SETTINGS: Record<VneNamespace, VnePluginSettings> = VNE.SETTINGS;
-  PARAMS: Record<VneNamespace, VnePluginParams> = VNE.PARAMS;
-
-  // runtime-injected
-  on?: ModuleInject["on"];
-  emit?: ModuleInject["emit"];
-  emitOne?: ModuleInject["emitOne"];
-  emitReal?: ModuleInject["emitReal"];
-
-  shared?: unknown;
-  media?: unknown;
-
-  name!: string;
-  globalState!: Record<string, unknown>;
-  state!: unknown;
-
-  inject = ({ on, emit, emitOne, emitReal, state, shared, media }: ModuleInject = {}) => {
-    // observer
-    this.on = on;
-    this.emit = emit;
-    this.emitOne = emitOne;
-    this.emitReal = emitReal;
-
-    // state
-    this.globalState = state ?? {};
-    this.setState(this.getDefaultState() || {});
-
-    this.shared = shared;
-    this.media = media;
-  }; // abstract
-
-  subscribe = () => {}; // implement
-
-  init = async () => {}; // implement
-
-  setState = (state: unknown = {}) => {
-    if (this.isOnlyLocalState) {
-      this.state = state;
-    } else {
-      this.globalState[this.name] = state;
-      this.state = this.globalState[this.name];
-    }
-  }; // abstract
-
-  updateState = (state: Record<string, unknown> = {}) => this.setState({ ...(this.state as Record<string, unknown>), ...state });
-
-  setDefaultState = () => this.setState(this.getDefaultState());
-
-  setStateFromGlobalState = ({ [this.name]: state }: Record<string, unknown>) => this.setState(state);
-
-  getState = () => this.state;
-
-  getDefaultState = () => ({}); // implement
-
-  waitCheck = async (checkFunc: () => boolean) => {
-    while (!checkFunc()) await this.waitTimeout(0);
-  };
-
-  waitRerenderCheck = async (checkFunc: () => boolean) => {
-    while (!checkFunc()) await this.waitRerender();
-  };
-
-  waitIsReady = () => this.waitCheck(this.getIsReady);
-
-  waitTimeout = (time: number) => new Promise<void>((resolve) => setTimeout(resolve, time));
-
-  waitImmediate = () =>
-    new Promise<void>((resolve) => {
-      const maybeSetImmediate = (globalThis as unknown as { setImmediate?: (cb: () => void) => unknown }).setImmediate;
-      if (typeof maybeSetImmediate === "function") maybeSetImmediate(resolve);
-      else setTimeout(resolve, 0);
-    });
-
-  waitRender = () => new Promise<number>((resolve) => requestAnimationFrame(resolve));
-
-  waitRerender = () => new Promise<void>((resolve) => requestAnimationFrame(() => setTimeout(resolve, 0)));
-
-  getIsReady = () => this.isReady;
-}

package/tsconfig.json

@@ -1,15 +0,0 @@
-{
-  "compilerOptions": {
-    "target": "ES2020",
-    "module": "ES2020",
-    "moduleResolution": "Bundler",
-    "strict": true,
-    "skipLibCheck": true,
-    "declaration": true,
-    "noEmitOnError": true,
-    "esModuleInterop": true,
-    "forceConsistentCasingInFileNames": true
-  },
-  "include": ["index.ts", "modules/**/*.ts"]
-}
-