phecda-core 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2022 fgsreally
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/index.d.ts

@@ -0,0 +1,180 @@
+import * as mitt from 'mitt';
+import { EventType, Emitter, Handler } from 'mitt';
+import * as vue from 'vue';
+import { Ref, UnwrapNestedRefs, App } from 'vue';
+
+interface PhecdaNameSpace {
+    [name: string]: Phecda;
+}
+interface PhecdaEvents extends Record<EventType, unknown> {
+    [key: EventType]: any;
+}
+interface UsePipeOptions {
+    transform: boolean;
+    collectError: boolean;
+}
+interface PhecdaHandler {
+    init?: (instance: Phecda, isFirstTime: boolean) => any;
+    validate?: (instance: Phecda) => string | void;
+    pipe?: (instance: Phecda) => void;
+    error?: any;
+    watch?: any;
+    rule?: any;
+    info?: any;
+    ignore?: boolean;
+    meta?: any;
+    beforeUnload?: (instance: Phecda) => any;
+    beforeLoad?: (instance: Phecda, v: any) => any;
+}
+type Vret<I> = {
+    [P in keyof I]: I[P] extends Function ? I[P] : Ref<I[P]>;
+};
+type ClassValue<I> = {
+    [P in keyof I]: I[P] extends Function ? undefined : I[P];
+};
+type SchemaToObj<S> = {
+    [P in keyof S]: S[P] extends object ? SchemaToObj<S[P]> : (S[P] extends string ? any : S[P]);
+};
+
+declare class Phecda {
+    protected static __PHECDA_EMIT__: Emitter<PhecdaEvents>;
+    protected static __PHECDA_NAMESPACE__: PhecdaNameSpace;
+    protected static __PHECDA_MODEL__: string[];
+    protected _symbol: string;
+    protected _namespace: {
+        __INIT_EVENT__: Set<PropertyKey>;
+        __STATE_VAR__: Set<PropertyKey>;
+        __STATE_HANDLER__: Map<PropertyKey, PhecdaHandler>;
+    };
+    constructor();
+    on<Key extends keyof PhecdaEvents>(type: Key, handler: Handler<PhecdaEvents[Key]>): void;
+    emit(type: keyof PhecdaEvents, event: PhecdaEvents[keyof PhecdaEvents]): void;
+    off<Key extends keyof PhecdaEvents>(type: Key, handler?: Handler<PhecdaEvents[Key]>): void;
+}
+declare class PhecdaWeb extends Phecda {
+    constructor();
+}
+declare function register(instance: any): void;
+
+declare function plainToClass<M extends new (...args: any) => any, Data extends Record<PropertyKey, any>>(Model: M, input: Data, options?: Partial<UsePipeOptions>): Promise<{
+    err: string[];
+    data: InstanceType<M>;
+}>;
+declare function classToValue<M>(instance: M): ClassValue<M>;
+declare function to<T extends (...args: any) => any>(task: T, oldTasks?: Function[]): {
+    to: <R extends (arg: ReturnType<T>) => any>(task: R) => {
+        to: <R_1 extends (arg: ReturnType<R>) => any>(task: R_1) => {
+            to: <R_2 extends (arg: ReturnType<R_1>) => any>(task: R_2) => {
+                to: <R_3 extends (arg: ReturnType<R_2>) => any>(task: R_3) => {
+                    to: <R_4 extends (arg: ReturnType<R_3>) => any>(task: R_4) => {
+                        to: <R_5 extends (arg: ReturnType<R_4>) => any>(task: R_5) => {
+                            to: <R_6 extends (arg: ReturnType<R_5>) => any>(task: R_6) => {
+                                to: <R_7 extends (arg: ReturnType<R_6>) => any>(task: R_7) => {
+                                    to: <R_8 extends (arg: ReturnType<R_7>) => any>(task: R_8) => {
+                                        to: <R_9 extends (arg: ReturnType<R_8>) => any>(task: R_9) => {
+                                            to: <R_10 extends (arg: ReturnType<R_9>) => any>(task: R_10) => any;
+                                            value: Function[];
+                                        };
+                                        value: Function[];
+                                    };
+                                    value: Function[];
+                                };
+                                value: Function[];
+                            };
+                            value: Function[];
+                        };
+                        value: Function[];
+                    };
+                    value: Function[];
+                };
+                value: Function[];
+            };
+            value: Function[];
+        };
+        value: Function[];
+    };
+    value: Function[];
+};
+declare function snapShot<T extends new (...args: any) => any>(data: UnwrapNestedRefs<InstanceType<T>>): {
+    data: UnwrapNestedRefs<InstanceType<T>>;
+    clear(): void;
+    apply(): void;
+};
+
+declare function regisInitEvent(target: any, key: string): void;
+declare function getInitEvent(target: any): string[];
+declare function setModalState(target: any, key: PropertyKey): void;
+declare function setExposeKey(target: any, key: PropertyKey): void;
+declare function setIgnoreKey(target: any, key: PropertyKey): void;
+declare function getModelState(target: any): string[];
+declare function getExposeKey(target: any): string[];
+declare function getIgnoreKey(target: any): string[];
+declare function regisHandler(target: any, key: PropertyKey, handler: PhecdaHandler): void;
+declare function getHandler(target: any, key: PropertyKey): any;
+declare function Init(target: any, key: string): void;
+declare function Rule(rule: RegExp | string | Function | number, info: string, meta?: any): (obj: any, key: string) => void;
+declare function Ignore(target: any, key: string): void;
+declare function Clear(target: any, key: string): void;
+declare function Err<Fn extends (...args: any) => any>(cb: Fn): (target: any, key: PropertyKey) => void;
+declare function Get(target: any, key: string): void;
+declare function Pipe(v: ReturnType<typeof to>): (obj: any, key: string) => void;
+declare function Watcher(eventName: string): (obj: any, key: string) => void;
+declare function Tag(tag: string): (target: any) => void;
+declare function Storage(target: any): void;
+
+declare const EXPRESS_RE: RegExp;
+declare const FN_RE: RegExp;
+declare function createFilter<Data extends Record<string, any>>(initState?: Object, option?: {
+    expressionRE?: RegExp;
+    fnRE?: RegExp;
+    exclude?: string[];
+}): {
+    filter: <Schema>(obj: Schema) => SchemaToObj<Schema>;
+    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;
+    store: {
+        [key: string]: Data;
+    };
+    applyStore: (key: string) => void;
+    dispose: () => void;
+    clearStore: (key: string) => void;
+};
+
+declare function validate(p: RegExp | string | Function | Object | Number, v: any): Promise<any>;
+declare function isAsyncFunc(fn: Function): boolean;
+
+declare const emitter: mitt.Emitter<PhecdaEvents>;
+declare const emit: {
+    <Key extends keyof PhecdaEvents>(type: Key, event: PhecdaEvents[Key]): void;
+    <Key_1 extends keyof PhecdaEvents>(type: undefined extends PhecdaEvents[Key_1] ? Key_1 : never): void;
+};
+
+declare const phecdaSymbol: unique symbol;
+declare function createPhecda(): vue.Raw<{
+    install(app: App): void;
+    vProxyMap: WeakMap<object, any>;
+    vMap: WeakMap<object, any>;
+}>;
+interface PhecdaInstance {
+    vProxyMap: WeakMap<any, any>;
+    vMap: WeakMap<any, any>;
+}
+declare function setActivePhecda(phecda: PhecdaInstance): void;
+declare function getActivePhecda(): PhecdaInstance;
+
+type _DeepPartial<T> = {
+    [K in keyof T]?: _DeepPartial<T[K]>;
+};
+
+declare function useR<T extends new (...args: any) => any>(Model: T): UnwrapNestedRefs<InstanceType<T>>;
+declare function usePatch<T extends new (...args: any) => any>(Model: T, Data: _DeepPartial<InstanceType<T>>): void;
+declare function useListen(eventName: Parameters<typeof emitter['on']>[0], cb: Parameters<typeof emitter['on']>[1]): () => void;
+declare function useV<T extends new (...args: any) => any>(Model: T): Vret<InstanceType<T>>;
+declare function cloneV<Instance extends Object>(instance: Instance): Instance;
+declare function initalize<M extends new (...args: any) => any>(Model: M): InstanceType<M> | void;
+declare function clearStorage<M extends new (...args: any) => any>(Model: M, isForceUpdate?: boolean): void;
+declare function deleteStorage(tag: string): void;
+
+export { ClassValue, Clear, EXPRESS_RE, Err, FN_RE, Get, Ignore, Init, Phecda, PhecdaEvents, PhecdaHandler, PhecdaNameSpace, PhecdaWeb, Pipe, Rule, SchemaToObj, Storage, Tag, UsePipeOptions, Vret, Watcher, classToValue, clearStorage, cloneV, createFilter, createPhecda, deleteStorage, emit, emitter, getActivePhecda, getExposeKey, getHandler, getIgnoreKey, getInitEvent, getModelState, initalize, isAsyncFunc, phecdaSymbol, plainToClass, regisHandler, regisInitEvent, register, setActivePhecda, setExposeKey, setIgnoreKey, setModalState, snapShot, to, useListen, usePatch, useR, useV, validate };

package/dist/index.js

@@ -0,0 +1,609 @@
+"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 __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to2, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to2, key) && key !== except)
+        __defProp(to2, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to2;
+};
+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, {
+  Clear: () => Clear,
+  EXPRESS_RE: () => EXPRESS_RE,
+  Err: () => Err,
+  FN_RE: () => FN_RE,
+  Get: () => Get,
+  Ignore: () => Ignore,
+  Init: () => Init,
+  Phecda: () => Phecda,
+  PhecdaWeb: () => PhecdaWeb,
+  Pipe: () => Pipe,
+  Rule: () => Rule,
+  Storage: () => Storage,
+  Tag: () => Tag,
+  Watcher: () => Watcher,
+  classToValue: () => classToValue,
+  clearStorage: () => clearStorage,
+  cloneV: () => cloneV,
+  createFilter: () => createFilter,
+  createPhecda: () => createPhecda,
+  deleteStorage: () => deleteStorage,
+  emit: () => emit,
+  emitter: () => emitter,
+  getActivePhecda: () => getActivePhecda,
+  getExposeKey: () => getExposeKey,
+  getHandler: () => getHandler,
+  getIgnoreKey: () => getIgnoreKey,
+  getInitEvent: () => getInitEvent,
+  getModelState: () => getModelState,
+  initalize: () => initalize,
+  isAsyncFunc: () => isAsyncFunc,
+  phecdaSymbol: () => phecdaSymbol,
+  plainToClass: () => plainToClass,
+  regisHandler: () => regisHandler,
+  regisInitEvent: () => regisInitEvent,
+  register: () => register,
+  setActivePhecda: () => setActivePhecda,
+  setExposeKey: () => setExposeKey,
+  setIgnoreKey: () => setIgnoreKey,
+  setModalState: () => setModalState,
+  snapShot: () => snapShot,
+  to: () => to,
+  useListen: () => useListen,
+  usePatch: () => usePatch,
+  useR: () => useR,
+  useV: () => useV,
+  validate: () => validate
+});
+module.exports = __toCommonJS(src_exports);
+
+// src/emitter.ts
+var import_mitt = __toESM(require("mitt"));
+var emitter = (0, import_mitt.default)();
+var emit = emitter.emit.bind(emitter);
+
+// src/decorators.ts
+function init(target) {
+  if (!target._namespace) {
+    target._namespace = {
+      __INIT_EVENT__: /* @__PURE__ */ new Set(),
+      __EXPOSE_VAR__: /* @__PURE__ */ new Set(),
+      __IGNORE_VAR__: /* @__PURE__ */ new Set(),
+      __STATE_VAR__: /* @__PURE__ */ new Set(),
+      __STATE_HANDLER__: /* @__PURE__ */ new Map()
+    };
+  }
+}
+function regisInitEvent(target, key) {
+  init(target);
+  target._namespace.__INIT_EVENT__.add(key);
+}
+function getInitEvent(target) {
+  init(target);
+  return [...target._namespace.__INIT_EVENT__];
+}
+function setModalState(target, key) {
+  init(target);
+  target._namespace.__STATE_VAR__.add(key);
+  setExposeKey(target, key);
+}
+function setExposeKey(target, key) {
+  init(target);
+  target._namespace.__EXPOSE_VAR__.add(key);
+}
+function setIgnoreKey(target, key) {
+  init(target);
+  target._namespace.__IGNORE_VAR__.add(key);
+}
+function getModelState(target) {
+  init(target);
+  return [...target._namespace.__STATE_VAR__].reverse();
+}
+function getExposeKey(target) {
+  init(target);
+  return [...target._namespace.__EXPOSE_VAR__];
+}
+function getIgnoreKey(target) {
+  init(target);
+  return [...target._namespace.__IGNORE_VAR__];
+}
+function regisHandler(target, key, handler) {
+  init(target);
+  if (!target._namespace.__STATE_HANDLER__.has(key))
+    target._namespace.__STATE_HANDLER__.set(key, [handler]);
+  else
+    target._namespace.__STATE_HANDLER__.get(key).push(handler);
+}
+function getHandler(target, key) {
+  return target._namespace.__STATE_HANDLER__.get(key) || [];
+}
+function Init(target, key) {
+  setModalState(target, key);
+  regisHandler(target, key, {
+    async init(instance) {
+      instance[key]();
+    }
+  });
+}
+function Rule(rule, info, meta) {
+  return (obj, key) => {
+    setModalState(obj, key);
+    regisHandler(obj, key, {
+      rule,
+      info,
+      meta
+    });
+  };
+}
+function Ignore(target, key) {
+  setIgnoreKey(target, key);
+}
+function Clear(target, key) {
+  init(target);
+  target._namespace.__INIT_EVENT__.delete(key);
+  target._namespace.__EXPOSE_VAR__.delete(key);
+  target._namespace.__IGNORE_VAR__.delete(key);
+  target._namespace.__STATE_VAR__.delete(key);
+  target._namespace.__STATE_HANDLER__.delete(key);
+}
+function Err(cb) {
+  return (target, key) => {
+    setModalState(target, key);
+    regisHandler(target, key, {
+      error: cb
+    });
+  };
+}
+function Get(target, key) {
+  setExposeKey(target, key);
+}
+function Pipe(v) {
+  return (obj, key) => {
+    setModalState(obj, key);
+    regisHandler(obj, key, {
+      async pipe(instance) {
+        const tasks = v.value;
+        for (const task of tasks)
+          instance[key] = await task(instance[key]);
+      }
+    });
+  };
+}
+function Watcher(eventName) {
+  return (obj, key) => {
+    setModalState(obj, key);
+    regisHandler(obj, key, {
+      init(instance) {
+        emitter.on(eventName, instance[key].bind(instance));
+      }
+    });
+  };
+}
+function Tag(tag) {
+  return (target) => {
+    target.prototype._symbol = tag;
+  };
+}
+function Storage(target) {
+  init(target.prototype);
+  const tag = target.prototype._symbol;
+  const uniTag = Symbol(tag);
+  setModalState(target.prototype, uniTag);
+  regisHandler(target.prototype, uniTag, {
+    init: (instance) => {
+      const { state } = instance;
+      window.addEventListener("beforeunload", () => {
+        localStorage.setItem(`_phecda_${tag}`, JSON.stringify(state));
+      });
+      const lastObjStr = localStorage.getItem(`_phecda_${tag}`);
+      if (lastObjStr && lastObjStr !== "undefined") {
+        const lastObj = JSON.parse(lastObjStr);
+        for (const i in lastObj)
+          state[i] = lastObj[i];
+      }
+    }
+  });
+}
+
+// src/model.ts
+var Phecda = class {
+  constructor() {
+    if (!this._symbol)
+      throw new Error("phecda miss tag");
+    if (!Phecda.__PHECDA_MODEL__) {
+      Phecda.__PHECDA_MODEL__ = [];
+      Phecda.__PHECDA_NAMESPACE__ = {};
+      Phecda.__PHECDA_EMIT__ = emitter;
+    }
+  }
+  on(type, handler) {
+    Phecda.__PHECDA_EMIT__.on(type, handler);
+  }
+  emit(type, event) {
+    Phecda.__PHECDA_EMIT__.emit(type, event);
+  }
+  off(type, handler) {
+    Phecda.__PHECDA_EMIT__.off(type, handler);
+  }
+};
+var PhecdaWeb = class extends Phecda {
+  constructor() {
+    super();
+    if (!window.__PHECDA_EMIT__) {
+      window.__PHECDA_EMIT__ = Phecda.__PHECDA_EMIT__;
+      window.__PHECDA_MODEL__ = Phecda.__PHECDA_MODEL__;
+      window.__PHECDA_NAMESPACE__ = Phecda.__PHECDA_NAMESPACE__;
+    }
+  }
+};
+function register(instance) {
+  const stateVars = getModelState(instance);
+  for (const item of stateVars) {
+    const handlers = getHandler(instance, item);
+    for (const hanlder of handlers)
+      hanlder.init?.(instance);
+  }
+}
+
+// src/utils.ts
+async function validate(p, v) {
+  if (typeof p === "string" || typeof p === "number") {
+    if (v === p)
+      return true;
+  }
+  if (typeof p === "function")
+    return p(v);
+  if (p instanceof RegExp)
+    return p.test(v);
+  return false;
+}
+function isAsyncFunc(fn) {
+  return fn[Symbol.toStringTag] === "AsyncFunction";
+}
+
+// src/composable.ts
+async function plainToClass(Model, input, options = {}) {
+  const data = new Model();
+  const resolvedOptions = {
+    collectError: true,
+    transform: false,
+    ...options
+  };
+  const err = [];
+  const stateVars = getModelState(data);
+  for (const item of stateVars) {
+    data[item] = input[item];
+    const handlers = getHandler(data, item);
+    if (handlers) {
+      for (const handler of handlers) {
+        const rule = handler.rule;
+        if (rule && !await validate(rule, data[item])) {
+          err.push(handler.info || "");
+          if (!resolvedOptions.collectError)
+            break;
+        }
+      }
+      if (err.length > 0 && !resolvedOptions.transform)
+        return { err, data };
+      for (const handler of handlers)
+        await handler.pipe?.(data);
+    }
+  }
+  return { data, err };
+}
+function classToValue(instance) {
+  const data = {};
+  const exposeVar = getExposeKey(instance);
+  const ignoreVars = getIgnoreKey(instance);
+  for (const item of exposeVar) {
+    if (ignoreVars.includes(item))
+      continue;
+    data[item] = instance[item];
+  }
+  return data;
+}
+function to(task, oldTasks) {
+  const tasks = oldTasks || [];
+  tasks.push(task);
+  return { to: (task2) => to(task2, tasks), value: tasks };
+}
+function snapShot(data) {
+  const snap = {};
+  for (const i in data)
+    snap[i] = data[i];
+  return {
+    data,
+    clear() {
+      for (const i in snap)
+        delete data[i];
+    },
+    apply() {
+      for (const i in snap)
+        data[i] = snap[i];
+    }
+  };
+}
+
+// src/filter.ts
+var import_vue = require("vue");
+var EXPRESS_RE = /^{{(.*)}}$/;
+var FN_RE = /^\[\[(.*)\]\]$/;
+function createFilter(initState = {}, option = {}) {
+  const resolveOption = Object.assign(
+    {
+      expressionRE: EXPRESS_RE,
+      fnRE: FN_RE,
+      exclude: []
+    },
+    option
+  );
+  let data = (0, import_vue.ref)(initState);
+  let store = {};
+  function traverse(obj) {
+    for (const i in obj) {
+      if (Array.isArray(obj[i]) || resolveOption.exclude.includes(i))
+        continue;
+      if (typeof obj[i] === "object" && obj[i])
+        traverse(obj[i]);
+      if (typeof obj[i] === "string") {
+        if (resolveOption.expressionRE.test(obj[i])) {
+          const body = obj[i].match(resolveOption.expressionRE)[1];
+          Object.defineProperty(obj, i, {
+            get() {
+              return new Function(...Object.keys(data.value), `return ${body}`)(
+                ...Object.values(data.value)
+              );
+            }
+          });
+        }
+        if (resolveOption.fnRE.test(obj[i])) {
+          const body = obj[i].match(resolveOption.fnRE)[1];
+          Object.defineProperty(obj, i, {
+            get() {
+              return new Function(...Object.keys(data.value), `${body}`)(
+                ...Object.values(data.value)
+              );
+            }
+          });
+        }
+      }
+    }
+  }
+  function filter(obj) {
+    obj = (0, import_vue.reactive)(obj);
+    traverse(obj);
+    return obj;
+  }
+  function setState(key, value) {
+    data.value[key] = value;
+  }
+  function storeState(key, params) {
+    store[key] = data.value;
+    init2(params);
+  }
+  function applyStore(key) {
+    if (!store[key])
+      return;
+    data.value = store[key];
+  }
+  function init2(params) {
+    data.value = params || initState || {};
+  }
+  function clearStore(key) {
+    delete store[key];
+  }
+  function dispose() {
+    data = null;
+    store = null;
+  }
+  return { filter, data, init: init2, setState, storeState, store, applyStore, dispose, clearStore };
+}
+
+// src/vue/phecda.ts
+var import_vue2 = require("vue");
+var phecdaSymbol = Symbol("phecda");
+function createPhecda() {
+  const phecda = (0, import_vue2.markRaw)({
+    install(app) {
+      app.provide(phecdaSymbol, phecda);
+      app.config.globalProperties.$phecda = phecda;
+    },
+    vProxyMap: /* @__PURE__ */ new WeakMap(),
+    vMap: /* @__PURE__ */ new WeakMap()
+  });
+  return phecda;
+}
+var activePhecda = {
+  vProxyMap: /* @__PURE__ */ new WeakMap(),
+  vMap: /* @__PURE__ */ new WeakMap()
+};
+function setActivePhecda(phecda) {
+  activePhecda = phecda;
+}
+function getActivePhecda() {
+  return activePhecda;
+}
+
+// src/vue/composable.ts
+var import_vue4 = require("vue");
+
+// src/vue/utils.ts
+var import_vue3 = require("vue");
+function isObject(o) {
+  return Object.prototype.toString.call(o) === "[object Object]";
+}
+function mergeReactiveObjects(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) && !(0, import_vue3.isRef)(subPatch) && !(0, import_vue3.isReactive)(subPatch)) {
+      target[key] = mergeReactiveObjects(targetValue, subPatch);
+    } else {
+      target[key] = subPatch;
+    }
+  }
+  return target;
+}
+
+// src/vue/composable.ts
+function useR(Model) {
+  if ((0, import_vue4.getCurrentInstance)()) {
+    const cur = (0, import_vue4.inject)(phecdaSymbol, null);
+    if (cur)
+      setActivePhecda(cur);
+  }
+  const { vMap } = getActivePhecda();
+  if (!vMap.has(Model)) {
+    const instance = (0, import_vue4.reactive)(new Model());
+    vMap.set(Model, instance);
+    register(instance);
+  }
+  return vMap.get(Model);
+}
+function usePatch(Model, Data) {
+  useR(Model);
+  const { vMap } = getActivePhecda();
+  const target = vMap.get(Model);
+  mergeReactiveObjects(target, Data);
+}
+function useListen(eventName, cb) {
+  (0, import_vue4.onUnmounted)(() => {
+    emitter.off(eventName, cb);
+  });
+  emitter.on(eventName, cb);
+  return () => emitter.off(eventName, cb);
+}
+function useV(Model) {
+  useR(Model);
+  const { vProxyMap, vMap } = getActivePhecda();
+  if (vProxyMap.has(Model))
+    return vProxyMap.get(Model);
+  const instance = vMap.get(Model);
+  const proxy = new Proxy(instance, {
+    get(target, key) {
+      if (typeof target[key] === "function") {
+        const errorHandler = getHandler(target, key).find((item) => item.error)?.error;
+        if (!errorHandler)
+          return target[key].bind(target);
+        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);
+            }
+          };
+        }
+      }
+      return (0, import_vue4.computed)({
+        get() {
+          return target[key];
+        },
+        set(v) {
+          return target[key] = v;
+        }
+      });
+    },
+    set(target, key, v) {
+      target[key] = v;
+      return true;
+    }
+  });
+  vProxyMap.set(Model, proxy);
+  return proxy;
+}
+function cloneV(instance) {
+  const newInstance = {};
+  for (const key in instance) {
+    if (instance.hasOwnProperty(key))
+      newInstance[key] = instance[key];
+  }
+  return newInstance;
+}
+function initalize(Model) {
+  const instance = useR(Model);
+  if (instance) {
+    Object.assign(instance, new Model());
+    return instance;
+  }
+}
+function clearStorage(Model, isForceUpdate = true) {
+  localStorage.removeItem(`_phecda_${useR(Model)._symbol}`);
+  isForceUpdate && initalize(Model);
+}
+function deleteStorage(tag) {
+  localStorage.removeItem(`_phecda_${tag}`);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Clear,
+  EXPRESS_RE,
+  Err,
+  FN_RE,
+  Get,
+  Ignore,
+  Init,
+  Phecda,
+  PhecdaWeb,
+  Pipe,
+  Rule,
+  Storage,
+  Tag,
+  Watcher,
+  classToValue,
+  clearStorage,
+  cloneV,
+  createFilter,
+  createPhecda,
+  deleteStorage,
+  emit,
+  emitter,
+  getActivePhecda,
+  getExposeKey,
+  getHandler,
+  getIgnoreKey,
+  getInitEvent,
+  getModelState,
+  initalize,
+  isAsyncFunc,
+  phecdaSymbol,
+  plainToClass,
+  regisHandler,
+  regisInitEvent,
+  register,
+  setActivePhecda,
+  setExposeKey,
+  setIgnoreKey,
+  setModalState,
+  snapShot,
+  to,
+  useListen,
+  usePatch,
+  useR,
+  useV,
+  validate
+});

package/dist/index.mjs

@@ -0,0 +1,531 @@
+// src/emitter.ts
+import mitt from "mitt";
+var emitter = mitt();
+var emit = emitter.emit.bind(emitter);
+
+// src/decorators.ts
+function init(target) {
+  if (!target._namespace) {
+    target._namespace = {
+      __INIT_EVENT__: /* @__PURE__ */ new Set(),
+      __EXPOSE_VAR__: /* @__PURE__ */ new Set(),
+      __IGNORE_VAR__: /* @__PURE__ */ new Set(),
+      __STATE_VAR__: /* @__PURE__ */ new Set(),
+      __STATE_HANDLER__: /* @__PURE__ */ new Map()
+    };
+  }
+}
+function regisInitEvent(target, key) {
+  init(target);
+  target._namespace.__INIT_EVENT__.add(key);
+}
+function getInitEvent(target) {
+  init(target);
+  return [...target._namespace.__INIT_EVENT__];
+}
+function setModalState(target, key) {
+  init(target);
+  target._namespace.__STATE_VAR__.add(key);
+  setExposeKey(target, key);
+}
+function setExposeKey(target, key) {
+  init(target);
+  target._namespace.__EXPOSE_VAR__.add(key);
+}
+function setIgnoreKey(target, key) {
+  init(target);
+  target._namespace.__IGNORE_VAR__.add(key);
+}
+function getModelState(target) {
+  init(target);
+  return [...target._namespace.__STATE_VAR__].reverse();
+}
+function getExposeKey(target) {
+  init(target);
+  return [...target._namespace.__EXPOSE_VAR__];
+}
+function getIgnoreKey(target) {
+  init(target);
+  return [...target._namespace.__IGNORE_VAR__];
+}
+function regisHandler(target, key, handler) {
+  init(target);
+  if (!target._namespace.__STATE_HANDLER__.has(key))
+    target._namespace.__STATE_HANDLER__.set(key, [handler]);
+  else
+    target._namespace.__STATE_HANDLER__.get(key).push(handler);
+}
+function getHandler(target, key) {
+  return target._namespace.__STATE_HANDLER__.get(key) || [];
+}
+function Init(target, key) {
+  setModalState(target, key);
+  regisHandler(target, key, {
+    async init(instance) {
+      instance[key]();
+    }
+  });
+}
+function Rule(rule, info, meta) {
+  return (obj, key) => {
+    setModalState(obj, key);
+    regisHandler(obj, key, {
+      rule,
+      info,
+      meta
+    });
+  };
+}
+function Ignore(target, key) {
+  setIgnoreKey(target, key);
+}
+function Clear(target, key) {
+  init(target);
+  target._namespace.__INIT_EVENT__.delete(key);
+  target._namespace.__EXPOSE_VAR__.delete(key);
+  target._namespace.__IGNORE_VAR__.delete(key);
+  target._namespace.__STATE_VAR__.delete(key);
+  target._namespace.__STATE_HANDLER__.delete(key);
+}
+function Err(cb) {
+  return (target, key) => {
+    setModalState(target, key);
+    regisHandler(target, key, {
+      error: cb
+    });
+  };
+}
+function Get(target, key) {
+  setExposeKey(target, key);
+}
+function Pipe(v) {
+  return (obj, key) => {
+    setModalState(obj, key);
+    regisHandler(obj, key, {
+      async pipe(instance) {
+        const tasks = v.value;
+        for (const task of tasks)
+          instance[key] = await task(instance[key]);
+      }
+    });
+  };
+}
+function Watcher(eventName) {
+  return (obj, key) => {
+    setModalState(obj, key);
+    regisHandler(obj, key, {
+      init(instance) {
+        emitter.on(eventName, instance[key].bind(instance));
+      }
+    });
+  };
+}
+function Tag(tag) {
+  return (target) => {
+    target.prototype._symbol = tag;
+  };
+}
+function Storage(target) {
+  init(target.prototype);
+  const tag = target.prototype._symbol;
+  const uniTag = Symbol(tag);
+  setModalState(target.prototype, uniTag);
+  regisHandler(target.prototype, uniTag, {
+    init: (instance) => {
+      const { state } = instance;
+      window.addEventListener("beforeunload", () => {
+        localStorage.setItem(`_phecda_${tag}`, JSON.stringify(state));
+      });
+      const lastObjStr = localStorage.getItem(`_phecda_${tag}`);
+      if (lastObjStr && lastObjStr !== "undefined") {
+        const lastObj = JSON.parse(lastObjStr);
+        for (const i in lastObj)
+          state[i] = lastObj[i];
+      }
+    }
+  });
+}
+
+// src/model.ts
+var Phecda = class {
+  constructor() {
+    if (!this._symbol)
+      throw new Error("phecda miss tag");
+    if (!Phecda.__PHECDA_MODEL__) {
+      Phecda.__PHECDA_MODEL__ = [];
+      Phecda.__PHECDA_NAMESPACE__ = {};
+      Phecda.__PHECDA_EMIT__ = emitter;
+    }
+  }
+  on(type, handler) {
+    Phecda.__PHECDA_EMIT__.on(type, handler);
+  }
+  emit(type, event) {
+    Phecda.__PHECDA_EMIT__.emit(type, event);
+  }
+  off(type, handler) {
+    Phecda.__PHECDA_EMIT__.off(type, handler);
+  }
+};
+var PhecdaWeb = class extends Phecda {
+  constructor() {
+    super();
+    if (!window.__PHECDA_EMIT__) {
+      window.__PHECDA_EMIT__ = Phecda.__PHECDA_EMIT__;
+      window.__PHECDA_MODEL__ = Phecda.__PHECDA_MODEL__;
+      window.__PHECDA_NAMESPACE__ = Phecda.__PHECDA_NAMESPACE__;
+    }
+  }
+};
+function register(instance) {
+  const stateVars = getModelState(instance);
+  for (const item of stateVars) {
+    const handlers = getHandler(instance, item);
+    for (const hanlder of handlers)
+      hanlder.init?.(instance);
+  }
+}
+
+// src/utils.ts
+async function validate(p, v) {
+  if (typeof p === "string" || typeof p === "number") {
+    if (v === p)
+      return true;
+  }
+  if (typeof p === "function")
+    return p(v);
+  if (p instanceof RegExp)
+    return p.test(v);
+  return false;
+}
+function isAsyncFunc(fn) {
+  return fn[Symbol.toStringTag] === "AsyncFunction";
+}
+
+// src/composable.ts
+async function plainToClass(Model, input, options = {}) {
+  const data = new Model();
+  const resolvedOptions = {
+    collectError: true,
+    transform: false,
+    ...options
+  };
+  const err = [];
+  const stateVars = getModelState(data);
+  for (const item of stateVars) {
+    data[item] = input[item];
+    const handlers = getHandler(data, item);
+    if (handlers) {
+      for (const handler of handlers) {
+        const rule = handler.rule;
+        if (rule && !await validate(rule, data[item])) {
+          err.push(handler.info || "");
+          if (!resolvedOptions.collectError)
+            break;
+        }
+      }
+      if (err.length > 0 && !resolvedOptions.transform)
+        return { err, data };
+      for (const handler of handlers)
+        await handler.pipe?.(data);
+    }
+  }
+  return { data, err };
+}
+function classToValue(instance) {
+  const data = {};
+  const exposeVar = getExposeKey(instance);
+  const ignoreVars = getIgnoreKey(instance);
+  for (const item of exposeVar) {
+    if (ignoreVars.includes(item))
+      continue;
+    data[item] = instance[item];
+  }
+  return data;
+}
+function to(task, oldTasks) {
+  const tasks = oldTasks || [];
+  tasks.push(task);
+  return { to: (task2) => to(task2, tasks), value: tasks };
+}
+function snapShot(data) {
+  const snap = {};
+  for (const i in data)
+    snap[i] = data[i];
+  return {
+    data,
+    clear() {
+      for (const i in snap)
+        delete data[i];
+    },
+    apply() {
+      for (const i in snap)
+        data[i] = snap[i];
+    }
+  };
+}
+
+// src/filter.ts
+import { reactive, ref } from "vue";
+var EXPRESS_RE = /^{{(.*)}}$/;
+var FN_RE = /^\[\[(.*)\]\]$/;
+function createFilter(initState = {}, option = {}) {
+  const resolveOption = Object.assign(
+    {
+      expressionRE: EXPRESS_RE,
+      fnRE: FN_RE,
+      exclude: []
+    },
+    option
+  );
+  let data = ref(initState);
+  let store = {};
+  function traverse(obj) {
+    for (const i in obj) {
+      if (Array.isArray(obj[i]) || resolveOption.exclude.includes(i))
+        continue;
+      if (typeof obj[i] === "object" && obj[i])
+        traverse(obj[i]);
+      if (typeof obj[i] === "string") {
+        if (resolveOption.expressionRE.test(obj[i])) {
+          const body = obj[i].match(resolveOption.expressionRE)[1];
+          Object.defineProperty(obj, i, {
+            get() {
+              return new Function(...Object.keys(data.value), `return ${body}`)(
+                ...Object.values(data.value)
+              );
+            }
+          });
+        }
+        if (resolveOption.fnRE.test(obj[i])) {
+          const body = obj[i].match(resolveOption.fnRE)[1];
+          Object.defineProperty(obj, i, {
+            get() {
+              return new Function(...Object.keys(data.value), `${body}`)(
+                ...Object.values(data.value)
+              );
+            }
+          });
+        }
+      }
+    }
+  }
+  function filter(obj) {
+    obj = reactive(obj);
+    traverse(obj);
+    return obj;
+  }
+  function setState(key, value) {
+    data.value[key] = value;
+  }
+  function storeState(key, params) {
+    store[key] = data.value;
+    init2(params);
+  }
+  function applyStore(key) {
+    if (!store[key])
+      return;
+    data.value = store[key];
+  }
+  function init2(params) {
+    data.value = params || initState || {};
+  }
+  function clearStore(key) {
+    delete store[key];
+  }
+  function dispose() {
+    data = null;
+    store = null;
+  }
+  return { filter, data, init: init2, setState, storeState, store, applyStore, dispose, clearStore };
+}
+
+// src/vue/phecda.ts
+import { markRaw } from "vue";
+var phecdaSymbol = Symbol("phecda");
+function createPhecda() {
+  const phecda = markRaw({
+    install(app) {
+      app.provide(phecdaSymbol, phecda);
+      app.config.globalProperties.$phecda = phecda;
+    },
+    vProxyMap: /* @__PURE__ */ new WeakMap(),
+    vMap: /* @__PURE__ */ new WeakMap()
+  });
+  return phecda;
+}
+var activePhecda = {
+  vProxyMap: /* @__PURE__ */ new WeakMap(),
+  vMap: /* @__PURE__ */ new WeakMap()
+};
+function setActivePhecda(phecda) {
+  activePhecda = phecda;
+}
+function getActivePhecda() {
+  return activePhecda;
+}
+
+// src/vue/composable.ts
+import { computed, getCurrentInstance, inject, onUnmounted, reactive as reactive2 } from "vue";
+
+// src/vue/utils.ts
+import { isReactive, isRef } from "vue";
+function isObject(o) {
+  return Object.prototype.toString.call(o) === "[object Object]";
+}
+function mergeReactiveObjects(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) && !isRef(subPatch) && !isReactive(subPatch)) {
+      target[key] = mergeReactiveObjects(targetValue, subPatch);
+    } else {
+      target[key] = subPatch;
+    }
+  }
+  return target;
+}
+
+// src/vue/composable.ts
+function useR(Model) {
+  if (getCurrentInstance()) {
+    const cur = inject(phecdaSymbol, null);
+    if (cur)
+      setActivePhecda(cur);
+  }
+  const { vMap } = getActivePhecda();
+  if (!vMap.has(Model)) {
+    const instance = reactive2(new Model());
+    vMap.set(Model, instance);
+    register(instance);
+  }
+  return vMap.get(Model);
+}
+function usePatch(Model, Data) {
+  useR(Model);
+  const { vMap } = getActivePhecda();
+  const target = vMap.get(Model);
+  mergeReactiveObjects(target, Data);
+}
+function useListen(eventName, cb) {
+  onUnmounted(() => {
+    emitter.off(eventName, cb);
+  });
+  emitter.on(eventName, cb);
+  return () => emitter.off(eventName, cb);
+}
+function useV(Model) {
+  useR(Model);
+  const { vProxyMap, vMap } = getActivePhecda();
+  if (vProxyMap.has(Model))
+    return vProxyMap.get(Model);
+  const instance = vMap.get(Model);
+  const proxy = new Proxy(instance, {
+    get(target, key) {
+      if (typeof target[key] === "function") {
+        const errorHandler = getHandler(target, key).find((item) => item.error)?.error;
+        if (!errorHandler)
+          return target[key].bind(target);
+        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);
+            }
+          };
+        }
+      }
+      return computed({
+        get() {
+          return target[key];
+        },
+        set(v) {
+          return target[key] = v;
+        }
+      });
+    },
+    set(target, key, v) {
+      target[key] = v;
+      return true;
+    }
+  });
+  vProxyMap.set(Model, proxy);
+  return proxy;
+}
+function cloneV(instance) {
+  const newInstance = {};
+  for (const key in instance) {
+    if (instance.hasOwnProperty(key))
+      newInstance[key] = instance[key];
+  }
+  return newInstance;
+}
+function initalize(Model) {
+  const instance = useR(Model);
+  if (instance) {
+    Object.assign(instance, new Model());
+    return instance;
+  }
+}
+function clearStorage(Model, isForceUpdate = true) {
+  localStorage.removeItem(`_phecda_${useR(Model)._symbol}`);
+  isForceUpdate && initalize(Model);
+}
+function deleteStorage(tag) {
+  localStorage.removeItem(`_phecda_${tag}`);
+}
+export {
+  Clear,
+  EXPRESS_RE,
+  Err,
+  FN_RE,
+  Get,
+  Ignore,
+  Init,
+  Phecda,
+  PhecdaWeb,
+  Pipe,
+  Rule,
+  Storage,
+  Tag,
+  Watcher,
+  classToValue,
+  clearStorage,
+  cloneV,
+  createFilter,
+  createPhecda,
+  deleteStorage,
+  emit,
+  emitter,
+  getActivePhecda,
+  getExposeKey,
+  getHandler,
+  getIgnoreKey,
+  getInitEvent,
+  getModelState,
+  initalize,
+  isAsyncFunc,
+  phecdaSymbol,
+  plainToClass,
+  regisHandler,
+  regisInitEvent,
+  register,
+  setActivePhecda,
+  setExposeKey,
+  setIgnoreKey,
+  setModalState,
+  snapShot,
+  to,
+  useListen,
+  usePatch,
+  useR,
+  useV,
+  validate
+};

package/package.json

@@ -0,0 +1,25 @@
+{
+  "name": "phecda-core",
+  "version": "1.0.0",
+  "description": "",
+  "main": "dist/index.js",
+  "module": "dist/index.mjs",
+  "types": "dist/index.d.ts",
+  "keywords": [],
+  "author": "",
+  "files": [
+    "dist"
+  ],
+  "license": "MIT",
+  "dependencies": {
+    "mitt": "^3.0.0",
+    "vue": "^3.2.45"
+  },
+  "devDependencies": {
+    "tsup": "^6.5.0"
+  },
+  "scripts": {
+    "dev": "tsup --watch",
+    "build": "tsup"
+  }
+}