phecda-web 1.0.1 → 2.0.1

package/README.md

@@ -3,3 +3,5 @@
 Fulfill `phecda-core` standard (`Storage/Watcher`);
 
 Work for `phecda-vue`/`phecda-react`
+
+Using `Proxy` and `emitDecoratorMetadata`

package/dist/index.d.ts

@@ -1,35 +1,49 @@
 import { Events, Construct } from 'phecda-core';
 export * from 'phecda-core';
 
-interface ActiveInstance {
-    state: Record<string | symbol, any>;
-    origin: WeakMap<any, any>;
-    cache: WeakMap<any, any>;
-    [key: string]: any;
-}
 interface PhecdaEmitter {
     on<N extends keyof Events>(eventName: N, cb: (args: Events[N]) => void): void;
     off<N extends keyof Events>(eventName: N, cb?: (args: Events[N]) => void): void;
     emit<N extends keyof Events>(eventName: N, param: Events[N]): void;
 }
+type DeepPartial<T> = {
+    [K in keyof T]?: DeepPartial<T[K]>;
+};
 
 declare const emitter: PhecdaEmitter;
 declare function defaultWebInject(): void;
 
-declare function waitUntilInit(...instances: InstanceType<Construct>[]): Promise<any[]>;
-declare function resetActiveInstance(instance?: ActiveInstance): void;
-declare function getActiveInstance(): ActiveInstance;
-declare function serializeState(): any;
-declare function isModuleLoad(model: Construct): boolean;
-declare function unmountModule(model: Construct | PropertyKey): Promise<void>;
+declare function wait(...instances: InstanceType<Construct>[]): Promise<any[]>;
+declare function bindMethod(instance: any): any;
+declare class WebPhecda {
+    protected parseModule: <Instance = any>(instance: Instance) => Instance;
+    origin: Record<string, any>;
+    state: Record<string | symbol, any>;
+    modelMap: WeakMap<object, any>;
+    constructor(parseModule: <Instance = any>(instance: Instance) => Instance);
+    init<Model extends Construct>(model: Model): InstanceType<Model>;
+    patch<Model extends Construct>(model: Model, data: DeepPartial<InstanceType<Model>>): void;
+    wait(...modelOrTag: (Construct | PropertyKey)[]): Promise<any[]>;
+    get<Model extends Construct>(model: Model): InstanceType<Model>;
+    has<Model extends Construct>(model: Model): boolean;
+    reset<Model extends Construct>(model: Model): InstanceType<Model> | undefined;
+    unmount(modelOrTag: Construct | PropertyKey): Promise<void>;
+    unmountAll(): Promise<void[]>;
+    ismount(modelOrTag: Construct | PropertyKey): boolean;
+    serialize(): string;
+    load(str: string): void;
+}
 
-declare class P {
+declare class Base {
     constructor();
     get tag(): PropertyKey;
     then(cb: () => void, reject?: (e: any) => void): any;
     on<Key extends keyof Events>(type: Key, handler: (arg: Events[Key]) => void): void;
     emit<Key extends keyof Events>(type: Key, param: Events[Key]): void;
     off<Key extends keyof Events>(type: Key, handler?: (arg: Events[Key]) => void): void;
+    private readonly __UNMOUNT_SYMBOL__;
+    private onUnmount;
+    private _unmount;
 }
 
-export { ActiveInstance, P, PhecdaEmitter, defaultWebInject, emitter, getActiveInstance, isModuleLoad, resetActiveInstance, serializeState, unmountModule, waitUntilInit };
+export { Base, DeepPartial, PhecdaEmitter, WebPhecda, bindMethod, defaultWebInject, emitter, wait };

package/dist/index.js

@@ -20,6 +20,10 @@ var __copyProps = (to, from, except, desc) => {
 };
 var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
 var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
   isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
   mod
 ));
@@ -28,15 +32,12 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/index.ts
 var src_exports = {};
 __export(src_exports, {
-  P: () => P,
+  Base: () => Base,
+  WebPhecda: () => WebPhecda,
+  bindMethod: () => bindMethod,
   defaultWebInject: () => defaultWebInject,
   emitter: () => emitter,
-  getActiveInstance: () => getActiveInstance,
-  isModuleLoad: () => isModuleLoad,
-  resetActiveInstance: () => resetActiveInstance,
-  serializeState: () => serializeState,
-  unmountModule: () => unmountModule,
-  waitUntilInit: () => waitUntilInit
+  wait: () => wait
 });
 module.exports = __toCommonJS(src_exports);
 __reExport(src_exports, require("phecda-core"), module.exports);
@@ -46,6 +47,8 @@ var import_phecda_core = require("phecda-core");
 var import_mitt = __toESM(require("mitt"));
 var emitter = (0, import_mitt.default)();
 function defaultWebInject() {
+  if (typeof window === "undefined")
+    return;
   if (!(0, import_phecda_core.getInject)("watcher")) {
     (0, import_phecda_core.setInject)("watcher", ({ eventName, instance, key, options }) => {
       const fn = typeof instance[key] === "function" ? instance[key].bind(instance) : (v) => instance[key] = v;
@@ -87,50 +90,191 @@ __name(defaultWebInject, "defaultWebInject");
 
 // src/core.ts
 var import_phecda_core2 = require("phecda-core");
-function waitUntilInit(...instances) {
-  return Promise.all(instances.map((i) => i._promise));
-}
-__name(waitUntilInit, "waitUntilInit");
-var activeInstance;
-function resetActiveInstance(instance) {
-  activeInstance = instance || {
-    state: {},
-    origin: /* @__PURE__ */ new WeakMap(),
-    cache: /* @__PURE__ */ new WeakMap()
-  };
+var import_reflect_metadata = require("reflect-metadata");
+
+// src/utils.ts
+function isObject(o) {
+  return Object.prototype.toString.call(o) === "[object Object]";
 }
-__name(resetActiveInstance, "resetActiveInstance");
-function getActiveInstance() {
-  return activeInstance;
+__name(isObject, "isObject");
+function deepMerge(target, patchToApply) {
+  for (const key in patchToApply) {
+    if (!patchToApply.hasOwnProperty(key))
+      continue;
+    const subPatch = patchToApply[key];
+    const targetValue = target[key];
+    if (isObject(targetValue) && isObject(subPatch) && target.hasOwnProperty(key)) {
+      target[key] = deepMerge(targetValue, subPatch);
+    } else {
+      target[key] = subPatch;
+    }
+  }
+  return target;
 }
-__name(getActiveInstance, "getActiveInstance");
-function serializeState() {
-  return JSON.parse(JSON.stringify(activeInstance.state));
+__name(deepMerge, "deepMerge");
+
+// src/core.ts
+function wait(...instances) {
+  return Promise.all(instances.map((i) => i._promise));
 }
-__name(serializeState, "serializeState");
-function isModuleLoad(model) {
-  const { origin, state } = getActiveInstance();
-  const tag = (0, import_phecda_core2.getTag)(model);
-  if (tag in state) {
-    if (origin.get(state[tag]) !== model)
-      throw new Error(`Synonym module: Module taged "${String(tag)}" (but not "${model.name}") has been loaded before`);
-    return true;
-  }
-  return false;
+__name(wait, "wait");
+function getParamtypes(Model, key) {
+  return Reflect.getMetadata("design:paramtypes", Model, key);
 }
-__name(isModuleLoad, "isModuleLoad");
-async function unmountModule(model) {
-  if (typeof model === "object")
-    model = (0, import_phecda_core2.getTag)(model);
-  const { state } = getActiveInstance();
-  await (0, import_phecda_core2.invokeHandler)("unmount", state[model]);
-  delete state[model];
+__name(getParamtypes, "getParamtypes");
+var bindCache = /* @__PURE__ */ new WeakMap();
+function bindMethod(instance) {
+  if (!bindCache.has(instance)) {
+    const cache = /* @__PURE__ */ new WeakMap();
+    bindCache.set(instance, new Proxy(instance, {
+      get(target, p) {
+        if (typeof target[p] === "function" && !target[p].toString().startsWith("(")) {
+          if (!cache.has(target[p]))
+            cache.set(target[p], target[p].bind(target));
+          return cache.get(target[p]);
+        }
+        return target[p];
+      }
+    }));
+  }
+  return bindCache.get(instance);
 }
-__name(unmountModule, "unmountModule");
+__name(bindMethod, "bindMethod");
+var WebPhecda = class {
+  parseModule;
+  origin;
+  state;
+  modelMap;
+  constructor(parseModule) {
+    this.parseModule = parseModule;
+    this.origin = {};
+    this.state = {};
+    this.modelMap = /* @__PURE__ */ new WeakMap();
+    defaultWebInject();
+  }
+  // Initialize a module that has not been created yet, and return it directly if it is cached.
+  init(model) {
+    const tag = (0, import_phecda_core2.getTag)(model);
+    const initModel = /* @__PURE__ */ __name(() => {
+      const paramtypes = getParamtypes(model);
+      let instance2;
+      if (paramtypes) {
+        const paramtypesInstances = [];
+        for (const i in paramtypes)
+          paramtypesInstances[i] = this.init(paramtypes[i]);
+        instance2 = this.parseModule(new model(...paramtypesInstances));
+      } else {
+        instance2 = this.parseModule(new model());
+      }
+      if (tag in this.origin) {
+        Object.assign(instance2, this.origin[tag]);
+        delete this.origin[tag];
+      }
+      if (typeof window !== "undefined")
+        instance2._promise = (0, import_phecda_core2.invokeHandler)("init", instance2);
+      return instance2;
+    }, "initModel");
+    const { state, modelMap: map } = this;
+    if ((0, import_phecda_core2.get)(model.prototype, "isolate"))
+      return initModel();
+    if (tag in state) {
+      if (process.env.NODE_ENV === "development") {
+        if (map.get(state[tag]) === model)
+          return state[tag];
+      } else {
+        if (map.get(state[tag]) !== model)
+          console.warn(`Synonym model: Module taged "${String(tag)}" has been loaded before, so won't load Module "${model.name}"`);
+        return state[tag];
+      }
+    }
+    const instance = initModel();
+    state[tag] = instance;
+    map.set(instance, model);
+    return instance;
+  }
+  patch(model, data) {
+    const tag = (0, import_phecda_core2.getTag)(model);
+    const { state } = this;
+    deepMerge(state[tag], data);
+  }
+  wait(...modelOrTag) {
+    const { state } = this;
+    return Promise.all(modelOrTag.map((i) => {
+      if (typeof i === "function")
+        i = (0, import_phecda_core2.getTag)(i);
+      return state[i]._promise;
+    }));
+  }
+  get(model) {
+    const { state } = this;
+    return state[(0, import_phecda_core2.getTag)(model)];
+  }
+  has(model) {
+    const { state } = this;
+    return (0, import_phecda_core2.getTag)(model) in state;
+  }
+  reset(model) {
+    const { state } = this;
+    const tag = (0, import_phecda_core2.getTag)(model);
+    if (!(tag in state))
+      return this.init(model);
+    const instance = this.init(model);
+    const newInstance = new model();
+    Object.assign(instance, newInstance);
+    for (const key in instance) {
+      if (!(key in newInstance))
+        delete instance[key];
+    }
+  }
+  async unmount(modelOrTag) {
+    const tag = typeof modelOrTag === "function" ? (0, import_phecda_core2.getTag)(modelOrTag) : modelOrTag;
+    const { state } = this;
+    await (0, import_phecda_core2.invokeHandler)("unmount", state[tag]);
+    delete state[tag];
+  }
+  async unmountAll() {
+    const { state } = this;
+    return Promise.all(Object.keys(state).map((tag) => this.unmount(tag)));
+  }
+  ismount(modelOrTag) {
+    const { state } = this;
+    const tag = typeof modelOrTag === "function" ? (0, import_phecda_core2.getTag)(modelOrTag) : modelOrTag;
+    if (tag in state)
+      return true;
+    return false;
+  }
+  serialize() {
+    const { state } = this;
+    return JSON.stringify(state, (_key, value) => {
+      if (this.modelMap.has(value))
+        return null;
+    });
+  }
+  load(str) {
+    this.origin = JSON.parse(str);
+  }
+};
+__name(WebPhecda, "WebPhecda");
 
 // src/base.ts
 var import_phecda_core3 = require("phecda-core");
-var P = class {
+function _ts_decorate(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function")
+    r = Reflect.decorate(decorators, target, key, desc);
+  else
+    for (var i = decorators.length - 1; i >= 0; i--)
+      if (d = decorators[i])
+        r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+__name(_ts_decorate, "_ts_decorate");
+function _ts_metadata(k, v) {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function")
+    return Reflect.metadata(k, v);
+}
+__name(_ts_metadata, "_ts_metadata");
+var Base = class {
   constructor() {
   }
   get tag() {
@@ -141,6 +285,7 @@ var P = class {
   }
   on(type, handler) {
     emitter.on(type, handler);
+    this.onUnmount(() => emitter.off(type, handler));
   }
   emit(type, param) {
     emitter.emit(type, param);
@@ -148,17 +293,28 @@ var P = class {
   off(type, handler) {
     emitter.off(type, handler);
   }
+  __UNMOUNT_SYMBOL__ = [];
+  onUnmount(cb) {
+    this.__UNMOUNT_SYMBOL__.push(cb);
+  }
+  _unmount() {
+    return Promise.all(this.__UNMOUNT_SYMBOL__.map((fn) => fn()));
+  }
 };
-__name(P, "P");
+__name(Base, "Base");
+_ts_decorate([
+  import_phecda_core3.Unmount,
+  _ts_metadata("design:type", Function),
+  _ts_metadata("design:paramtypes", []),
+  _ts_metadata("design:returntype", void 0)
+], Base.prototype, "_unmount", null);
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  P,
+  Base,
+  WebPhecda,
+  bindMethod,
   defaultWebInject,
   emitter,
-  getActiveInstance,
-  isModuleLoad,
-  resetActiveInstance,
-  serializeState,
-  unmountModule,
-  waitUntilInit
+  wait,
+  ...require("phecda-core")
 });

package/dist/index.mjs

@@ -9,6 +9,8 @@ import { getInject, setInject } from "phecda-core";
 import mitt from "mitt";
 var emitter = mitt();
 function defaultWebInject() {
+  if (typeof window === "undefined")
+    return;
   if (!getInject("watcher")) {
     setInject("watcher", ({ eventName, instance, key, options }) => {
       const fn = typeof instance[key] === "function" ? instance[key].bind(instance) : (v) => instance[key] = v;
@@ -49,51 +51,192 @@ function defaultWebInject() {
 __name(defaultWebInject, "defaultWebInject");
 
 // src/core.ts
-import { getTag, invokeHandler } from "phecda-core";
-function waitUntilInit(...instances) {
-  return Promise.all(instances.map((i) => i._promise));
-}
-__name(waitUntilInit, "waitUntilInit");
-var activeInstance;
-function resetActiveInstance(instance) {
-  activeInstance = instance || {
-    state: {},
-    origin: /* @__PURE__ */ new WeakMap(),
-    cache: /* @__PURE__ */ new WeakMap()
-  };
+import { get, getTag, invokeHandler } from "phecda-core";
+import "reflect-metadata";
+
+// src/utils.ts
+function isObject(o) {
+  return Object.prototype.toString.call(o) === "[object Object]";
 }
-__name(resetActiveInstance, "resetActiveInstance");
-function getActiveInstance() {
-  return activeInstance;
+__name(isObject, "isObject");
+function deepMerge(target, patchToApply) {
+  for (const key in patchToApply) {
+    if (!patchToApply.hasOwnProperty(key))
+      continue;
+    const subPatch = patchToApply[key];
+    const targetValue = target[key];
+    if (isObject(targetValue) && isObject(subPatch) && target.hasOwnProperty(key)) {
+      target[key] = deepMerge(targetValue, subPatch);
+    } else {
+      target[key] = subPatch;
+    }
+  }
+  return target;
 }
-__name(getActiveInstance, "getActiveInstance");
-function serializeState() {
-  return JSON.parse(JSON.stringify(activeInstance.state));
+__name(deepMerge, "deepMerge");
+
+// src/core.ts
+function wait(...instances) {
+  return Promise.all(instances.map((i) => i._promise));
 }
-__name(serializeState, "serializeState");
-function isModuleLoad(model) {
-  const { origin, state } = getActiveInstance();
-  const tag = getTag(model);
-  if (tag in state) {
-    if (origin.get(state[tag]) !== model)
-      throw new Error(`Synonym module: Module taged "${String(tag)}" (but not "${model.name}") has been loaded before`);
-    return true;
-  }
-  return false;
+__name(wait, "wait");
+function getParamtypes(Model, key) {
+  return Reflect.getMetadata("design:paramtypes", Model, key);
 }
-__name(isModuleLoad, "isModuleLoad");
-async function unmountModule(model) {
-  if (typeof model === "object")
-    model = getTag(model);
-  const { state } = getActiveInstance();
-  await invokeHandler("unmount", state[model]);
-  delete state[model];
+__name(getParamtypes, "getParamtypes");
+var bindCache = /* @__PURE__ */ new WeakMap();
+function bindMethod(instance) {
+  if (!bindCache.has(instance)) {
+    const cache = /* @__PURE__ */ new WeakMap();
+    bindCache.set(instance, new Proxy(instance, {
+      get(target, p) {
+        if (typeof target[p] === "function" && !target[p].toString().startsWith("(")) {
+          if (!cache.has(target[p]))
+            cache.set(target[p], target[p].bind(target));
+          return cache.get(target[p]);
+        }
+        return target[p];
+      }
+    }));
+  }
+  return bindCache.get(instance);
 }
-__name(unmountModule, "unmountModule");
+__name(bindMethod, "bindMethod");
+var WebPhecda = class {
+  parseModule;
+  origin;
+  state;
+  modelMap;
+  constructor(parseModule) {
+    this.parseModule = parseModule;
+    this.origin = {};
+    this.state = {};
+    this.modelMap = /* @__PURE__ */ new WeakMap();
+    defaultWebInject();
+  }
+  // Initialize a module that has not been created yet, and return it directly if it is cached.
+  init(model) {
+    const tag = getTag(model);
+    const initModel = /* @__PURE__ */ __name(() => {
+      const paramtypes = getParamtypes(model);
+      let instance2;
+      if (paramtypes) {
+        const paramtypesInstances = [];
+        for (const i in paramtypes)
+          paramtypesInstances[i] = this.init(paramtypes[i]);
+        instance2 = this.parseModule(new model(...paramtypesInstances));
+      } else {
+        instance2 = this.parseModule(new model());
+      }
+      if (tag in this.origin) {
+        Object.assign(instance2, this.origin[tag]);
+        delete this.origin[tag];
+      }
+      if (typeof window !== "undefined")
+        instance2._promise = invokeHandler("init", instance2);
+      return instance2;
+    }, "initModel");
+    const { state, modelMap: map } = this;
+    if (get(model.prototype, "isolate"))
+      return initModel();
+    if (tag in state) {
+      if (process.env.NODE_ENV === "development") {
+        if (map.get(state[tag]) === model)
+          return state[tag];
+      } else {
+        if (map.get(state[tag]) !== model)
+          console.warn(`Synonym model: Module taged "${String(tag)}" has been loaded before, so won't load Module "${model.name}"`);
+        return state[tag];
+      }
+    }
+    const instance = initModel();
+    state[tag] = instance;
+    map.set(instance, model);
+    return instance;
+  }
+  patch(model, data) {
+    const tag = getTag(model);
+    const { state } = this;
+    deepMerge(state[tag], data);
+  }
+  wait(...modelOrTag) {
+    const { state } = this;
+    return Promise.all(modelOrTag.map((i) => {
+      if (typeof i === "function")
+        i = getTag(i);
+      return state[i]._promise;
+    }));
+  }
+  get(model) {
+    const { state } = this;
+    return state[getTag(model)];
+  }
+  has(model) {
+    const { state } = this;
+    return getTag(model) in state;
+  }
+  reset(model) {
+    const { state } = this;
+    const tag = getTag(model);
+    if (!(tag in state))
+      return this.init(model);
+    const instance = this.init(model);
+    const newInstance = new model();
+    Object.assign(instance, newInstance);
+    for (const key in instance) {
+      if (!(key in newInstance))
+        delete instance[key];
+    }
+  }
+  async unmount(modelOrTag) {
+    const tag = typeof modelOrTag === "function" ? getTag(modelOrTag) : modelOrTag;
+    const { state } = this;
+    await invokeHandler("unmount", state[tag]);
+    delete state[tag];
+  }
+  async unmountAll() {
+    const { state } = this;
+    return Promise.all(Object.keys(state).map((tag) => this.unmount(tag)));
+  }
+  ismount(modelOrTag) {
+    const { state } = this;
+    const tag = typeof modelOrTag === "function" ? getTag(modelOrTag) : modelOrTag;
+    if (tag in state)
+      return true;
+    return false;
+  }
+  serialize() {
+    const { state } = this;
+    return JSON.stringify(state, (_key, value) => {
+      if (this.modelMap.has(value))
+        return null;
+    });
+  }
+  load(str) {
+    this.origin = JSON.parse(str);
+  }
+};
+__name(WebPhecda, "WebPhecda");
 
 // src/base.ts
-import { getTag as getTag2 } from "phecda-core";
-var P = class {
+import { Unmount, getTag as getTag2 } from "phecda-core";
+function _ts_decorate(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function")
+    r = Reflect.decorate(decorators, target, key, desc);
+  else
+    for (var i = decorators.length - 1; i >= 0; i--)
+      if (d = decorators[i])
+        r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+__name(_ts_decorate, "_ts_decorate");
+function _ts_metadata(k, v) {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function")
+    return Reflect.metadata(k, v);
+}
+__name(_ts_metadata, "_ts_metadata");
+var Base = class {
   constructor() {
   }
   get tag() {
@@ -104,6 +247,7 @@ var P = class {
   }
   on(type, handler) {
     emitter.on(type, handler);
+    this.onUnmount(() => emitter.off(type, handler));
   }
   emit(type, param) {
     emitter.emit(type, param);
@@ -111,16 +255,26 @@ var P = class {
   off(type, handler) {
     emitter.off(type, handler);
   }
+  __UNMOUNT_SYMBOL__ = [];
+  onUnmount(cb) {
+    this.__UNMOUNT_SYMBOL__.push(cb);
+  }
+  _unmount() {
+    return Promise.all(this.__UNMOUNT_SYMBOL__.map((fn) => fn()));
+  }
 };
-__name(P, "P");
+__name(Base, "Base");
+_ts_decorate([
+  Unmount,
+  _ts_metadata("design:type", Function),
+  _ts_metadata("design:paramtypes", []),
+  _ts_metadata("design:returntype", void 0)
+], Base.prototype, "_unmount", null);
 export {
-  P,
+  Base,
+  WebPhecda,
+  bindMethod,
   defaultWebInject,
   emitter,
-  getActiveInstance,
-  isModuleLoad,
-  resetActiveInstance,
-  serializeState,
-  unmountModule,
-  waitUntilInit
+  wait
 };

package/package.json

@@ -1,18 +1,23 @@
 {
   "name": "phecda-web",
-  "version": "1.0.1",
-  "description": "provide web function for phecda",
+  "version": "2.0.1",
+  "description": "using proxy, provide phecda function to web app",
+  "author": "fgsreally",
+  "license": "MIT",
+  "repository": "https://github.com/fgsreally/phecda/tree/main/packages/web",
+  "keywords": [
+    "phecda",
+    "web"
+  ],
   "main": "dist/index.js",
   "module": "dist/index.mjs",
   "types": "dist/index.d.ts",
-  "keywords": [],
-  "author": "",
   "files": [
     "dist"
   ],
-  "license": "MIT",
   "dependencies": {
     "mitt": "^3.0.0",
+    "reflect-metadata": "^0.1.13",
     "phecda-core": "3.0.0"
   },
   "devDependencies": {