@vnejs/module 0.0.13 → 0.0.14

package/index.d.ts

@@ -1,72 +1 @@
-import { CONST, EVENTS, PARAMS, SETTINGS } from "@vnejs/shared";
-
-declare type GlobalState = {};
-
-declare type SHARED = {};
-
-type OnFunc = (event: string, func: (arg: any) => Promise<any>) => void;
-type EmitFunc = (event: string, arg: any) => Promise<any[]>;
-type EmitOneFunc = (event: string, arg: any) => Promise<any>;
-
-type InjectArg = {
-  on: OnFunc;
-  emit: EmitFunc;
-  emitOne: EmitOneFunc;
-
-  state: GlobalState;
-
-  shared: SHARED;
-  media: Record<string, Record<string, string>>;
-  options: any;
-};
-
-declare type StateType = {};
-
-export class Module {
-  isReady: Boolean;
-
-  CONST: CONST;
-  EVENTS: EVENTS;
-  PARAMS: PARAMS;
-  SETTINGS: SETTINGS;
-
-  on: OnFunc;
-  emit: EmitFunc;
-  emitOne: EmitOneFunc;
-  emitReal: EmitOneFunc;
-
-  globalState: GlobalState;
-  state: StateType;
-
-  shared: SHARED;
-  media: Record<string, Record<string, string>>;
-  options: any;
-
-  inject: (arg: InjectArg) => void; // abstract
-
-  subscribe: () => void;
-  init: () => Promise<void>; // implement
-
-  setState: (state: StateType) => void; // abstract
-  updateState: (state: Partial<StateType>) => void; // abstract
-  setDefaultState: () => void;
-  setStateFromGlobalState: (state: GlobalState) => void;
-  getState: () => StateType;
-  getDefaultState: () => StateType; // implement
-
-  waitCheck: (checkFunc: () => Boolean) => Promise<void>;
-  waitRerenderCheck: (checkFunc: () => Boolean) => Promise<void>;
-  waitIsReady: () => Promise<void>;
-  waitTimeout: (time: number) => Promise<void>;
-  waitImmediate: () => Promise<void>;
-  waitRender: () => Promise<void>;
-  waitRerender: () => Promise<void>;
-
-  getIsReady: () => Boolean;
-}
-
-declare module "@vnejs/shared" {
-  export const VNE_MODULES: Module[];
-
-  export const regModule: (m: Module) => void;
-}
+export * from "./modules/module";

package/index.ts

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

package/modules/module.d.ts

@@ -0,0 +1,44 @@
+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,62 +1,59 @@
 import { VNE } from "@vnejs/shared";
-
 export class Module {
-  isReady = false;
-  isOnlyLocalState = false;
-
-  EVENTS = VNE.EVENTS;
-  CONST = VNE.CONST;
-  SETTINGS = VNE.SETTINGS;
-  PARAMS = VNE.PARAMS;
-
-  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
-  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];
+    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;
     }
-  }; // 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(setImmediate);
-  waitRender = () => new Promise(requestAnimationFrame);
-  waitRerender = () => new Promise((resolve) => requestAnimationFrame(() => setTimeout(resolve, 0)));
-
-  getIsReady = () => this.isReady;
 }

package/modules/module.ts

@@ -0,0 +1,98 @@
+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/package.json

@@ -1,17 +1,19 @@
 {
   "name": "@vnejs/module",
-  "version": "0.0.13",
+  "version": "0.0.14",
   "description": "",
   "main": "index.js",
+  "types": "index.d.ts",
   "scripts": {
     "test": "echo \"Error: no test specified\" && exit 1",
-    "publish:major": "npm version major && npm publish --access public",
-    "publish:minor": "npm version minor && npm publish --access public",
-    "publish:patch": "npm version patch && npm publish --access public"
+    "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"
   },
   "author": "",
   "license": "ISC",
   "peerDependencies": {
-    "@vnejs/shared": "~0.0.8"
+    "@vnejs/shared": "~0.0.9"
   }
 }

package/tsconfig.json

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

package/shared.d.ts

@@ -1,7 +0,0 @@
-import { Module } from ".";
-
-declare module "@vnejs/shared" {
-  export const VNE_MODULES: Module[];
-
-  export const regModule: (m: Module) => void;
-}