phecda-module 1.0.0

package/.turbo/turbo-build.log

@@ -0,0 +1,22 @@
+ WARN  Issue while reading "/home/runner/work/phecda/phecda/.npmrc". Failed to replace env in config: ${NPM_TOKEN}
+
+> phecda-module@1.0.0 build /home/runner/work/phecda/phecda/packages/module
+> tsup
+
+CLI Building entry: src/index.ts, src/vite.ts
+CLI Using tsconfig: ../../tsconfig.json
+CLI tsup v6.5.0
+CLI Using tsup config: /home/runner/work/phecda/phecda/packages/module/tsup.config.ts
+CLI Target: esnext
+CJS Build start
+ESM Build start
+ESM dist/index.mjs 1.91 KB
+ESM dist/vite.mjs  519.00 B
+ESM ⚡️ Build success in 99ms
+CJS dist/index.js 3.13 KB
+CJS dist/vite.js  1.42 KB
+CJS ⚡️ Build success in 101ms
+DTS Build start
+DTS ⚡️ Build success in 3602ms
+DTS dist/index.d.ts 186.00 B
+DTS dist/vite.d.ts  210.00 B

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2022 fgsreally
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/index.d.ts

@@ -0,0 +1,6 @@
+export * from 'phecda-core';
+
+declare const moduleMap: Map<string, any>;
+declare function Factory(Modules: (new (...args: any) => any)[]): Promise<void>;
+
+export { Factory, moduleMap };

package/dist/index.js

@@ -0,0 +1,96 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  Factory: () => Factory,
+  moduleMap: () => moduleMap
+});
+module.exports = __toCommonJS(src_exports);
+
+// src/core.ts
+var import_phecda_core = require("phecda-core");
+var import_reflect_metadata = require("reflect-metadata");
+var moduleMap = /* @__PURE__ */ new Map();
+async function Factory(Modules) {
+  for (const Module of Modules)
+    await buildNestModule(Module);
+}
+__name(Factory, "Factory");
+if (__DEV__) {
+  window.__PHECDA_MODULE_UPDATE__ = (target) => {
+    target = Object.values(target)[0];
+    const tag = target.prototype?.__TAG__ || target.name;
+    const module2 = moduleMap.get(tag);
+    module2.destroy?.();
+    moduleMap.delete(tag);
+    buildNestModule(target);
+  };
+}
+async function buildNestModule(Module) {
+  const paramtypes = getParamtypes(Module);
+  let instance;
+  const tag = Module.prototype?.__TAG__ || Module.name;
+  if (moduleMap.has(tag)) {
+    instance = moduleMap.get(tag);
+    if (!instance)
+      throw new Error(`exist Circular-Dependency or Multiple modules with the same name/tag [tag] ${tag}--[module] ${Module}`);
+    return instance;
+  }
+  moduleMap.set(tag, void 0);
+  if (paramtypes) {
+    const paramtypesInstances = [];
+    for (const i in paramtypes)
+      paramtypesInstances[i] = await buildNestModule(paramtypes[i]);
+    instance = new Module(...paramtypesInstances);
+  } else {
+    instance = new Module();
+  }
+  await (0, import_phecda_core.registerAsync)(instance);
+  moduleMap.set(tag, instance);
+  if (__DEV__) {
+    const proxy = new Proxy({}, {
+      get(_target, p) {
+        return moduleMap.get(tag)[p];
+      },
+      set(_target, p, value) {
+        moduleMap.get(tag)[p] = value;
+        return true;
+      }
+    });
+    return proxy;
+  }
+  return instance;
+}
+__name(buildNestModule, "buildNestModule");
+function getParamtypes(Module, key) {
+  return Reflect.getMetadata("design:paramtypes", Module, key);
+}
+__name(getParamtypes, "getParamtypes");
+
+// src/index.ts
+__reExport(src_exports, require("phecda-core"), module.exports);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Factory,
+  moduleMap
+});

package/dist/index.mjs

@@ -0,0 +1,69 @@
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+
+// src/core.ts
+import { registerAsync } from "phecda-core";
+import "reflect-metadata";
+var moduleMap = /* @__PURE__ */ new Map();
+async function Factory(Modules) {
+  for (const Module of Modules)
+    await buildNestModule(Module);
+}
+__name(Factory, "Factory");
+if (__DEV__) {
+  window.__PHECDA_MODULE_UPDATE__ = (target) => {
+    target = Object.values(target)[0];
+    const tag = target.prototype?.__TAG__ || target.name;
+    const module = moduleMap.get(tag);
+    module.destroy?.();
+    moduleMap.delete(tag);
+    buildNestModule(target);
+  };
+}
+async function buildNestModule(Module) {
+  const paramtypes = getParamtypes(Module);
+  let instance;
+  const tag = Module.prototype?.__TAG__ || Module.name;
+  if (moduleMap.has(tag)) {
+    instance = moduleMap.get(tag);
+    if (!instance)
+      throw new Error(`exist Circular-Dependency or Multiple modules with the same name/tag [tag] ${tag}--[module] ${Module}`);
+    return instance;
+  }
+  moduleMap.set(tag, void 0);
+  if (paramtypes) {
+    const paramtypesInstances = [];
+    for (const i in paramtypes)
+      paramtypesInstances[i] = await buildNestModule(paramtypes[i]);
+    instance = new Module(...paramtypesInstances);
+  } else {
+    instance = new Module();
+  }
+  await registerAsync(instance);
+  moduleMap.set(tag, instance);
+  if (__DEV__) {
+    const proxy = new Proxy({}, {
+      get(_target, p) {
+        return moduleMap.get(tag)[p];
+      },
+      set(_target, p, value) {
+        moduleMap.get(tag)[p] = value;
+        return true;
+      }
+    });
+    return proxy;
+  }
+  return instance;
+}
+__name(buildNestModule, "buildNestModule");
+function getParamtypes(Module, key) {
+  return Reflect.getMetadata("design:paramtypes", Module, key);
+}
+__name(getParamtypes, "getParamtypes");
+
+// src/index.ts
+export * from "phecda-core";
+export {
+  Factory,
+  moduleMap
+};

package/dist/vite.d.ts

@@ -0,0 +1,8 @@
+declare function export_default(reg?: RegExp): {
+    name: string;
+    enforce: string;
+    apply: string;
+    transform(code: string, id: string): string | undefined;
+};
+
+export { export_default as default };

package/dist/vite.js

@@ -0,0 +1,43 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/vite.ts
+var vite_exports = {};
+__export(vite_exports, {
+  default: () => vite_default
+});
+module.exports = __toCommonJS(vite_exports);
+function vite_default(reg = /\.module\.ts$/) {
+  return {
+    name: "phecda-module-hmr",
+    enforce: "pre",
+    apply: "serve",
+    transform(code, id) {
+      if (reg.test(id)) {
+        return code += `
+if (import.meta.hot)
+    import.meta.hot.accept(__PHECDA_MODULE_UPDATE__)`;
+      }
+    }
+  };
+}
+__name(vite_default, "default");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {});

package/dist/vite.mjs

@@ -0,0 +1,22 @@
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+
+// src/vite.ts
+function vite_default(reg = /\.module\.ts$/) {
+  return {
+    name: "phecda-module-hmr",
+    enforce: "pre",
+    apply: "serve",
+    transform(code, id) {
+      if (reg.test(id)) {
+        return code += `
+if (import.meta.hot)
+    import.meta.hot.accept(__PHECDA_MODULE_UPDATE__)`;
+      }
+    }
+  };
+}
+__name(vite_default, "default");
+export {
+  vite_default as default
+};

package/package.json

@@ -0,0 +1,39 @@
+{
+  "name": "phecda-module",
+  "version": "1.0.0",
+  "description": "provide DI and HMR for modules by reflect-metadata and vite",
+  "main": "dist/index.js",
+  "module": "dist/index.mjs",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": "./dist/index.mjs",
+      "require": "./dist/index.js"
+    },
+    "./vite": {
+      "import": "./dist/vite.mjs",
+      "require": "./dist/vite.js"
+    }
+  },
+  "typesVersions": {
+    "*": {
+      "vite": [
+        "dist/vite.d.ts"
+      ]
+    }
+  },
+  "keywords": [],
+  "author": "",
+  "license": "ISC",
+  "dependencies": {
+    "reflect-metadata": "^0.1.13",
+    "phecda-core": "2.0.0-alpha.7"
+  },
+  "devDependencies": {
+    "tsup": "^6.5.0"
+  },
+  "scripts": {
+    "dev": "tsup --watch",
+    "build": "tsup"
+  }
+}

package/src/core.ts

@@ -0,0 +1,69 @@
+import { registerAsync } from 'phecda-core'
+import 'reflect-metadata'
+
+type Construct<T = any> = new (...args: any[]) => T
+
+export const moduleMap = new Map<string, InstanceType<Construct>>()
+
+export async function Factory(Modules: (new (...args: any) => any)[]) {
+  for (const Module of Modules)
+    await buildNestModule(Module)
+}
+
+if (__DEV__) {
+  // @ts-expect-error work for hmr
+  window.__PHECDA_MODULE_UPDATE__ = (target) => {
+    target = Object.values(target)[0]
+    const tag = target.prototype?.__TAG__ || target.name
+    const module = moduleMap.get(tag)
+    module.destroy?.()
+    moduleMap.delete(tag)
+    buildNestModule(target)
+  }
+}
+
+async function buildNestModule(Module: Construct) {
+  const paramtypes = getParamtypes(Module) as Construct[]
+
+  let instance: InstanceType<Construct>
+  const tag = Module.prototype?.__TAG__ || Module.name
+
+  if (moduleMap.has(tag)) {
+    instance = moduleMap.get(tag)
+    if (!instance)
+      throw new Error(`exist Circular-Dependency or Multiple modules with the same name/tag [tag] ${tag}--[module] ${Module}`)
+
+    return instance
+  }
+  moduleMap.set(tag, undefined)
+  if (paramtypes) {
+    const paramtypesInstances = [] as any[]
+    for (const i in paramtypes)
+      paramtypesInstances[i] = await buildNestModule(paramtypes[i])
+
+    instance = new Module(...paramtypesInstances)
+  }
+  else {
+    instance = new Module()
+  }
+  await registerAsync(instance)
+  moduleMap.set(tag, instance)
+  if (__DEV__) {
+    const proxy = new Proxy({}, {
+      get(_target, p) {
+        return moduleMap.get(tag)[p]
+      },
+      set(_target, p, value) {
+        moduleMap.get(tag)[p] = value
+        return true
+      },
+    })
+
+    return proxy
+  }
+  return instance
+}
+
+function getParamtypes(Module: any, key?: string | symbol) {
+  return Reflect.getMetadata('design:paramtypes', Module, key!)
+}

package/src/index.ts

@@ -0,0 +1,2 @@
+export * from './core'
+export * from 'phecda-core'

package/src/vite.ts

@@ -0,0 +1,13 @@
+export default function (reg = /\.module\.ts$/) {
+  return {
+    name: 'phecda-module-hmr',
+    enforce: 'pre',
+    apply: 'serve',
+    transform(code: string, id: string) {
+      if (reg.test(id)) {
+        return code += `\nif (import.meta.hot)
+    import.meta.hot.accept(__PHECDA_MODULE_UPDATE__)`
+      }
+    },
+  }
+}

package/tsup.config.ts

@@ -0,0 +1,9 @@
+import type { Options } from 'tsup'
+
+export const tsup: Options = {
+  entry: ['src/index.ts', 'src/vite.ts'],
+  format: ['cjs', 'esm'],
+  dts: true,
+  splitting: false,
+  shims: false,
+}