phecda-vue 1.0.1

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,115 @@
+import * as mitt from 'mitt';
+import { EventType, Handler, Emitter } from 'mitt';
+import * as vue from 'vue';
+import { Ref, App, UnwrapNestedRefs, Component, DefineComponent, ExtractPropTypes } from 'vue';
+import { Phecda } from 'phecda-core';
+export * from 'phecda-core';
+
+type Vret<I> = {
+    [P in keyof I]: I[P] extends Function ? I[P] : Ref<I[P]>;
+};
+type SchemaToObj<S> = {
+    [P in keyof S]: S[P] extends object ? SchemaToObj<S[P]> : (S[P] extends string ? any : S[P]);
+};
+interface PhecdaEvents extends Record<EventType, unknown> {
+    [key: EventType]: any;
+}
+
+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 function Watcher(eventName: string): (obj: any, key: string) => void;
+
+declare const phecdaSymbol: unique symbol;
+declare function createPhecda(): vue.Raw<{
+    install(app: App): void;
+    uesVMap: WeakMap<object, any>;
+    uesOMap: WeakMap<object, any>;
+    uesRMap: WeakMap<object, any>;
+}>;
+interface PhecdaInstance {
+    uesVMap: WeakMap<any, any>;
+    uesOMap: WeakMap<any, any>;
+    uesRMap: 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 useO<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 useR<T extends new (...args: any) => any>(Model: T): UnwrapNestedRefs<InstanceType<T>>;
+declare function useV<T extends new (...args: any) => any>(Model: T): Vret<InstanceType<T>>;
+declare function useOn<Key extends keyof PhecdaEvents>(eventName: Key, cb: Handler<PhecdaEvents[Key]>): () => void;
+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;
+
+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 class P {
+    protected static emitter: Emitter<PhecdaEvents>;
+    protected _namespace: Phecda['_namespace'];
+    constructor();
+    get tag(): string;
+    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 function createForm<P extends {
+    $props: any;
+}>(compSet: Record<string, Component> | any, form: Component<P>, formItem: Component | false, modelKey?: string): DefineComponent<{
+    config: Object;
+    data: Object;
+} & P['$props']>;
+
+declare function createFormData<Schema extends object, Data extends object>(schema: Schema, initData?: Data, options?: {
+    expressionRE?: RegExp;
+    fnRE?: RegExp;
+    exclude?: string[];
+}): {
+    config: SchemaToObj<Schema>;
+    data: vue.Ref<Record<string, any>>;
+};
+
+declare function getElementPlusRules<M, O extends object>(Model: M, options?: O): any;
+declare const GetDevUIRules: typeof getElementPlusRules;
+declare function getNaiveUIRules<M, O extends object>(Model: M, options?: O): any;
+declare const getAntDRules: typeof getNaiveUIRules;
+declare function getNutUIRules<M, O extends object>(Model: M, options?: O): any;
+declare const getVantRules: typeof getNutUIRules;
+
+declare const createModal: <P>(w: Component, k: string) => (comp: DefineComponent<P, any, any>, props?: ExtractPropTypes<P>) => void;
+
+declare function createTable<P extends {
+    $props: any;
+}>(compSet: Record<string, Component> | any, table: Component<P>, tableColumn: Component | false, data?: any): DefineComponent<{
+    config: Object;
+} & P['$props']>;
+
+export { EXPRESS_RE, FN_RE, GetDevUIRules, P, PhecdaEvents, SchemaToObj, Vret, Watcher, clearStorage, createFilter, createForm, createFormData, createModal, createPhecda, createTable, deleteStorage, emit, emitter, getActivePhecda, getAntDRules, getElementPlusRules, getNaiveUIRules, getNutUIRules, getVantRules, initalize, phecdaSymbol, setActivePhecda, useO, useOn, usePatch, useR, useV };

package/dist/index.js

@@ -0,0 +1,650 @@
+"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 = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  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, {
+  EXPRESS_RE: () => EXPRESS_RE,
+  FN_RE: () => FN_RE,
+  GetDevUIRules: () => GetDevUIRules,
+  P: () => P,
+  Watcher: () => Watcher,
+  clearStorage: () => clearStorage,
+  createFilter: () => createFilter,
+  createForm: () => createForm,
+  createFormData: () => createFormData,
+  createModal: () => createModal,
+  createPhecda: () => createPhecda,
+  createTable: () => createTable,
+  deleteStorage: () => deleteStorage,
+  emit: () => emit,
+  emitter: () => emitter,
+  getActivePhecda: () => getActivePhecda,
+  getAntDRules: () => getAntDRules,
+  getElementPlusRules: () => getElementPlusRules,
+  getNaiveUIRules: () => getNaiveUIRules,
+  getNutUIRules: () => getNutUIRules,
+  getVantRules: () => getVantRules,
+  initalize: () => initalize,
+  phecdaSymbol: () => phecdaSymbol,
+  setActivePhecda: () => setActivePhecda,
+  useO: () => useO,
+  useOn: () => useOn,
+  usePatch: () => usePatch,
+  useR: () => useR,
+  useV: () => useV
+});
+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
+var import_phecda_core = require("phecda-core");
+function Watcher(eventName) {
+  return (obj, key) => {
+    (0, import_phecda_core.setModalState)(obj, key);
+    (0, import_phecda_core.regisHandler)(obj, key, {
+      init(instance) {
+        emitter.on(eventName, instance[key].bind(instance));
+      }
+    });
+  };
+}
+
+// src/vue/phecda.ts
+var import_vue = require("vue");
+var phecdaSymbol = Symbol("phecda");
+function createPhecda() {
+  const phecda = (0, import_vue.markRaw)({
+    install(app) {
+      app.provide(phecdaSymbol, phecda);
+      app.config.globalProperties.$phecda = phecda;
+    },
+    uesVMap: /* @__PURE__ */ new WeakMap(),
+    uesOMap: /* @__PURE__ */ new WeakMap(),
+    uesRMap: /* @__PURE__ */ new WeakMap()
+  });
+  return phecda;
+}
+var activePhecda = {
+  uesVMap: /* @__PURE__ */ new WeakMap(),
+  uesOMap: /* @__PURE__ */ new WeakMap(),
+  uesRMap: /* @__PURE__ */ new WeakMap()
+};
+function setActivePhecda(phecda) {
+  activePhecda = phecda;
+}
+function getActivePhecda() {
+  return activePhecda;
+}
+
+// src/vue/composable.ts
+var import_vue3 = require("vue");
+var import_phecda_core2 = require("phecda-core");
+
+// src/vue/utils.ts
+var import_vue2 = 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_vue2.isRef)(subPatch) && !(0, import_vue2.isReactive)(subPatch)) {
+      target[key] = mergeReactiveObjects(targetValue, subPatch);
+    } else {
+      target[key] = subPatch;
+    }
+  }
+  return target;
+}
+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);
+      }
+    };
+  }
+}
+function isAsyncFunc(fn) {
+  return fn[Symbol.toStringTag] === "AsyncFunction";
+}
+
+// src/vue/composable.ts
+function useO(Model) {
+  if ((0, import_vue3.getCurrentInstance)()) {
+    const cur = (0, import_vue3.inject)(phecdaSymbol, null);
+    if (cur)
+      setActivePhecda(cur);
+  }
+  const { uesOMap } = getActivePhecda();
+  if (!uesOMap.has(Model)) {
+    const instance = (0, import_vue3.reactive)(new Model());
+    uesOMap.set(Model, instance);
+    (0, import_phecda_core2.register)(instance);
+  }
+  return uesOMap.get(Model);
+}
+function usePatch(Model, Data) {
+  useO(Model);
+  const { uesOMap } = getActivePhecda();
+  const target = uesOMap.get(Model);
+  mergeReactiveObjects(target, Data);
+}
+function useR(Model) {
+  useO(Model);
+  const { uesRMap, uesOMap } = getActivePhecda();
+  if (uesRMap.has(Model))
+    return uesRMap.get(Model);
+  const instance = uesOMap.get(Model);
+  const proxy = new Proxy(instance, {
+    get(target, key) {
+      if (typeof target[key] === "function") {
+        const errorHandler = (0, import_phecda_core2.getHandler)(target, key).find((item) => item.error)?.error;
+        if (!errorHandler)
+          return target[key].bind(target);
+        return wrapError(target, key, errorHandler);
+      }
+      return target[key];
+    },
+    set(target, key, v) {
+      target[key] = v;
+      return true;
+    }
+  });
+  uesRMap.set(Model, proxy);
+  return proxy;
+}
+function useV(Model) {
+  useO(Model);
+  const { uesVMap, uesOMap } = getActivePhecda();
+  if (uesVMap.has(Model))
+    return uesVMap.get(Model);
+  const instance = uesOMap.get(Model);
+  const proxy = new Proxy(instance, {
+    get(target, key) {
+      if (typeof target[key] === "function") {
+        const errorHandler = (0, import_phecda_core2.getHandler)(target, key).find((item) => item.error)?.error;
+        if (!errorHandler)
+          return target[key].bind(target);
+        return wrapError(target, key, errorHandler);
+      }
+      return (0, import_vue3.computed)({
+        get() {
+          return target[key];
+        },
+        set(v) {
+          return target[key] = v;
+        }
+      });
+    },
+    set() {
+      return false;
+    }
+  });
+  uesVMap.set(Model, proxy);
+  return proxy;
+}
+function useOn(eventName, cb) {
+  (0, import_vue3.onUnmounted)(() => {
+    emitter.off(eventName, cb);
+  });
+  emitter.on(eventName, cb);
+  return () => emitter.off(eventName, cb);
+}
+function initalize(Model) {
+  const instance = useO(Model);
+  if (instance) {
+    Object.assign(instance, new Model());
+    return instance;
+  }
+}
+function clearStorage(Model, isForceUpdate = true) {
+  localStorage.removeItem(`_phecda_${useO(Model)._symbol}`);
+  isForceUpdate && initalize(Model);
+}
+function deleteStorage(tag) {
+  localStorage.removeItem(`_phecda_${tag}`);
+}
+
+// src/filter.ts
+var import_vue4 = 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_vue4.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_vue4.reactive)(obj);
+    traverse(obj);
+    return obj;
+  }
+  function setState(key, value) {
+    data.value[key] = value;
+  }
+  function storeState(key, params) {
+    store[key] = data.value;
+    init(params);
+  }
+  function applyStore(key) {
+    if (!store[key])
+      return;
+    data.value = store[key];
+  }
+  function init(params) {
+    data.value = params || initState || {};
+  }
+  function clearStore(key) {
+    delete store[key];
+  }
+  function dispose() {
+    data = null;
+    store = null;
+  }
+  return { filter, data, init, setState, storeState, store, applyStore, dispose, clearStore };
+}
+
+// src/index.ts
+__reExport(src_exports, require("phecda-core"), module.exports);
+
+// src/wrapper.ts
+var _P = class {
+  constructor() {
+  }
+  get tag() {
+    return this._namespace.__TAG__;
+  }
+  on(type, handler) {
+    _P.emitter.on(type, handler);
+  }
+  emit(type, event) {
+    _P.emitter.emit(type, event);
+  }
+  off(type, handler) {
+    _P.emitter.off(type, handler);
+  }
+};
+var P = _P;
+P.emitter = emitter;
+
+// src/components/createForm.ts
+var import_vue5 = require("vue");
+function createForm(compSet, form, formItem, modelKey = "modelValue") {
+  function generateChildVNode(props) {
+    return props._children?.map(
+      (item) => (0, import_vue5.h)(compSet[item._component], item)
+    );
+  }
+  function generateVNode(props) {
+    return (0, import_vue5.h)(
+      compSet[props.config[props.property]._component],
+      {
+        ...props.config[props.property],
+        [`${modelKey}`]: props.data[props.property],
+        [`onUpdate:${modelKey}`]: (v) => {
+          props.data[props.property] = v;
+        }
+      },
+      {
+        default: () => generateChildVNode(props.config[props.property])
+      }
+    );
+  }
+  const FormItem = (0, import_vue5.defineComponent)({
+    name: "CustomFormItem",
+    props: {
+      formItem: { type: Object },
+      config: {
+        type: Object,
+        required: true
+      },
+      data: {
+        type: Object,
+        required: true
+      },
+      property: {
+        type: String,
+        required: true
+      }
+    },
+    setup(props) {
+      return () => {
+        return formItem ? (0, import_vue5.h)(
+          formItem,
+          {
+            ...props.formItem
+          },
+          {
+            default: () => {
+              return generateVNode(props);
+            }
+          }
+        ) : generateVNode(props);
+      };
+    }
+  });
+  return (0, import_vue5.defineComponent)({
+    name: "CustomForm",
+    props: {
+      config: {
+        type: Object,
+        required: true
+      },
+      data: {
+        type: Object,
+        required: true
+      }
+    },
+    setup(props, ctx) {
+      const dom = (0, import_vue5.ref)();
+      (0, import_vue5.onMounted)(() => {
+        ctx.expose({ ...dom.value });
+      });
+      return () => {
+        return (0, import_vue5.h)(form, Object.assign({ ref: dom }, ctx.attrs), {
+          default: () => Object.keys(props.config).map((item) => {
+            return (0, import_vue5.h)(FormItem, {
+              formItem: props.config[item]._formItem,
+              config: props.config,
+              property: item,
+              data: props.data
+            });
+          })
+        });
+      };
+    }
+  });
+}
+
+// src/components/formFilter.ts
+function createFormData(schema, initData = {}, options = {}) {
+  const { data, filter } = createFilter(initData, options);
+  initlize(schema, data.value);
+  const filterRet = filter(schema);
+  function initlize(obj1, obj2) {
+    for (const i in obj1) {
+      if (obj1[i]._default)
+        obj2[i] = obj1[i]._default;
+    }
+  }
+  return { config: filterRet, data };
+}
+
+// src/components/formResolve.ts
+var import_phecda_core3 = require("phecda-core");
+function getElementPlusRules(Model, options = {}) {
+  const stateVars = (0, import_phecda_core3.getModelState)(Model);
+  const ret = {};
+  for (const item of stateVars) {
+    const handlers = (0, import_phecda_core3.getHandler)(Model, item);
+    if (handlers) {
+      for (const handler of handlers) {
+        const { rule, meta, info } = handler;
+        if (rule) {
+          if (!ret[item])
+            ret[item] = [];
+          ret[item].push({
+            validator: async (_, value, callback) => {
+              if (!await (0, import_phecda_core3.validate)(rule, value))
+                callback(new Error(info || ""));
+              else
+                callback();
+            },
+            ...options,
+            ...meta || {}
+          });
+        }
+      }
+    }
+  }
+  return ret;
+}
+var GetDevUIRules = getElementPlusRules;
+function getNaiveUIRules(Model, options = {}) {
+  const stateVars = (0, import_phecda_core3.getModelState)(Model);
+  const ret = {};
+  for (const item of stateVars) {
+    const handlers = (0, import_phecda_core3.getHandler)(Model, item);
+    if (handlers) {
+      for (const handler of handlers) {
+        const { rule, meta, info } = handler;
+        if (rule) {
+          if (!ret[item])
+            ret[item] = [];
+          ret[item].push({
+            validator: async (_, value) => {
+              if (!await (0, import_phecda_core3.validate)(rule, value))
+                return Promise.reject(info);
+              else
+                return Promise.resolve();
+            },
+            ...options,
+            ...meta || {}
+          });
+        }
+      }
+    }
+  }
+  return ret;
+}
+var getAntDRules = getNaiveUIRules;
+function getNutUIRules(Model, options = {}) {
+  const stateVars = (0, import_phecda_core3.getModelState)(Model);
+  const ret = {};
+  for (const item of stateVars) {
+    const handlers = (0, import_phecda_core3.getHandler)(Model, item);
+    if (handlers) {
+      for (const handler of handlers) {
+        const { rule, meta, info } = handler;
+        if (rule) {
+          if (!ret[item])
+            ret[item] = [];
+          ret[item].push({
+            validator: async (_, value) => {
+              if (!await (0, import_phecda_core3.validate)(rule, value))
+                return false;
+              else
+                return true;
+            },
+            message: info,
+            ...options,
+            ...meta || {}
+          });
+        }
+      }
+    }
+  }
+  return ret;
+}
+var getVantRules = getNutUIRules;
+
+// src/components/createModal.ts
+var import_vue6 = require("vue");
+var createModal = function(modalWrapper, modelKey = "modelValue") {
+  let isMounted = false;
+  const isShow = (0, import_vue6.ref)(true);
+  const content = (0, import_vue6.shallowRef)();
+  const propsRef = (0, import_vue6.ref)({});
+  const wrapper = (0, import_vue6.defineComponent)({
+    setup() {
+      return () => (0, import_vue6.h)(modalWrapper, {
+        [modelKey]: isShow.value,
+        [`onUpdate:${modelKey}`]: (v) => {
+          isShow.value = v;
+        }
+      }, {
+        default: () => content.value && (0, import_vue6.h)(content.value, propsRef.value)
+      });
+    }
+  });
+  return (comp, props) => {
+    content.value = comp;
+    propsRef.value = props;
+    if (!isMounted) {
+      const el = document.createElement("div");
+      const vnode = (0, import_vue6.h)(wrapper);
+      document.body.appendChild(((0, import_vue6.render)(vnode, el), el));
+      isMounted = true;
+    } else {
+      isShow.value = true;
+    }
+  };
+};
+
+// src/components/createTable.ts
+var import_vue7 = require("vue");
+function createTable(compSet, table, tableColumn, data) {
+  const TableColumn = (0, import_vue7.defineComponent)({
+    name: "PhecdaTableColumn",
+    props: {
+      tableColumn: {
+        type: Object,
+        required: true
+      }
+    },
+    setup(props) {
+      const compName = props.tableColumn._component;
+      return () => (0, import_vue7.h)(
+        tableColumn,
+        {
+          ...props.tableColumn
+        },
+        {
+          default: (scope) => {
+            return compName ? (0, import_vue7.h)(compSet[compName], { scope, data, ...props.tableColumn._props || {} }) : null;
+          }
+        }
+      );
+    }
+  });
+  return (0, import_vue7.defineComponent)({
+    name: "PhecdaTable",
+    props: {
+      config: {
+        type: Array,
+        required: true
+      }
+    },
+    setup(props, ctx) {
+      const dom = (0, import_vue7.ref)();
+      (0, import_vue7.onMounted)(() => {
+        ctx.expose({ ...dom.value });
+      });
+      return () => {
+        return (0, import_vue7.h)(table, Object.assign({ ref: dom }, ctx.attrs), {
+          default: () => props.config.map((item) => {
+            return (0, import_vue7.h)(TableColumn, {
+              tableColumn: item
+            });
+          })
+        });
+      };
+    }
+  });
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  EXPRESS_RE,
+  FN_RE,
+  GetDevUIRules,
+  P,
+  Watcher,
+  clearStorage,
+  createFilter,
+  createForm,
+  createFormData,
+  createModal,
+  createPhecda,
+  createTable,
+  deleteStorage,
+  emit,
+  emitter,
+  getActivePhecda,
+  getAntDRules,
+  getElementPlusRules,
+  getNaiveUIRules,
+  getNutUIRules,
+  getVantRules,
+  initalize,
+  phecdaSymbol,
+  setActivePhecda,
+  useO,
+  useOn,
+  usePatch,
+  useR,
+  useV
+});

package/dist/index.mjs

@@ -0,0 +1,588 @@
+// src/emitter.ts
+import mitt from "mitt";
+var emitter = mitt();
+var emit = emitter.emit.bind(emitter);
+
+// src/decorators.ts
+import { regisHandler, setModalState } from "phecda-core";
+function Watcher(eventName) {
+  return (obj, key) => {
+    setModalState(obj, key);
+    regisHandler(obj, key, {
+      init(instance) {
+        emitter.on(eventName, instance[key].bind(instance));
+      }
+    });
+  };
+}
+
+// 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;
+    },
+    uesVMap: /* @__PURE__ */ new WeakMap(),
+    uesOMap: /* @__PURE__ */ new WeakMap(),
+    uesRMap: /* @__PURE__ */ new WeakMap()
+  });
+  return phecda;
+}
+var activePhecda = {
+  uesVMap: /* @__PURE__ */ new WeakMap(),
+  uesOMap: /* @__PURE__ */ new WeakMap(),
+  uesRMap: /* @__PURE__ */ new WeakMap()
+};
+function setActivePhecda(phecda) {
+  activePhecda = phecda;
+}
+function getActivePhecda() {
+  return activePhecda;
+}
+
+// src/vue/composable.ts
+import { computed, getCurrentInstance, inject, onUnmounted, reactive } from "vue";
+import { getHandler, register } from "phecda-core";
+
+// 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;
+}
+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);
+      }
+    };
+  }
+}
+function isAsyncFunc(fn) {
+  return fn[Symbol.toStringTag] === "AsyncFunction";
+}
+
+// src/vue/composable.ts
+function useO(Model) {
+  if (getCurrentInstance()) {
+    const cur = inject(phecdaSymbol, null);
+    if (cur)
+      setActivePhecda(cur);
+  }
+  const { uesOMap } = getActivePhecda();
+  if (!uesOMap.has(Model)) {
+    const instance = reactive(new Model());
+    uesOMap.set(Model, instance);
+    register(instance);
+  }
+  return uesOMap.get(Model);
+}
+function usePatch(Model, Data) {
+  useO(Model);
+  const { uesOMap } = getActivePhecda();
+  const target = uesOMap.get(Model);
+  mergeReactiveObjects(target, Data);
+}
+function useR(Model) {
+  useO(Model);
+  const { uesRMap, uesOMap } = getActivePhecda();
+  if (uesRMap.has(Model))
+    return uesRMap.get(Model);
+  const instance = uesOMap.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);
+        return wrapError(target, key, errorHandler);
+      }
+      return target[key];
+    },
+    set(target, key, v) {
+      target[key] = v;
+      return true;
+    }
+  });
+  uesRMap.set(Model, proxy);
+  return proxy;
+}
+function useV(Model) {
+  useO(Model);
+  const { uesVMap, uesOMap } = getActivePhecda();
+  if (uesVMap.has(Model))
+    return uesVMap.get(Model);
+  const instance = uesOMap.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);
+        return wrapError(target, key, errorHandler);
+      }
+      return computed({
+        get() {
+          return target[key];
+        },
+        set(v) {
+          return target[key] = v;
+        }
+      });
+    },
+    set() {
+      return false;
+    }
+  });
+  uesVMap.set(Model, proxy);
+  return proxy;
+}
+function useOn(eventName, cb) {
+  onUnmounted(() => {
+    emitter.off(eventName, cb);
+  });
+  emitter.on(eventName, cb);
+  return () => emitter.off(eventName, cb);
+}
+function initalize(Model) {
+  const instance = useO(Model);
+  if (instance) {
+    Object.assign(instance, new Model());
+    return instance;
+  }
+}
+function clearStorage(Model, isForceUpdate = true) {
+  localStorage.removeItem(`_phecda_${useO(Model)._symbol}`);
+  isForceUpdate && initalize(Model);
+}
+function deleteStorage(tag) {
+  localStorage.removeItem(`_phecda_${tag}`);
+}
+
+// src/filter.ts
+import { reactive as reactive2, 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 = reactive2(obj);
+    traverse(obj);
+    return obj;
+  }
+  function setState(key, value) {
+    data.value[key] = value;
+  }
+  function storeState(key, params) {
+    store[key] = data.value;
+    init(params);
+  }
+  function applyStore(key) {
+    if (!store[key])
+      return;
+    data.value = store[key];
+  }
+  function init(params) {
+    data.value = params || initState || {};
+  }
+  function clearStore(key) {
+    delete store[key];
+  }
+  function dispose() {
+    data = null;
+    store = null;
+  }
+  return { filter, data, init, setState, storeState, store, applyStore, dispose, clearStore };
+}
+
+// src/index.ts
+export * from "phecda-core";
+
+// src/wrapper.ts
+var _P = class {
+  constructor() {
+  }
+  get tag() {
+    return this._namespace.__TAG__;
+  }
+  on(type, handler) {
+    _P.emitter.on(type, handler);
+  }
+  emit(type, event) {
+    _P.emitter.emit(type, event);
+  }
+  off(type, handler) {
+    _P.emitter.off(type, handler);
+  }
+};
+var P = _P;
+P.emitter = emitter;
+
+// src/components/createForm.ts
+import { defineComponent, h, onMounted, ref as ref2 } from "vue";
+function createForm(compSet, form, formItem, modelKey = "modelValue") {
+  function generateChildVNode(props) {
+    return props._children?.map(
+      (item) => h(compSet[item._component], item)
+    );
+  }
+  function generateVNode(props) {
+    return h(
+      compSet[props.config[props.property]._component],
+      {
+        ...props.config[props.property],
+        [`${modelKey}`]: props.data[props.property],
+        [`onUpdate:${modelKey}`]: (v) => {
+          props.data[props.property] = v;
+        }
+      },
+      {
+        default: () => generateChildVNode(props.config[props.property])
+      }
+    );
+  }
+  const FormItem = defineComponent({
+    name: "CustomFormItem",
+    props: {
+      formItem: { type: Object },
+      config: {
+        type: Object,
+        required: true
+      },
+      data: {
+        type: Object,
+        required: true
+      },
+      property: {
+        type: String,
+        required: true
+      }
+    },
+    setup(props) {
+      return () => {
+        return formItem ? h(
+          formItem,
+          {
+            ...props.formItem
+          },
+          {
+            default: () => {
+              return generateVNode(props);
+            }
+          }
+        ) : generateVNode(props);
+      };
+    }
+  });
+  return defineComponent({
+    name: "CustomForm",
+    props: {
+      config: {
+        type: Object,
+        required: true
+      },
+      data: {
+        type: Object,
+        required: true
+      }
+    },
+    setup(props, ctx) {
+      const dom = ref2();
+      onMounted(() => {
+        ctx.expose({ ...dom.value });
+      });
+      return () => {
+        return h(form, Object.assign({ ref: dom }, ctx.attrs), {
+          default: () => Object.keys(props.config).map((item) => {
+            return h(FormItem, {
+              formItem: props.config[item]._formItem,
+              config: props.config,
+              property: item,
+              data: props.data
+            });
+          })
+        });
+      };
+    }
+  });
+}
+
+// src/components/formFilter.ts
+function createFormData(schema, initData = {}, options = {}) {
+  const { data, filter } = createFilter(initData, options);
+  initlize(schema, data.value);
+  const filterRet = filter(schema);
+  function initlize(obj1, obj2) {
+    for (const i in obj1) {
+      if (obj1[i]._default)
+        obj2[i] = obj1[i]._default;
+    }
+  }
+  return { config: filterRet, data };
+}
+
+// src/components/formResolve.ts
+import { getHandler as getHandler2, getModelState, validate } from "phecda-core";
+function getElementPlusRules(Model, options = {}) {
+  const stateVars = getModelState(Model);
+  const ret = {};
+  for (const item of stateVars) {
+    const handlers = getHandler2(Model, item);
+    if (handlers) {
+      for (const handler of handlers) {
+        const { rule, meta, info } = handler;
+        if (rule) {
+          if (!ret[item])
+            ret[item] = [];
+          ret[item].push({
+            validator: async (_, value, callback) => {
+              if (!await validate(rule, value))
+                callback(new Error(info || ""));
+              else
+                callback();
+            },
+            ...options,
+            ...meta || {}
+          });
+        }
+      }
+    }
+  }
+  return ret;
+}
+var GetDevUIRules = getElementPlusRules;
+function getNaiveUIRules(Model, options = {}) {
+  const stateVars = getModelState(Model);
+  const ret = {};
+  for (const item of stateVars) {
+    const handlers = getHandler2(Model, item);
+    if (handlers) {
+      for (const handler of handlers) {
+        const { rule, meta, info } = handler;
+        if (rule) {
+          if (!ret[item])
+            ret[item] = [];
+          ret[item].push({
+            validator: async (_, value) => {
+              if (!await validate(rule, value))
+                return Promise.reject(info);
+              else
+                return Promise.resolve();
+            },
+            ...options,
+            ...meta || {}
+          });
+        }
+      }
+    }
+  }
+  return ret;
+}
+var getAntDRules = getNaiveUIRules;
+function getNutUIRules(Model, options = {}) {
+  const stateVars = getModelState(Model);
+  const ret = {};
+  for (const item of stateVars) {
+    const handlers = getHandler2(Model, item);
+    if (handlers) {
+      for (const handler of handlers) {
+        const { rule, meta, info } = handler;
+        if (rule) {
+          if (!ret[item])
+            ret[item] = [];
+          ret[item].push({
+            validator: async (_, value) => {
+              if (!await validate(rule, value))
+                return false;
+              else
+                return true;
+            },
+            message: info,
+            ...options,
+            ...meta || {}
+          });
+        }
+      }
+    }
+  }
+  return ret;
+}
+var getVantRules = getNutUIRules;
+
+// src/components/createModal.ts
+import { defineComponent as defineComponent2, h as h2, ref as ref3, render, shallowRef } from "vue";
+var createModal = function(modalWrapper, modelKey = "modelValue") {
+  let isMounted = false;
+  const isShow = ref3(true);
+  const content = shallowRef();
+  const propsRef = ref3({});
+  const wrapper = defineComponent2({
+    setup() {
+      return () => h2(modalWrapper, {
+        [modelKey]: isShow.value,
+        [`onUpdate:${modelKey}`]: (v) => {
+          isShow.value = v;
+        }
+      }, {
+        default: () => content.value && h2(content.value, propsRef.value)
+      });
+    }
+  });
+  return (comp, props) => {
+    content.value = comp;
+    propsRef.value = props;
+    if (!isMounted) {
+      const el = document.createElement("div");
+      const vnode = h2(wrapper);
+      document.body.appendChild((render(vnode, el), el));
+      isMounted = true;
+    } else {
+      isShow.value = true;
+    }
+  };
+};
+
+// src/components/createTable.ts
+import { defineComponent as defineComponent3, h as h3, onMounted as onMounted2, ref as ref4 } from "vue";
+function createTable(compSet, table, tableColumn, data) {
+  const TableColumn = defineComponent3({
+    name: "PhecdaTableColumn",
+    props: {
+      tableColumn: {
+        type: Object,
+        required: true
+      }
+    },
+    setup(props) {
+      const compName = props.tableColumn._component;
+      return () => h3(
+        tableColumn,
+        {
+          ...props.tableColumn
+        },
+        {
+          default: (scope) => {
+            return compName ? h3(compSet[compName], { scope, data, ...props.tableColumn._props || {} }) : null;
+          }
+        }
+      );
+    }
+  });
+  return defineComponent3({
+    name: "PhecdaTable",
+    props: {
+      config: {
+        type: Array,
+        required: true
+      }
+    },
+    setup(props, ctx) {
+      const dom = ref4();
+      onMounted2(() => {
+        ctx.expose({ ...dom.value });
+      });
+      return () => {
+        return h3(table, Object.assign({ ref: dom }, ctx.attrs), {
+          default: () => props.config.map((item) => {
+            return h3(TableColumn, {
+              tableColumn: item
+            });
+          })
+        });
+      };
+    }
+  });
+}
+export {
+  EXPRESS_RE,
+  FN_RE,
+  GetDevUIRules,
+  P,
+  Watcher,
+  clearStorage,
+  createFilter,
+  createForm,
+  createFormData,
+  createModal,
+  createPhecda,
+  createTable,
+  deleteStorage,
+  emit,
+  emitter,
+  getActivePhecda,
+  getAntDRules,
+  getElementPlusRules,
+  getNaiveUIRules,
+  getNutUIRules,
+  getVantRules,
+  initalize,
+  phecdaSymbol,
+  setActivePhecda,
+  useO,
+  useOn,
+  usePatch,
+  useR,
+  useV
+};

package/package.json

@@ -0,0 +1,26 @@
+{
+  "name": "phecda-vue",
+  "version": "1.0.1",
+  "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",
+    "phecda-core": "1.0.1"
+  },
+  "devDependencies": {
+    "tsup": "^6.5.0"
+  },
+  "scripts": {
+    "build": "tsup",
+    "dev": "tsup --watch"
+  }
+}