phecda-vue 3.0.0-alpha.8 → 3.0.0-beta.16

package/dist/index.d.ts

@@ -1,10 +1,14 @@
-import * as _vue_reactivity from '@vue/reactivity';
+import * as vue from 'vue';
 import { Ref, App, UnwrapNestedRefs } from 'vue';
-import { Events, Plugin, Construct } from 'phecda-web';
+import { Construct, Events } from 'phecda-web';
 export * from 'phecda-web';
 
+declare const RawSymbol: unique symbol;
+type Raw<T> = T & {
+    [RawSymbol]: true;
+};
 type ReplaceInstanceValues<I> = {
-    [P in keyof I]: I[P] extends (...args: any[]) => any ? I[P] : Ref<I[P]>;
+    [P in keyof I]: I[P] extends (...args: any[]) => any ? I[P] : I[P] extends Raw<infer O> ? O : Ref<I[P]>;
 };
 type SchemaToObj<S> = {
     [P in keyof S]: S[P] extends object ? SchemaToObj<S[P]> : (S[P] extends string ? any : S[P]);
@@ -18,7 +22,7 @@ declare function createFilter<Data extends Record<string, any>>(initState?: Obje
     errorHandler?: (error?: Error, errorPath?: string) => any;
 }): {
     filter: <Schema>(obj: Schema) => SchemaToObj<Schema>;
-    data: [Data] extends [_vue_reactivity.Ref<any>] ? Data : _vue_reactivity.Ref<_vue_reactivity.UnwrapRef<Data>>;
+    data: [Data] extends [vue.Ref<any>] ? Data : vue.Ref<vue.UnwrapRef<Data>>;
     init: (params?: Data) => void;
     setState: <Key extends string>(key: Key, value: Data[Key]) => void;
     storeState: (key: string, params?: Data) => void;
@@ -31,26 +35,20 @@ declare function createFilter<Data extends Record<string, any>>(initState?: Obje
     delState: (key: string) => void;
 };
 
-declare class PV {
-    constructor();
-    get tag(): 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;
-}
-
 declare const phecdaSymbol: unique symbol;
-declare function createPhecda(): _vue_reactivity.Raw<{
-    plugins: Plugin[];
+declare function createPhecda(): vue.Raw<{
     install(app: App): void;
-    use(...plugins: Plugin[]): any;
     load(state: any): any;
-    unmount(): void;
+    unmount(): Promise<void>;
 }>;
 
 type DeepPartial<T> = {
     [K in keyof T]?: DeepPartial<T[K]>;
 };
+declare function markRaw<T extends object>(value: T): Raw<T>;
+declare function isObject(o: any): boolean;
+declare function mergeReactiveObjects<T extends Record<any, unknown> | Map<unknown, unknown> | Set<unknown>>(target: T, patchToApply: DeepPartial<T>): T;
+declare function createSharedReactive<F extends (...args: any) => any>(composable: F): () => ReturnType<F>;
 
 declare function useO<T extends Construct>(module: T): UnwrapNestedRefs<InstanceType<T>>;
 declare function useRaw<T extends Construct>(module: T): InstanceType<T>;
@@ -63,4 +61,6 @@ declare function useEvent<Key extends keyof Events>(eventName: Key, cb: (event:
 };
 declare function initialize<M extends Construct>(module: M, deleteOtherProperty?: boolean): InstanceType<M> | void;
 
-export { PV, RE, createFilter, createPhecda, initialize, phecdaSymbol, useEvent, useO, usePatch, useR, useRaw, useV };
+declare function Shallow(module: any): void;
+
+export { DeepPartial, RE, Raw, RawSymbol, ReplaceInstanceValues, SchemaToObj, Shallow, createFilter, createPhecda, createSharedReactive, initialize, isObject, markRaw, mergeReactiveObjects, phecdaSymbol, useEvent, useO, usePatch, useR, useRaw, useV };

package/dist/index.js

@@ -22,11 +22,15 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/index.ts
 var src_exports = {};
 __export(src_exports, {
-  PV: () => PV,
   RE: () => RE,
+  Shallow: () => Shallow,
   createFilter: () => createFilter,
   createPhecda: () => createPhecda,
+  createSharedReactive: () => createSharedReactive,
   initialize: () => initialize,
+  isObject: () => isObject,
+  markRaw: () => markRaw2,
+  mergeReactiveObjects: () => mergeReactiveObjects,
   phecdaSymbol: () => phecdaSymbol,
   useEvent: () => useEvent,
   useO: () => useO,
@@ -135,53 +139,28 @@ __name(createFilter, "createFilter");
 // src/index.ts
 __reExport(src_exports, require("phecda-web"), module.exports);
 
-// src/wrapper.ts
-var import_phecda_web = require("phecda-web");
-var PV = class {
-  constructor() {
-  }
-  get tag() {
-    return this.__TAG__;
-  }
-  on(type, handler) {
-    import_phecda_web.emitter.on(type, handler);
-  }
-  emit(type, param) {
-    import_phecda_web.emitter.emit(type, param);
-  }
-  off(type, handler) {
-    import_phecda_web.emitter.off(type, handler);
-  }
-};
-__name(PV, "PV");
-
 // src/phecda.ts
 var import_vue2 = require("vue");
-var import_phecda_web2 = require("phecda-web");
+var import_phecda_web = require("phecda-web");
 var phecdaSymbol = Symbol("phecda");
 function createPhecda() {
-  (0, import_phecda_web2.resetActiveInstance)();
+  (0, import_phecda_web.resetActiveInstance)();
   const phecda = (0, import_vue2.markRaw)({
-    plugins: [],
     install(app) {
-      const instance = (0, import_phecda_web2.getActiveInstance)();
+      const instance = (0, import_phecda_web.getActiveInstance)();
       instance.app = app;
       app.provide(phecdaSymbol, instance);
       app.config.globalProperties.$phecda = instance;
-      this.plugins.forEach((p) => p.setup(instance));
-    },
-    use(...plugins) {
-      plugins.forEach((p) => this.plugins.push(p));
-      return this;
     },
     load(state) {
-      const instance = (0, import_phecda_web2.getActiveInstance)();
+      const instance = (0, import_phecda_web.getActiveInstance)();
       instance.state = state;
       return this;
     },
-    unmount() {
-      const instance = (0, import_phecda_web2.getActiveInstance)();
-      this.plugins.forEach((p) => p.unmount?.(instance));
+    async unmount() {
+      const { state } = (0, import_phecda_web.getActiveInstance)();
+      await Object.values(state).map((ins) => (0, import_phecda_web.invokeHandler)("unmount", ins));
+      (0, import_phecda_web.resetActiveInstance)();
     }
   });
   return phecda;
@@ -190,10 +169,14 @@ __name(createPhecda, "createPhecda");
 
 // src/composable.ts
 var import_vue4 = require("vue");
-var import_phecda_web3 = require("phecda-web");
+var import_phecda_web2 = require("phecda-web");
 
 // src/utils.ts
 var import_vue3 = require("vue");
+function markRaw2(value) {
+  return (0, import_vue3.markRaw)(value);
+}
+__name(markRaw2, "markRaw");
 function isObject(o) {
   return Object.prototype.toString.call(o) === "[object Object]";
 }
@@ -223,7 +206,7 @@ function createSharedReactive(composable) {
       state = scope = null;
     }
   }, "dispose");
-  return () => {
+  const cb = /* @__PURE__ */ __name(() => {
     subscribers++;
     if (!state) {
       scope = (0, import_vue3.effectScope)(true);
@@ -231,23 +214,28 @@ function createSharedReactive(composable) {
     }
     (0, import_vue3.onScopeDispose)(dispose);
     return state;
-  };
+  }, "cb");
+  cb.r = true;
+  return cb;
 }
 __name(createSharedReactive, "createSharedReactive");
 
 // src/composable.ts
+var REF_SYMBOL = Symbol("ref");
 function useO(module2) {
-  const { state } = (0, import_phecda_web3.getActiveInstance)();
-  if (module2.prototype.__ISOLATE__) {
-    const instance = (0, import_vue4.reactive)(new module2());
-    instance._promise = (0, import_phecda_web3.registerSerial)(instance);
+  const { state, origin } = (0, import_phecda_web2.getActiveInstance)();
+  const proxyFn = (0, import_phecda_web2.get)(module2.prototype, "shallow") ? import_vue4.shallowReactive : import_vue4.reactive;
+  if ((0, import_phecda_web2.get)(module2.prototype, "isolate")) {
+    const instance = proxyFn(new module2());
+    instance._promise = (0, import_phecda_web2.invokeHandler)("init", instance);
     return instance;
   }
-  const tag = (0, import_phecda_web3.getTag)(module2);
+  const tag = (0, import_phecda_web2.getTag)(module2);
   if (!(tag in state)) {
-    const instance = (0, import_vue4.reactive)(new module2());
-    instance._promise = (0, import_phecda_web3.registerSerial)(instance);
+    const instance = proxyFn(new module2());
+    instance._promise = (0, import_phecda_web2.invokeHandler)("init", instance);
     state[tag] = instance;
+    origin.set(instance, module2);
   }
   return state[tag];
 }
@@ -262,54 +250,27 @@ function usePatch(module2, Data) {
 }
 __name(usePatch, "usePatch");
 function useR(module2) {
-  const { _r: rmap, _f: fmap } = (0, import_phecda_web3.getActiveInstance)();
-  const instance = useO(module2);
-  if (rmap.has(instance))
-    return rmap.get(instance);
-  const proxy = new Proxy(instance, {
-    get(target, key) {
-      if (typeof target[key] === "function") {
-        if (fmap.has(target[key]))
-          return fmap.get(target[key]);
-        const errorHandler = (0, import_phecda_web3.getHandler)(target, key).find((item) => item.error)?.error;
-        if (!errorHandler)
-          return target[key].bind(target);
-        const wrapper = (0, import_phecda_web3.wrapError)(target, key, errorHandler);
-        fmap.set(target[key], wrapper);
-        return wrapper;
-      }
-      return target[key];
-    },
-    set(target, key, v) {
-      target[key] = v;
-      return true;
-    }
-  });
-  rmap.set(instance, proxy);
-  return proxy;
+  return useO(module2);
 }
 __name(useR, "useR");
 function useV(module2) {
-  const { _v: vmap, _f: fmap, _c: cmap } = (0, import_phecda_web3.getActiveInstance)();
+  const { cache: cacheMap } = (0, import_phecda_web2.getActiveInstance)();
   const instance = useO(module2);
-  if (vmap.has(instance))
-    return vmap.get(instance);
-  cmap.set(instance, {});
+  const cache = cacheMap.get(instance) || {};
+  if (cache[REF_SYMBOL])
+    return cache[REF_SYMBOL];
   const proxy = new Proxy(instance, {
     get(target, key) {
       if (typeof target[key] === "function") {
-        if (fmap.has(target[key]))
-          return fmap.get(target[key]);
-        const errorHandler = (0, import_phecda_web3.getHandler)(target, key).find((item) => item.error)?.error;
-        if (!errorHandler)
-          return target[key].bind(target);
-        const wrapper = (0, import_phecda_web3.wrapError)(target, key, errorHandler);
-        fmap.set(target[key], wrapper);
-        return wrapper;
+        if (!cache[key])
+          cache[key] = target[key].bind(this);
+        return cache[key];
       }
-      const cache = cmap.get(instance);
-      if (key in cache)
-        return cache[key]();
+      if (target[key]?.__v_skip)
+        return target[key];
+      const cacheRef = cache[key];
+      if (cacheRef && cacheRef.r)
+        return cacheRef();
       cache[key] = createSharedReactive(() => {
         return (0, import_vue4.toRef)(target, key);
       });
@@ -319,18 +280,20 @@ function useV(module2) {
       return false;
     }
   });
-  vmap.set(instance, proxy);
+  cache[REF_SYMBOL] = proxy;
+  if (!cacheMap.has(instance))
+    cacheMap.set(instance, cache);
   return proxy;
 }
 __name(useV, "useV");
 function useEvent(eventName, cb) {
   (0, import_vue4.onBeforeUnmount)(() => {
-    import_phecda_web3.emitter.off(eventName, cb);
+    import_phecda_web2.emitter.off(eventName, cb);
   });
-  import_phecda_web3.emitter.on(eventName, cb);
+  import_phecda_web2.emitter.on(eventName, cb);
   return {
-    emit: (arg) => import_phecda_web3.emitter.emit(eventName, arg),
-    cancel: () => import_phecda_web3.emitter.off(eventName, cb)
+    emit: (arg) => import_phecda_web2.emitter.emit(eventName, arg),
+    cancel: () => import_phecda_web2.emitter.off(eventName, cb)
   };
 }
 __name(useEvent, "useEvent");
@@ -346,13 +309,24 @@ function initialize(module2, deleteOtherProperty = true) {
   }
 }
 __name(initialize, "initialize");
+
+// src/decorator.ts
+var import_phecda_web3 = require("phecda-web");
+function Shallow(module2) {
+  (0, import_phecda_web3.set)(module2.prototype, "shallow", true);
+}
+__name(Shallow, "Shallow");
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  PV,
   RE,
+  Shallow,
   createFilter,
   createPhecda,
+  createSharedReactive,
   initialize,
+  isObject,
+  markRaw,
+  mergeReactiveObjects,
   phecdaSymbol,
   useEvent,
   useO,

package/dist/index.mjs

@@ -99,53 +99,28 @@ __name(createFilter, "createFilter");
 // src/index.ts
 export * from "phecda-web";
 
-// src/wrapper.ts
-import { emitter } from "phecda-web";
-var PV = class {
-  constructor() {
-  }
-  get tag() {
-    return this.__TAG__;
-  }
-  on(type, handler) {
-    emitter.on(type, handler);
-  }
-  emit(type, param) {
-    emitter.emit(type, param);
-  }
-  off(type, handler) {
-    emitter.off(type, handler);
-  }
-};
-__name(PV, "PV");
-
 // src/phecda.ts
 import { markRaw } from "vue";
-import { getActiveInstance, resetActiveInstance } from "phecda-web";
+import { getActiveInstance, invokeHandler, resetActiveInstance } from "phecda-web";
 var phecdaSymbol = Symbol("phecda");
 function createPhecda() {
   resetActiveInstance();
   const phecda = markRaw({
-    plugins: [],
     install(app) {
       const instance = getActiveInstance();
       instance.app = app;
       app.provide(phecdaSymbol, instance);
       app.config.globalProperties.$phecda = instance;
-      this.plugins.forEach((p) => p.setup(instance));
-    },
-    use(...plugins) {
-      plugins.forEach((p) => this.plugins.push(p));
-      return this;
     },
     load(state) {
       const instance = getActiveInstance();
       instance.state = state;
       return this;
     },
-    unmount() {
-      const instance = getActiveInstance();
-      this.plugins.forEach((p) => p.unmount?.(instance));
+    async unmount() {
+      const { state } = getActiveInstance();
+      await Object.values(state).map((ins) => invokeHandler("unmount", ins));
+      resetActiveInstance();
     }
   });
   return phecda;
@@ -153,11 +128,15 @@ function createPhecda() {
 __name(createPhecda, "createPhecda");
 
 // src/composable.ts
-import { onBeforeUnmount, reactive, toRaw, toRef } from "vue";
-import { emitter as emitter2, getActiveInstance as getActiveInstance2, getHandler, getTag, registerSerial, wrapError } from "phecda-web";
+import { onBeforeUnmount, reactive, shallowReactive, toRaw, toRef } from "vue";
+import { emitter, get, getActiveInstance as getActiveInstance2, getTag, invokeHandler as invokeHandler2 } from "phecda-web";
 
 // src/utils.ts
-import { effectScope as effectScope2, isReactive, isRef, onScopeDispose } from "vue";
+import { effectScope as effectScope2, isReactive, isRef, onScopeDispose, markRaw as raw } from "vue";
+function markRaw2(value) {
+  return raw(value);
+}
+__name(markRaw2, "markRaw");
 function isObject(o) {
   return Object.prototype.toString.call(o) === "[object Object]";
 }
@@ -187,7 +166,7 @@ function createSharedReactive(composable) {
       state = scope = null;
     }
   }, "dispose");
-  return () => {
+  const cb = /* @__PURE__ */ __name(() => {
     subscribers++;
     if (!state) {
       scope = effectScope2(true);
@@ -195,23 +174,28 @@ function createSharedReactive(composable) {
     }
     onScopeDispose(dispose);
     return state;
-  };
+  }, "cb");
+  cb.r = true;
+  return cb;
 }
 __name(createSharedReactive, "createSharedReactive");
 
 // src/composable.ts
+var REF_SYMBOL = Symbol("ref");
 function useO(module) {
-  const { state } = getActiveInstance2();
-  if (module.prototype.__ISOLATE__) {
-    const instance = reactive(new module());
-    instance._promise = registerSerial(instance);
+  const { state, origin } = getActiveInstance2();
+  const proxyFn = get(module.prototype, "shallow") ? shallowReactive : reactive;
+  if (get(module.prototype, "isolate")) {
+    const instance = proxyFn(new module());
+    instance._promise = invokeHandler2("init", instance);
     return instance;
   }
   const tag = getTag(module);
   if (!(tag in state)) {
-    const instance = reactive(new module());
-    instance._promise = registerSerial(instance);
+    const instance = proxyFn(new module());
+    instance._promise = invokeHandler2("init", instance);
     state[tag] = instance;
+    origin.set(instance, module);
   }
   return state[tag];
 }
@@ -226,54 +210,27 @@ function usePatch(module, Data) {
 }
 __name(usePatch, "usePatch");
 function useR(module) {
-  const { _r: rmap, _f: fmap } = getActiveInstance2();
-  const instance = useO(module);
-  if (rmap.has(instance))
-    return rmap.get(instance);
-  const proxy = new Proxy(instance, {
-    get(target, key) {
-      if (typeof target[key] === "function") {
-        if (fmap.has(target[key]))
-          return fmap.get(target[key]);
-        const errorHandler = getHandler(target, key).find((item) => item.error)?.error;
-        if (!errorHandler)
-          return target[key].bind(target);
-        const wrapper = wrapError(target, key, errorHandler);
-        fmap.set(target[key], wrapper);
-        return wrapper;
-      }
-      return target[key];
-    },
-    set(target, key, v) {
-      target[key] = v;
-      return true;
-    }
-  });
-  rmap.set(instance, proxy);
-  return proxy;
+  return useO(module);
 }
 __name(useR, "useR");
 function useV(module) {
-  const { _v: vmap, _f: fmap, _c: cmap } = getActiveInstance2();
+  const { cache: cacheMap } = getActiveInstance2();
   const instance = useO(module);
-  if (vmap.has(instance))
-    return vmap.get(instance);
-  cmap.set(instance, {});
+  const cache = cacheMap.get(instance) || {};
+  if (cache[REF_SYMBOL])
+    return cache[REF_SYMBOL];
   const proxy = new Proxy(instance, {
     get(target, key) {
       if (typeof target[key] === "function") {
-        if (fmap.has(target[key]))
-          return fmap.get(target[key]);
-        const errorHandler = getHandler(target, key).find((item) => item.error)?.error;
-        if (!errorHandler)
-          return target[key].bind(target);
-        const wrapper = wrapError(target, key, errorHandler);
-        fmap.set(target[key], wrapper);
-        return wrapper;
+        if (!cache[key])
+          cache[key] = target[key].bind(this);
+        return cache[key];
       }
-      const cache = cmap.get(instance);
-      if (key in cache)
-        return cache[key]();
+      if (target[key]?.__v_skip)
+        return target[key];
+      const cacheRef = cache[key];
+      if (cacheRef && cacheRef.r)
+        return cacheRef();
       cache[key] = createSharedReactive(() => {
         return toRef(target, key);
       });
@@ -283,18 +240,20 @@ function useV(module) {
       return false;
     }
   });
-  vmap.set(instance, proxy);
+  cache[REF_SYMBOL] = proxy;
+  if (!cacheMap.has(instance))
+    cacheMap.set(instance, cache);
   return proxy;
 }
 __name(useV, "useV");
 function useEvent(eventName, cb) {
   onBeforeUnmount(() => {
-    emitter2.off(eventName, cb);
+    emitter.off(eventName, cb);
   });
-  emitter2.on(eventName, cb);
+  emitter.on(eventName, cb);
   return {
-    emit: (arg) => emitter2.emit(eventName, arg),
-    cancel: () => emitter2.off(eventName, cb)
+    emit: (arg) => emitter.emit(eventName, arg),
+    cancel: () => emitter.off(eventName, cb)
   };
 }
 __name(useEvent, "useEvent");
@@ -310,12 +269,23 @@ function initialize(module, deleteOtherProperty = true) {
   }
 }
 __name(initialize, "initialize");
+
+// src/decorator.ts
+import { set } from "phecda-web";
+function Shallow(module) {
+  set(module.prototype, "shallow", true);
+}
+__name(Shallow, "Shallow");
 export {
-  PV,
   RE,
+  Shallow,
   createFilter,
   createPhecda,
+  createSharedReactive,
   initialize,
+  isObject,
+  markRaw2 as markRaw,
+  mergeReactiveObjects,
   phecdaSymbol,
   useEvent,
   useO,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "phecda-vue",
-  "version": "3.0.0-alpha.8",
+  "version": "3.0.0-beta.16",
   "description": "provide phecda function to vue",
   "main": "dist/index.js",
   "module": "dist/index.mjs",
@@ -13,7 +13,7 @@
   "license": "MIT",
   "dependencies": {
     "vue": "^3.2.45",
-    "phecda-web": "1.0.1-alpha.2"
+    "phecda-web": "1.0.1-beta.10"
   },
   "devDependencies": {
     "tsup": "^6.5.0"