phecda-vue 5.0.0 → 5.1.1

package/dist/index.d.mts

@@ -36,4 +36,8 @@ 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 { type Raw, RawSymbol, type ReplaceInstanceValues, Shallow, VuePhecda, WatchEffect, createPhecda, createSharedReactive, getPhecda, getR, getRaw, getV, markRaw, phecdaSymbol, useEvent, usePhecda, useR, useRaw, useV };
+declare function hasI(model: Construct): boolean;
+declare function useIR<T extends Construct>(model: T, forceProvide?: boolean): UnwrapNestedRefs<InstanceType<T>>;
+declare function useIV<T extends Construct>(model: T, forceProvide?: boolean): ReplaceInstanceValues<InstanceType<T>>;
+
+export { type Raw, RawSymbol, type ReplaceInstanceValues, Shallow, VuePhecda, WatchEffect, createPhecda, createSharedReactive, getPhecda, getR, getRaw, getV, hasI, markRaw, phecdaSymbol, useEvent, useIR, useIV, usePhecda, useR, useRaw, useV };

package/dist/index.d.ts

@@ -36,4 +36,8 @@ 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 { type Raw, RawSymbol, type ReplaceInstanceValues, Shallow, VuePhecda, WatchEffect, createPhecda, createSharedReactive, getPhecda, getR, getRaw, getV, markRaw, phecdaSymbol, useEvent, usePhecda, useR, useRaw, useV };
+declare function hasI(model: Construct): boolean;
+declare function useIR<T extends Construct>(model: T, forceProvide?: boolean): UnwrapNestedRefs<InstanceType<T>>;
+declare function useIV<T extends Construct>(model: T, forceProvide?: boolean): ReplaceInstanceValues<InstanceType<T>>;
+
+export { type Raw, RawSymbol, type ReplaceInstanceValues, Shallow, VuePhecda, WatchEffect, createPhecda, createSharedReactive, getPhecda, getR, getRaw, getV, hasI, markRaw, phecdaSymbol, useEvent, useIR, useIV, usePhecda, useR, useRaw, useV };

package/dist/index.js

@@ -31,9 +31,12 @@ __export(src_exports, {
   getR: () => getR,
   getRaw: () => getRaw,
   getV: () => getV,
+  hasI: () => hasI,
   markRaw: () => markRaw,
   phecdaSymbol: () => phecdaSymbol,
   useEvent: () => useEvent,
+  useIR: () => useIR,
+  useIV: () => useIV,
   usePhecda: () => usePhecda,
   useR: () => useR,
   useRaw: () => useRaw,
@@ -537,6 +540,65 @@ function WatchEffect(option) {
   };
 }
 __name(WatchEffect, "WatchEffect");
+
+// src/lib.ts
+var import_phecda_web4 = require("phecda-web");
+var import_vue5 = require("vue");
+function hasI(model) {
+  const tag = (0, import_phecda_web4.getTag)(model);
+  const injectKey = `phecda-vue:lib ${tag.toString()}`;
+  return !!(0, import_vue5.inject)(injectKey);
+}
+__name(hasI, "hasI");
+function useIR(model, forceProvide = false) {
+  const tag = (0, import_phecda_web4.getTag)(model);
+  const instance = (0, import_vue5.getCurrentInstance)();
+  if (!instance["phecda-vue"]) instance["phecda-vue"] = /* @__PURE__ */ new WeakMap();
+  const modelMap = instance["phecda-vue"];
+  const injectKey = `phecda-vue:lib ${tag.toString()}`;
+  let existModule = modelMap.get(model) || (0, import_vue5.inject)(injectKey);
+  if (!existModule || forceProvide) {
+    const data = {
+      // keep class name
+      [model.name]: class extends model {
+      }
+    };
+    const paramtypes = (0, import_phecda_web4.getParamtypes)(model) || [];
+    existModule = (0, import_phecda_web4.bindMethod)((0, import_vue5.reactive)(new data[model.name](...paramtypes.map((param) => useIR(param)))));
+    (0, import_phecda_web4.invokeInit)(existModule);
+    (0, import_vue5.provide)(injectKey, existModule);
+    modelMap.set(model, existModule);
+    (0, import_vue5.onBeforeUnmount)(() => (0, import_phecda_web4.invokeUnmount)(existModule));
+    return existModule;
+  } else {
+    return existModule;
+  }
+}
+__name(useIR, "useIR");
+var weakmap = /* @__PURE__ */ new WeakMap();
+function useIV(model, forceProvide = false) {
+  const instance = useIR(model, forceProvide);
+  if (weakmap.has(instance)) return weakmap.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_vue5.toRef)(target, key);
+      });
+      return cache[key]();
+    },
+    set() {
+      return false;
+    }
+  });
+  weakmap.set(instance, proxy);
+  return proxy;
+}
+__name(useIV, "useIV");
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   Shallow,
@@ -548,9 +610,12 @@ __name(WatchEffect, "WatchEffect");
   getR,
   getRaw,
   getV,
+  hasI,
   markRaw,
   phecdaSymbol,
   useEvent,
+  useIR,
+  useIV,
   usePhecda,
   useR,
   useRaw,

package/dist/index.mjs

@@ -499,6 +499,65 @@ function WatchEffect(option) {
   };
 }
 __name(WatchEffect, "WatchEffect");
+
+// src/lib.ts
+import { bindMethod as bindMethod3, getParamtypes, getTag as getTag3, invokeInit, invokeUnmount } from "phecda-web";
+import { getCurrentInstance as getCurrentInstance2, inject as inject2, onBeforeUnmount as onBeforeUnmount2, provide, reactive as reactive2, toRef as toRef2 } from "vue";
+function hasI(model) {
+  const tag = getTag3(model);
+  const injectKey = `phecda-vue:lib ${tag.toString()}`;
+  return !!inject2(injectKey);
+}
+__name(hasI, "hasI");
+function useIR(model, forceProvide = false) {
+  const tag = getTag3(model);
+  const instance = getCurrentInstance2();
+  if (!instance["phecda-vue"]) instance["phecda-vue"] = /* @__PURE__ */ new WeakMap();
+  const modelMap = instance["phecda-vue"];
+  const injectKey = `phecda-vue:lib ${tag.toString()}`;
+  let existModule = modelMap.get(model) || inject2(injectKey);
+  if (!existModule || forceProvide) {
+    const data = {
+      // keep class name
+      [model.name]: class extends model {
+      }
+    };
+    const paramtypes = getParamtypes(model) || [];
+    existModule = bindMethod3(reactive2(new data[model.name](...paramtypes.map((param) => useIR(param)))));
+    invokeInit(existModule);
+    provide(injectKey, existModule);
+    modelMap.set(model, existModule);
+    onBeforeUnmount2(() => invokeUnmount(existModule));
+    return existModule;
+  } else {
+    return existModule;
+  }
+}
+__name(useIR, "useIR");
+var weakmap = /* @__PURE__ */ new WeakMap();
+function useIV(model, forceProvide = false) {
+  const instance = useIR(model, forceProvide);
+  if (weakmap.has(instance)) return weakmap.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 toRef2(target, key);
+      });
+      return cache[key]();
+    },
+    set() {
+      return false;
+    }
+  });
+  weakmap.set(instance, proxy);
+  return proxy;
+}
+__name(useIV, "useIV");
 export {
   Shallow,
   VuePhecda,
@@ -509,9 +568,12 @@ export {
   getR,
   getRaw,
   getV,
+  hasI,
   markRaw,
   phecdaSymbol,
   useEvent,
+  useIR,
+  useIV,
   usePhecda,
   useR,
   useRaw,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "phecda-vue",
-  "version": "5.0.0",
+  "version": "5.1.1",
   "description": "provide phecda function to vue",
   "author": "fgsreally",
   "license": "MIT",