phecda-react 0.0.1-alpha.3 → 0.1.0-alpha.4

package/dist/index.d.ts

@@ -1,27 +1,14 @@
-import * as react from 'react';
-import { Events } from 'phecda-core';
-export * from 'phecda-core';
-
-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;
-}
-interface PhecdaInstance {
-    useOMap: Map<any, any>;
-    useVMap: WeakMap<any, any>;
-    useRMap: WeakMap<any, any>;
-    fnMap: WeakMap<any, any>;
-}
-
-declare const emitter: PhecdaEmitter;
-declare function setActivePhecda(phecda: PhecdaInstance): void;
-declare function getActivePhecda(): PhecdaInstance;
-declare function useO<T extends new (...args: any) => any>(module: T): any;
-declare function useR<T extends new (...args: any) => any>(module: T): [InstanceType<T>, InstanceType<T>];
-declare function createPhecdaContext(): ({ children }: any) => react.FunctionComponentElement<react.ProviderProps<null>>;
-
-declare function wrapError(target: any, key: PropertyKey, errorHandler: Function): (...args: any) => any;
-declare function isAsyncFunc(fn: Function): boolean;
-
-export { createPhecdaContext, emitter, getActivePhecda, isAsyncFunc, setActivePhecda, useO, useR, wrapError };
+import { Construct, Plugin, Events } from 'phecda-web';
+export * from 'phecda-web';
+
+declare function useO<T extends Construct>(module: T): any;
+declare function useR<T extends Construct>(module: T): [InstanceType<T>, InstanceType<T>];
+declare function createPhecda(): {
+    use(...plugins: Plugin[]): void;
+    load(state: any): any;
+    unmount(): void;
+};
+declare function useEvent<Key extends keyof Events>(eventName: Key, cb: (event: Events[Key]) => void): ((arg: Events[Key]) => any)[];
+declare function initialize<M extends Construct>(module: M, deleteOtherProperty?: boolean): InstanceType<M> | void;
+
+export { createPhecda, initialize, useEvent, useO, useR };

package/dist/index.js

@@ -1,9 +1,7 @@
 "use strict";
-var __create = Object.create;
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
 var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
 var __export = (target, all) => {
@@ -19,85 +17,43 @@ var __copyProps = (to, from, except, desc) => {
   return to;
 };
 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(
-  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
-  mod
-));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
 // src/index.ts
 var src_exports = {};
 __export(src_exports, {
-  createPhecdaContext: () => createPhecdaContext,
-  emitter: () => emitter,
-  getActivePhecda: () => getActivePhecda,
-  isAsyncFunc: () => isAsyncFunc,
-  setActivePhecda: () => setActivePhecda,
+  createPhecda: () => createPhecda,
+  initialize: () => initialize,
+  useEvent: () => useEvent,
   useO: () => useO,
-  useR: () => useR,
-  wrapError: () => wrapError
+  useR: () => useR
 });
 module.exports = __toCommonJS(src_exports);
 
-// src/composables.ts
+// src/core.ts
 var import_valtio = require("valtio");
-var import_phecda_core = require("phecda-core");
 var import_react = require("react");
-var import_mitt = __toESM(require("mitt"));
-
-// src/utils.ts
-function wrapError(target, key, errorHandler) {
-  if (isAsyncFunc(target[key])) {
-    return (...args) => {
-      return target[key].apply(target, args).catch(errorHandler);
-    };
-  } else {
-    return (...args) => {
-      try {
-        return target[key].apply(target, args);
-      } catch (e) {
-        return errorHandler(e);
-      }
-    };
-  }
-}
-__name(wrapError, "wrapError");
-function isAsyncFunc(fn) {
-  return fn[Symbol.toStringTag] === "AsyncFunction";
-}
-__name(isAsyncFunc, "isAsyncFunc");
-
-// src/composables.ts
-var emitter = (0, import_mitt.default)();
-var activePhecda = {
-  useOMap: /* @__PURE__ */ new Map(),
-  useVMap: /* @__PURE__ */ new WeakMap(),
-  useRMap: /* @__PURE__ */ new WeakMap(),
-  fnMap: /* @__PURE__ */ new WeakMap()
-};
-function setActivePhecda(phecda) {
-  activePhecda = phecda;
-}
-__name(setActivePhecda, "setActivePhecda");
-function getActivePhecda() {
-  return activePhecda;
-}
-__name(getActivePhecda, "getActivePhecda");
+var import_phecda_web = require("phecda-web");
 function useO(module2) {
-  const { useOMap } = getActivePhecda();
-  const tag = (0, import_phecda_core.getTag)(module2) || module2.name;
-  if (useOMap.has(tag))
-    return useOMap.get(tag);
+  const { state } = (0, import_phecda_web.getActiveInstance)();
+  if (module2.prototype.__ISOLATE__) {
+    const instance2 = new module2();
+    instance2._promise = registerAsync(instance2);
+    return instance2;
+  }
+  const tag = (0, import_phecda_web.getTag)(module2) || module2.name;
+  if (tag in state)
+    return state[tag];
   const instance = new module2();
-  useOMap.set(tag, instance);
+  state[tag] = instance;
   return instance;
 }
 __name(useO, "useO");
 function useR(module2) {
-  const { useRMap, fnMap } = getActivePhecda();
+  const { _r: rmap, _f: fmap } = (0, import_phecda_web.getActiveInstance)();
   const instance = useO(module2);
-  if (useRMap.has(instance)) {
-    const proxyInstance2 = useRMap.get(instance);
+  if (rmap.has(instance)) {
+    const proxyInstance2 = rmap.get(instance);
     return [
       (0, import_valtio.useSnapshot)(proxyInstance2),
       proxyInstance2
@@ -106,13 +62,13 @@ function useR(module2) {
   const proxyInstance = (0, import_valtio.proxy)(new Proxy(instance, {
     get(target, key) {
       if (typeof target[key] === "function") {
-        if (fnMap.has(target[key]))
-          return fnMap.get(target[key]);
-        const errorHandler = (0, import_phecda_core.getHandler)(target, key).find((item) => item.error)?.error;
+        if (fmap.has(target[key]))
+          return fmap.get(target[key]);
+        const errorHandler = (0, import_phecda_web.getHandler)(target, key).find((item) => item.error)?.error;
         if (!errorHandler)
           return target[key].bind(target);
-        const wrapper = wrapError(target, key, errorHandler);
-        fnMap.set(target[key], wrapper);
+        const wrapper = (0, import_phecda_web.wrapError)(target, key, errorHandler);
+        fmap.set(target[key], wrapper);
         return wrapper;
       }
       return target[key];
@@ -122,85 +78,66 @@ function useR(module2) {
       return true;
     }
   }));
-  (0, import_phecda_core.register)(proxyInstance);
-  useRMap.set(instance, proxyInstance);
+  (0, import_phecda_web.register)(proxyInstance);
+  rmap.set(instance, proxyInstance);
   return [
     (0, import_valtio.useSnapshot)(proxyInstance),
     proxyInstance
   ];
 }
 __name(useR, "useR");
-function createPhecdaContext() {
-  const { Provider } = (0, import_react.createContext)(null);
-  let eventRecord = [];
-  return ({ children }) => {
-    (0, import_react.useEffect)(() => {
-      return () => {
-        getActivePhecda().useOMap.clear();
-        eventRecord.forEach(([eventName, handler]) => emitter.off(eventName, handler));
-        eventRecord = [];
-      };
-    }, []);
-    if (!(0, import_phecda_core.getProperty)("watcher")) {
-      (0, import_phecda_core.injectProperty)("watcher", ({ eventName, instance, key, options }) => {
-        const fn = typeof instance[key] === "function" ? instance[key].bind(instance) : (v) => instance[key] = v;
-        if (options?.once) {
-          const handler = /* @__PURE__ */ __name((...args) => {
-            fn(...args);
-            emitter.off(eventName, handler);
-          }, "handler");
-          emitter.on(eventName, handler);
-          eventRecord.push([
-            eventName,
-            handler
-          ]);
-        } else {
-          eventRecord.push([
-            eventName,
-            fn
-          ]);
-          emitter.on(eventName, fn);
-        }
-      });
-    }
-    if (!(0, import_phecda_core.getProperty)("storage")) {
-      (0, import_phecda_core.injectProperty)("storage", ({ tag, key, instance }) => {
-        if (!tag)
-          return;
-        const initstr = localStorage.getItem(tag);
-        if (initstr) {
-          const data = JSON.parse(initstr);
-          if (key) {
-            instance[key] = data;
-          } else {
-            for (const i in data) {
-              if (i)
-                instance[i] = data[i];
-            }
-          }
-        }
-        globalThis.addEventListener("beforeunload", () => {
-          localStorage.setItem(tag, JSON.stringify(key ? instance[key] : instance));
-        });
+function createPhecda() {
+  (0, import_phecda_web.resetActiveInstance)();
+  const instance = (0, import_phecda_web.getActiveInstance)();
+  const pluginSet = [];
+  return {
+    use(...plugins) {
+      plugins.forEach((p) => {
+        p.setup(instance);
+        pluginSet.push(p);
       });
+    },
+    load(state) {
+      instance.state = state;
+      return this;
+    },
+    unmount() {
+      pluginSet.forEach((p) => p.unmount?.(instance));
     }
-    return (0, import_react.createElement)(Provider, {
-      value: null
-    }, children);
   };
 }
-__name(createPhecdaContext, "createPhecdaContext");
+__name(createPhecda, "createPhecda");
+function useEvent(eventName, cb) {
+  (0, import_react.useEffect)(() => {
+    return () => emitter.off(eventName, cb);
+  });
+  emitter.on(eventName, cb);
+  return [
+    (arg) => emitter.emit(eventName, arg),
+    () => emitter.off(eventName, cb)
+  ];
+}
+__name(useEvent, "useEvent");
+function initialize(module2, deleteOtherProperty = true) {
+  const instance = useO(module2);
+  const newInstance = new module2();
+  Object.assign(instance, newInstance);
+  if (deleteOtherProperty) {
+    for (const key in instance) {
+      if (!(key in newInstance))
+        delete instance[key];
+    }
+  }
+}
+__name(initialize, "initialize");
 
 // src/index.ts
-__reExport(src_exports, require("phecda-core"), module.exports);
+__reExport(src_exports, require("phecda-web"), module.exports);
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  createPhecdaContext,
-  emitter,
-  getActivePhecda,
-  isAsyncFunc,
-  setActivePhecda,
+  createPhecda,
+  initialize,
+  useEvent,
   useO,
-  useR,
-  wrapError
+  useR
 });

package/dist/index.mjs

@@ -1,65 +1,30 @@
 var __defProp = Object.defineProperty;
 var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
 
-// src/composables.ts
+// src/core.ts
 import { proxy, useSnapshot } from "valtio";
-import { getHandler, getProperty, getTag, injectProperty, register } from "phecda-core";
-import { createContext, createElement, useEffect } from "react";
-import mitt from "mitt";
-
-// src/utils.ts
-function wrapError(target, key, errorHandler) {
-  if (isAsyncFunc(target[key])) {
-    return (...args) => {
-      return target[key].apply(target, args).catch(errorHandler);
-    };
-  } else {
-    return (...args) => {
-      try {
-        return target[key].apply(target, args);
-      } catch (e) {
-        return errorHandler(e);
-      }
-    };
-  }
-}
-__name(wrapError, "wrapError");
-function isAsyncFunc(fn) {
-  return fn[Symbol.toStringTag] === "AsyncFunction";
-}
-__name(isAsyncFunc, "isAsyncFunc");
-
-// src/composables.ts
-var emitter = mitt();
-var activePhecda = {
-  useOMap: /* @__PURE__ */ new Map(),
-  useVMap: /* @__PURE__ */ new WeakMap(),
-  useRMap: /* @__PURE__ */ new WeakMap(),
-  fnMap: /* @__PURE__ */ new WeakMap()
-};
-function setActivePhecda(phecda) {
-  activePhecda = phecda;
-}
-__name(setActivePhecda, "setActivePhecda");
-function getActivePhecda() {
-  return activePhecda;
-}
-__name(getActivePhecda, "getActivePhecda");
+import { useEffect } from "react";
+import { getActiveInstance, getHandler, getTag, register, resetActiveInstance, wrapError } from "phecda-web";
 function useO(module) {
-  const { useOMap } = getActivePhecda();
+  const { state } = getActiveInstance();
+  if (module.prototype.__ISOLATE__) {
+    const instance2 = new module();
+    instance2._promise = registerAsync(instance2);
+    return instance2;
+  }
   const tag = getTag(module) || module.name;
-  if (useOMap.has(tag))
-    return useOMap.get(tag);
+  if (tag in state)
+    return state[tag];
   const instance = new module();
-  useOMap.set(tag, instance);
+  state[tag] = instance;
   return instance;
 }
 __name(useO, "useO");
 function useR(module) {
-  const { useRMap, fnMap } = getActivePhecda();
+  const { _r: rmap, _f: fmap } = getActiveInstance();
   const instance = useO(module);
-  if (useRMap.has(instance)) {
-    const proxyInstance2 = useRMap.get(instance);
+  if (rmap.has(instance)) {
+    const proxyInstance2 = rmap.get(instance);
     return [
       useSnapshot(proxyInstance2),
       proxyInstance2
@@ -68,13 +33,13 @@ function useR(module) {
   const proxyInstance = proxy(new Proxy(instance, {
     get(target, key) {
       if (typeof target[key] === "function") {
-        if (fnMap.has(target[key]))
-          return fnMap.get(target[key]);
+        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);
-        fnMap.set(target[key], wrapper);
+        fmap.set(target[key], wrapper);
         return wrapper;
       }
       return target[key];
@@ -85,83 +50,64 @@ function useR(module) {
     }
   }));
   register(proxyInstance);
-  useRMap.set(instance, proxyInstance);
+  rmap.set(instance, proxyInstance);
   return [
     useSnapshot(proxyInstance),
     proxyInstance
   ];
 }
 __name(useR, "useR");
-function createPhecdaContext() {
-  const { Provider } = createContext(null);
-  let eventRecord = [];
-  return ({ children }) => {
-    useEffect(() => {
-      return () => {
-        getActivePhecda().useOMap.clear();
-        eventRecord.forEach(([eventName, handler]) => emitter.off(eventName, handler));
-        eventRecord = [];
-      };
-    }, []);
-    if (!getProperty("watcher")) {
-      injectProperty("watcher", ({ eventName, instance, key, options }) => {
-        const fn = typeof instance[key] === "function" ? instance[key].bind(instance) : (v) => instance[key] = v;
-        if (options?.once) {
-          const handler = /* @__PURE__ */ __name((...args) => {
-            fn(...args);
-            emitter.off(eventName, handler);
-          }, "handler");
-          emitter.on(eventName, handler);
-          eventRecord.push([
-            eventName,
-            handler
-          ]);
-        } else {
-          eventRecord.push([
-            eventName,
-            fn
-          ]);
-          emitter.on(eventName, fn);
-        }
-      });
-    }
-    if (!getProperty("storage")) {
-      injectProperty("storage", ({ tag, key, instance }) => {
-        if (!tag)
-          return;
-        const initstr = localStorage.getItem(tag);
-        if (initstr) {
-          const data = JSON.parse(initstr);
-          if (key) {
-            instance[key] = data;
-          } else {
-            for (const i in data) {
-              if (i)
-                instance[i] = data[i];
-            }
-          }
-        }
-        globalThis.addEventListener("beforeunload", () => {
-          localStorage.setItem(tag, JSON.stringify(key ? instance[key] : instance));
-        });
+function createPhecda() {
+  resetActiveInstance();
+  const instance = getActiveInstance();
+  const pluginSet = [];
+  return {
+    use(...plugins) {
+      plugins.forEach((p) => {
+        p.setup(instance);
+        pluginSet.push(p);
       });
+    },
+    load(state) {
+      instance.state = state;
+      return this;
+    },
+    unmount() {
+      pluginSet.forEach((p) => p.unmount?.(instance));
     }
-    return createElement(Provider, {
-      value: null
-    }, children);
   };
 }
-__name(createPhecdaContext, "createPhecdaContext");
+__name(createPhecda, "createPhecda");
+function useEvent(eventName, cb) {
+  useEffect(() => {
+    return () => emitter.off(eventName, cb);
+  });
+  emitter.on(eventName, cb);
+  return [
+    (arg) => emitter.emit(eventName, arg),
+    () => emitter.off(eventName, cb)
+  ];
+}
+__name(useEvent, "useEvent");
+function initialize(module, deleteOtherProperty = true) {
+  const instance = useO(module);
+  const newInstance = new module();
+  Object.assign(instance, newInstance);
+  if (deleteOtherProperty) {
+    for (const key in instance) {
+      if (!(key in newInstance))
+        delete instance[key];
+    }
+  }
+}
+__name(initialize, "initialize");
 
 // src/index.ts
-export * from "phecda-core";
+export * from "phecda-web";
 export {
-  createPhecdaContext,
-  emitter,
-  getActivePhecda,
-  isAsyncFunc,
-  setActivePhecda,
+  createPhecda,
+  initialize,
+  useEvent,
   useO,
-  useR,
-  wrapError
+  useR
 };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "phecda-react",
-  "version": "0.0.1-alpha.3",
-  "description": "provide store with phecda function to react",
+  "version": "0.1.0-alpha.4",
+  "description": "provide phecda function to react by valtio",
   "main": "dist/index.js",
   "module": "dist/index.mjs",
   "types": "dist/index.d.ts",
@@ -12,10 +12,9 @@
   ],
   "license": "MIT",
   "dependencies": {
-    "mitt": "^3.0.0",
     "react": "^18.2.0",
     "valtio": "^1.13.0",
-    "phecda-core": "3.0.0-alpha.2"
+    "phecda-web": "1.0.1-alpha.0"
   },
   "devDependencies": {
     "@types/react": "^18.2.48",