phecda-vue 4.0.1 → 4.0.2

package/dist/index.d.ts

@@ -4,6 +4,7 @@ import { App, Ref, UnwrapNestedRefs, WatchOptions } from 'vue';
 
 declare const phecdaSymbol: unique symbol;
 declare class VuePhecda extends WebPhecda {
+    vueApp: App;
     install(app: App): void;
 }
 declare function createPhecda(): VuePhecda;
@@ -20,13 +21,16 @@ type SchemaToObj<S> = {
 };
 
 declare function useRaw<T extends Construct>(model: T): InstanceType<T>;
-declare function usePhecda(phecda?: VuePhecda): VuePhecda;
+declare function usePhecda(): VuePhecda;
+declare function getPhecda(phecda?: VuePhecda): VuePhecda;
 declare function useEvent<Key extends keyof Events>(eventName: Key, cb: (event: Events[Key]) => void): {
     emit: (arg: Events[Key]) => void;
     cancel: () => void;
 };
-declare function useR<T extends Construct>(model: T, phecda?: VuePhecda): UnwrapNestedRefs<InstanceType<T>>;
-declare function useV<T extends Construct>(model: T, phecda?: VuePhecda): ReplaceInstanceValues<InstanceType<T>>;
+declare function useR<T extends Construct>(model: T): UnwrapNestedRefs<InstanceType<T>>;
+declare function getR<T extends Construct>(model: T, phecda?: VuePhecda): UnwrapNestedRefs<InstanceType<T>>;
+declare function useV<T extends Construct>(model: T): ReplaceInstanceValues<InstanceType<T>>;
+declare function getV<T extends Construct>(model: T, phecda?: VuePhecda): ReplaceInstanceValues<InstanceType<T>>;
 
 declare function Shallow(isShallow?: boolean): (model: any) => void;
 declare function WatchEffect(option?: WatchOptions): (proto: any, key: string) => void;
@@ -34,4 +38,4 @@ declare function WatchEffect(option?: WatchOptions): (proto: any, key: string) =
 declare function markRaw<T extends object>(value: T): Raw<T>;
 declare function createSharedReactive<F extends (...args: any) => any>(composable: F): () => ReturnType<F>;
 
-export { Raw, RawSymbol, ReplaceInstanceValues, SchemaToObj, Shallow, VuePhecda, WatchEffect, createPhecda, createSharedReactive, markRaw, phecdaSymbol, useEvent, usePhecda, useR, useRaw, useV };
+export { Raw, RawSymbol, ReplaceInstanceValues, SchemaToObj, Shallow, VuePhecda, WatchEffect, createPhecda, createSharedReactive, getPhecda, getR, getV, markRaw, phecdaSymbol, useEvent, usePhecda, useR, useRaw, useV };

package/dist/index.js

@@ -27,6 +27,9 @@ __export(src_exports, {
   WatchEffect: () => WatchEffect,
   createPhecda: () => createPhecda,
   createSharedReactive: () => createSharedReactive,
+  getPhecda: () => getPhecda,
+  getR: () => getR,
+  getV: () => getV,
   markRaw: () => markRaw,
   phecdaSymbol: () => phecdaSymbol,
   useEvent: () => useEvent,
@@ -43,8 +46,10 @@ var import_vue = require("vue");
 var import_phecda_web = require("phecda-web");
 var phecdaSymbol = Symbol(process.env.NODE_ENV === "development" ? "phecda-vue" : void 0);
 var VuePhecda = class extends import_phecda_web.WebPhecda {
+  vueApp;
   install(app) {
     app.provide(phecdaSymbol, this);
+    this.vueApp = app;
   }
 };
 __name(VuePhecda, "VuePhecda");
@@ -95,15 +100,26 @@ function useRaw(model) {
   return (0, import_vue3.toRaw)(useR(model));
 }
 __name(useRaw, "useRaw");
-function usePhecda(phecda) {
-  const activePhecda = phecda || (0, import_vue3.hasInjectionContext)() && (0, import_vue3.inject)(phecdaSymbol);
+function usePhecda() {
+  if (!(0, import_vue3.hasInjectionContext)())
+    throw new Error("[phecda-vue]: use hook inside component setup function");
+  const activePhecda = (0, import_vue3.inject)(phecdaSymbol);
   if (!activePhecda)
-    throw new Error("[phecda-vue]: must install the vue plugin (if used in setup) or manually inject the phecda instance ");
+    throw new Error("[phecda-vue]: must install the vue plugin ");
   if (!cacheMap.has(activePhecda))
     cacheMap.set(activePhecda, (0, import_phecda_web2.bindMethod)(activePhecda));
   return cacheMap.get(activePhecda);
 }
 __name(usePhecda, "usePhecda");
+function getPhecda(phecda) {
+  const activePhecda = phecda || (0, import_phecda_web2.getDefaultPhecda)();
+  if (!activePhecda)
+    throw new Error("[phecda-vue]:  manually inject the phecda instance if there is no default phecda");
+  if (!cacheMap.has(activePhecda))
+    cacheMap.set(activePhecda, (0, import_phecda_web2.bindMethod)(activePhecda));
+  return cacheMap.get(activePhecda);
+}
+__name(getPhecda, "getPhecda");
 function useEvent(eventName, cb) {
   (0, import_vue3.onBeforeUnmount)(() => {
     import_phecda_web2.emitter.off(eventName, cb);
@@ -115,20 +131,23 @@ function useEvent(eventName, cb) {
   };
 }
 __name(useEvent, "useEvent");
-function useR(model, phecda) {
-  return usePhecda(phecda).init(model);
+function useR(model) {
+  return usePhecda().init(model);
 }
 __name(useR, "useR");
-function useV(model, phecda) {
-  const instance = usePhecda(phecda).init(model);
+function getR(model, phecda) {
+  return getPhecda(phecda).init(model);
+}
+__name(getR, "getR");
+function useV(model) {
+  const instance = usePhecda().init(model);
   if (cacheMap.has(instance))
     return cacheMap.get(instance);
   const cache = {};
   const proxy = new Proxy(instance, {
     get(target, key) {
-      if (typeof target[key] === "function") {
+      if (typeof target[key] === "function")
         return target[key];
-      }
       if (target[key]?.__v_skip)
         return target[key];
       const cacheRef = cache[key];
@@ -147,6 +166,33 @@ function useV(model, phecda) {
   return proxy;
 }
 __name(useV, "useV");
+function getV(model, phecda) {
+  const instance = getPhecda(phecda).init(model);
+  if (cacheMap.has(instance))
+    return cacheMap.get(instance);
+  const cache = {};
+  const proxy = new Proxy(instance, {
+    get(target, key) {
+      if (typeof target[key] === "function")
+        return target[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_vue3.toRef)(target, key);
+      });
+      return cache[key]();
+    },
+    set() {
+      return false;
+    }
+  });
+  cacheMap.set(instance, proxy);
+  return proxy;
+}
+__name(getV, "getV");
 
 // src/decorator.ts
 var import_phecda_web3 = require("phecda-web");
@@ -181,6 +227,9 @@ __name(WatchEffect, "WatchEffect");
   WatchEffect,
   createPhecda,
   createSharedReactive,
+  getPhecda,
+  getR,
+  getV,
   markRaw,
   phecdaSymbol,
   useEvent,

package/dist/index.mjs

@@ -9,8 +9,10 @@ import { reactive, shallowReactive } from "vue";
 import { WebPhecda, bindMethod, get } from "phecda-web";
 var phecdaSymbol = Symbol(process.env.NODE_ENV === "development" ? "phecda-vue" : void 0);
 var VuePhecda = class extends WebPhecda {
+  vueApp;
   install(app) {
     app.provide(phecdaSymbol, this);
+    this.vueApp = app;
   }
 };
 __name(VuePhecda, "VuePhecda");
@@ -22,7 +24,7 @@ function createPhecda() {
 __name(createPhecda, "createPhecda");
 
 // src/composable.ts
-import { bindMethod as bindMethod2, emitter } from "phecda-web";
+import { bindMethod as bindMethod2, emitter, getDefaultPhecda } from "phecda-web";
 import { hasInjectionContext, inject, onBeforeUnmount, toRaw, toRef } from "vue";
 
 // src/utils.ts
@@ -61,15 +63,26 @@ function useRaw(model) {
   return toRaw(useR(model));
 }
 __name(useRaw, "useRaw");
-function usePhecda(phecda) {
-  const activePhecda = phecda || hasInjectionContext() && inject(phecdaSymbol);
+function usePhecda() {
+  if (!hasInjectionContext())
+    throw new Error("[phecda-vue]: use hook inside component setup function");
+  const activePhecda = inject(phecdaSymbol);
   if (!activePhecda)
-    throw new Error("[phecda-vue]: must install the vue plugin (if used in setup) or manually inject the phecda instance ");
+    throw new Error("[phecda-vue]: must install the vue plugin ");
   if (!cacheMap.has(activePhecda))
     cacheMap.set(activePhecda, bindMethod2(activePhecda));
   return cacheMap.get(activePhecda);
 }
 __name(usePhecda, "usePhecda");
+function getPhecda(phecda) {
+  const activePhecda = phecda || getDefaultPhecda();
+  if (!activePhecda)
+    throw new Error("[phecda-vue]:  manually inject the phecda instance if there is no default phecda");
+  if (!cacheMap.has(activePhecda))
+    cacheMap.set(activePhecda, bindMethod2(activePhecda));
+  return cacheMap.get(activePhecda);
+}
+__name(getPhecda, "getPhecda");
 function useEvent(eventName, cb) {
   onBeforeUnmount(() => {
     emitter.off(eventName, cb);
@@ -81,20 +94,23 @@ function useEvent(eventName, cb) {
   };
 }
 __name(useEvent, "useEvent");
-function useR(model, phecda) {
-  return usePhecda(phecda).init(model);
+function useR(model) {
+  return usePhecda().init(model);
 }
 __name(useR, "useR");
-function useV(model, phecda) {
-  const instance = usePhecda(phecda).init(model);
+function getR(model, phecda) {
+  return getPhecda(phecda).init(model);
+}
+__name(getR, "getR");
+function useV(model) {
+  const instance = usePhecda().init(model);
   if (cacheMap.has(instance))
     return cacheMap.get(instance);
   const cache = {};
   const proxy = new Proxy(instance, {
     get(target, key) {
-      if (typeof target[key] === "function") {
+      if (typeof target[key] === "function")
         return target[key];
-      }
       if (target[key]?.__v_skip)
         return target[key];
       const cacheRef = cache[key];
@@ -113,6 +129,33 @@ function useV(model, phecda) {
   return proxy;
 }
 __name(useV, "useV");
+function getV(model, phecda) {
+  const instance = getPhecda(phecda).init(model);
+  if (cacheMap.has(instance))
+    return cacheMap.get(instance);
+  const cache = {};
+  const proxy = new Proxy(instance, {
+    get(target, key) {
+      if (typeof target[key] === "function")
+        return target[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);
+      });
+      return cache[key]();
+    },
+    set() {
+      return false;
+    }
+  });
+  cacheMap.set(instance, proxy);
+  return proxy;
+}
+__name(getV, "getV");
 
 // src/decorator.ts
 import { set, setHandler, setStateKey } from "phecda-web";
@@ -146,6 +189,9 @@ export {
   WatchEffect,
   createPhecda,
   createSharedReactive,
+  getPhecda,
+  getR,
+  getV,
   markRaw,
   phecdaSymbol,
   useEvent,

package/package.json

@@ -1,23 +1,23 @@
 {
   "name": "phecda-vue",
-  "version": "4.0.1",
+  "version": "4.0.2",
   "description": "provide phecda function to vue",
-  "main": "dist/index.js",
-  "module": "dist/index.mjs",
-  "types": "dist/index.d.ts",
+  "author": "fgsreally",
+  "license": "MIT",
+  "repository": "https://github.com/fgsreally/phecda/tree/main/packages/vue",
   "keywords": [
     "phecda",
     "vue"
   ],
-  "author": "fgsreally",
-  "repository": "https://github.com/fgsreally/phecda/tree/main/packages/vue",
+  "main": "dist/index.js",
+  "module": "dist/index.mjs",
+  "types": "dist/index.d.ts",
   "files": [
     "dist"
   ],
-  "license": "MIT",
   "dependencies": {
     "vue": "^3.2.45",
-    "phecda-web": "2.0.1"
+    "phecda-web": "2.0.2"
   },
   "devDependencies": {
     "@vue/test-utils": "^2.4.6",