phecda-core 1.1.1 → 1.2.1

package/README.md

@@ -0,0 +1,3 @@
+# phecda-core
+provide base function and abstract limit to other phecda module
+

package/dist/index.d.ts

@@ -79,7 +79,6 @@ declare function Err<Fn extends (...args: any) => any>(cb: Fn): (target: any, ke
 declare function P(target: any, key: PropertyKey): void;
 declare function Pipe(v: ReturnType<typeof to>): (obj: any, key: PropertyKey) => void;
 declare function Tag(tag: string): (target: any) => void;
-declare function Storage(target: any): void;
 declare function Global(target: any): void;
 
 declare function validate(p: RegExp | string | Function | Object | Number, v: any): Promise<any>;
@@ -103,25 +102,6 @@ declare function getState(target: Phecda, key: PropertyKey): Object | undefined;
 declare function register(instance: Phecda): void;
 declare function registerAsync(instance: Phecda): Promise<void>;
 
-declare function isArray(info?: string): (obj: any, key: PropertyKey) => void;
-declare function isBoolean(info?: string): (obj: any, key: PropertyKey) => void;
-declare function isNumber(info?: string): (obj: any, key: PropertyKey) => void;
-declare function isString(info?: string): (obj: any, key: PropertyKey) => void;
-declare function isObject(info?: string): (obj: any, key: PropertyKey) => void;
-declare function isMobile(info?: string): (obj: any, key: PropertyKey) => void;
-declare function isLandline(info?: string): (obj: any, key: PropertyKey) => void;
-declare function isMailBox(info?: string): (obj: any, key: PropertyKey) => void;
-declare function isIdCard(info?: string): (obj: any, key: PropertyKey) => void;
-declare function isCnName(info?: string): (obj: any, key: PropertyKey) => void;
-declare function isEnName(info?: string): (obj: any, key: PropertyKey) => void;
-declare function isDate(info?: string): (obj: any, key: PropertyKey) => void;
-declare function isWechat(info?: string): (obj: any, key: PropertyKey) => void;
-declare function isHexColor(info?: string): (obj: any, key: PropertyKey) => void;
-declare function isPostalCode(info?: string): (obj: any, key: PropertyKey) => void;
-
-declare function toNumber(): (obj: any, key: PropertyKey) => void;
-declare function toString(): (obj: any, key: PropertyKey) => void;
-
 declare const activeInstance: Record<string, any>;
 declare function injectProperty(key: string, value: any): Record<string, any>;
 declare function getProperty(key: string): any;
@@ -129,5 +109,6 @@ declare function getProperty(key: string): any;
 declare function Watcher(eventName: keyof PhecdaEvents, options?: {
     once: boolean;
 }): (obj: any, key: string) => void;
+declare function Storage(storeKey?: string): (target: any, key?: PropertyKey) => void;
 
-export { ClassValue, Clear, Err, Global, Ignore, Init, P, Phecda, PhecdaEvents, PhecdaHandler, PhecdaNameSpace, Pipe, Rule, Storage, Tag, UsePipeOptions, Watcher, activeInstance, addDecoToClass, classToValue, getExposeKey, getHandler, getIgnoreKey, getInitEvent, getModelState, getProperty, getState, getTag, init, injectProperty, isArray, isBoolean, isCnName, isDate, isEnName, isHexColor, isIdCard, isLandline, isMailBox, isMobile, isNumber, isObject, isPhecda, isPostalCode, isString, isWechat, mergeOptions, mergeState, plainToClass, regisHandler, regisInitEvent, register, registerAsync, setExposeKey, setIgnoreKey, setModalVar, snapShot, to, toNumber, toString, validate };
+export { ClassValue, Clear, Err, Global, Ignore, Init, P, Phecda, PhecdaEvents, PhecdaHandler, PhecdaNameSpace, Pipe, Rule, Storage, Tag, UsePipeOptions, Watcher, activeInstance, addDecoToClass, classToValue, getExposeKey, getHandler, getIgnoreKey, getInitEvent, getModelState, getProperty, getState, getTag, init, injectProperty, isPhecda, mergeOptions, mergeState, plainToClass, regisHandler, regisInitEvent, register, registerAsync, setExposeKey, setIgnoreKey, setModalVar, snapShot, to, validate };

package/dist/index.global.js

@@ -0,0 +1,436 @@
+"use strict";
+var Phecda = (() => {
+  var __defProp = Object.defineProperty;
+  var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+  var __getOwnPropNames = Object.getOwnPropertyNames;
+  var __hasOwnProp = Object.prototype.hasOwnProperty;
+  var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+  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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+  // src/index.ts
+  var src_exports = {};
+  __export(src_exports, {
+    Clear: () => Clear,
+    Err: () => Err,
+    Global: () => Global,
+    Ignore: () => Ignore,
+    Init: () => Init,
+    P: () => P,
+    Pipe: () => Pipe,
+    Rule: () => Rule,
+    Storage: () => Storage,
+    Tag: () => Tag,
+    Watcher: () => Watcher,
+    activeInstance: () => activeInstance,
+    addDecoToClass: () => addDecoToClass,
+    classToValue: () => classToValue,
+    getExposeKey: () => getExposeKey,
+    getHandler: () => getHandler,
+    getIgnoreKey: () => getIgnoreKey,
+    getInitEvent: () => getInitEvent,
+    getModelState: () => getModelState,
+    getProperty: () => getProperty,
+    getState: () => getState,
+    getTag: () => getTag,
+    init: () => init,
+    injectProperty: () => injectProperty,
+    isPhecda: () => isPhecda,
+    mergeOptions: () => mergeOptions,
+    mergeState: () => mergeState,
+    plainToClass: () => plainToClass,
+    regisHandler: () => regisHandler,
+    regisInitEvent: () => regisInitEvent,
+    register: () => register,
+    registerAsync: () => registerAsync,
+    setExposeKey: () => setExposeKey,
+    setIgnoreKey: () => setIgnoreKey,
+    setModalVar: () => setModalVar,
+    snapShot: () => snapShot,
+    to: () => to,
+    validate: () => validate
+  });
+
+  // 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;
+  }
+  __name(validate, "validate");
+  function getTag(Model) {
+    return Model.prototype?._namespace?.__TAG__;
+  }
+  __name(getTag, "getTag");
+  function mergeOptions(obj1, obj2) {
+    if (!obj2)
+      return obj1;
+    for (const i in obj2) {
+      if (isObject(obj1[i]) && isObject(obj2[i])) {
+        mergeOptions(obj1[i], obj2[i]);
+        continue;
+      }
+      if (Array.isArray(obj1[i]) && Array.isArray(obj2[i])) {
+        obj1[i].push(...obj2[i].filter((item) => !obj1[i].includes(item)));
+        continue;
+      }
+      obj1[i] = obj2[i];
+    }
+    return obj1;
+  }
+  __name(mergeOptions, "mergeOptions");
+  function isObject(obj) {
+    return Object.prototype.toString.call(obj) === "[object Object]";
+  }
+  __name(isObject, "isObject");
+
+  // src/core.ts
+  function isPhecda(target) {
+    return target && !!target.prototype._namespace;
+  }
+  __name(isPhecda, "isPhecda");
+  function init(target) {
+    if (!target._namespace) {
+      target._namespace = {
+        __TAG__: "",
+        __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(),
+        __STATE_NAMESPACE__: /* @__PURE__ */ new Map()
+      };
+    }
+  }
+  __name(init, "init");
+  function regisInitEvent(target, key) {
+    init(target);
+    target._namespace.__INIT_EVENT__.add(key);
+  }
+  __name(regisInitEvent, "regisInitEvent");
+  function getInitEvent(target) {
+    init(target);
+    return [
+      ...target._namespace.__INIT_EVENT__
+    ];
+  }
+  __name(getInitEvent, "getInitEvent");
+  function setModalVar(target, key) {
+    init(target);
+    target._namespace.__STATE_VAR__.add(key);
+    setExposeKey(target, key);
+  }
+  __name(setModalVar, "setModalVar");
+  function setExposeKey(target, key) {
+    init(target);
+    target._namespace.__EXPOSE_VAR__.add(key);
+  }
+  __name(setExposeKey, "setExposeKey");
+  function setIgnoreKey(target, key) {
+    init(target);
+    target._namespace.__IGNORE_VAR__.add(key);
+  }
+  __name(setIgnoreKey, "setIgnoreKey");
+  function getModelState(target) {
+    init(target);
+    return [
+      ...target._namespace.__STATE_VAR__
+    ];
+  }
+  __name(getModelState, "getModelState");
+  function getExposeKey(target) {
+    init(target);
+    return [
+      ...target._namespace.__EXPOSE_VAR__
+    ].filter((item) => !target._namespace.__IGNORE_VAR__.has(item));
+  }
+  __name(getExposeKey, "getExposeKey");
+  function getIgnoreKey(target) {
+    init(target);
+    return [
+      ...target._namespace.__IGNORE_VAR__
+    ];
+  }
+  __name(getIgnoreKey, "getIgnoreKey");
+  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);
+  }
+  __name(regisHandler, "regisHandler");
+  function getHandler(target, key) {
+    return target._namespace.__STATE_HANDLER__.get(key) || [];
+  }
+  __name(getHandler, "getHandler");
+  function mergeState(target, key, state) {
+    const namespace = target._namespace.__STATE_NAMESPACE__;
+    if (!namespace.has(key))
+      namespace.set(key, state);
+    else
+      mergeOptions(namespace.get(key), state);
+  }
+  __name(mergeState, "mergeState");
+  function getState(target, key) {
+    const namespace = target._namespace.__STATE_NAMESPACE__;
+    if (namespace)
+      return namespace.get(key);
+  }
+  __name(getState, "getState");
+  function register(instance) {
+    const stateVars = getExposeKey(instance);
+    for (const item of stateVars) {
+      const handlers = getHandler(instance, item);
+      for (const hanlder of handlers)
+        hanlder.init?.(instance);
+    }
+  }
+  __name(register, "register");
+  async function registerAsync(instance) {
+    const stateVars = getExposeKey(instance);
+    for (const item of stateVars) {
+      const handlers = getHandler(instance, item);
+      for (const hanlder of handlers)
+        await hanlder.init?.(instance);
+    }
+  }
+  __name(registerAsync, "registerAsync");
+
+  // src/decorators.ts
+  function Init(target, key) {
+    setModalVar(target, key);
+    regisHandler(target, key, {
+      async init(instance) {
+        instance[key]();
+      }
+    });
+  }
+  __name(Init, "Init");
+  function Rule(rule, info, meta) {
+    return (obj, key) => {
+      setModalVar(obj, key);
+      regisHandler(obj, key, {
+        rule,
+        info,
+        meta
+      });
+    };
+  }
+  __name(Rule, "Rule");
+  function Ignore(target, key) {
+    setIgnoreKey(target, key);
+  }
+  __name(Ignore, "Ignore");
+  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);
+    target._namespace.__STATE_NAMESPACE__.delete(key);
+  }
+  __name(Clear, "Clear");
+  function Err(cb) {
+    return (target, key) => {
+      setModalVar(target, key);
+      regisHandler(target, key, {
+        error: cb
+      });
+    };
+  }
+  __name(Err, "Err");
+  function P(target, key) {
+    setExposeKey(target, key);
+  }
+  __name(P, "P");
+  function Pipe(v) {
+    return (obj, key) => {
+      setModalVar(obj, key);
+      regisHandler(obj, key, {
+        async pipe(instance) {
+          const tasks = v.value;
+          for (const task of tasks)
+            instance[key] = await task(instance[key]);
+        }
+      });
+    };
+  }
+  __name(Pipe, "Pipe");
+  function Tag(tag) {
+    return (target) => {
+      init(target.prototype);
+      target.prototype._namespace.__TAG__ = tag;
+    };
+  }
+  __name(Tag, "Tag");
+  function Global(target) {
+    if (!globalThis.__PHECDA__)
+      globalThis.__PHECDA__ = {};
+    const tag = target.prototype._namespace.__TAG__;
+    if (tag)
+      globalThis.__PHECDA__[tag] = target;
+  }
+  __name(Global, "Global");
+
+  // src/helper.ts
+  async function plainToClass(Model, input, options = {}) {
+    const data = new Model();
+    const err = [];
+    const stateVars = getModelState(data);
+    for (const item of stateVars) {
+      data[item] = input[item];
+      const handlers = getHandler(data, item);
+      if (handlers) {
+        if (options.collectError !== false) {
+          for (const handler of handlers) {
+            const rule = handler.rule;
+            if (rule && !await validate(rule, data[item])) {
+              err.push(handler.info || "");
+              if (!options.collectError)
+                break;
+            }
+          }
+        }
+        if (err.length > 0 && !options.transform)
+          return {
+            err,
+            data
+          };
+        if (options.transform !== false) {
+          for (const handler of handlers)
+            await handler.pipe?.(data);
+        }
+      }
+    }
+    return {
+      data,
+      err
+    };
+  }
+  __name(plainToClass, "plainToClass");
+  function classToValue(instance) {
+    const data = {};
+    const exposeVar = getExposeKey(instance);
+    for (const item of exposeVar)
+      data[item] = instance[item];
+    return data;
+  }
+  __name(classToValue, "classToValue");
+  function to(task, oldTasks) {
+    const tasks = oldTasks || [];
+    tasks.push(task);
+    return {
+      to: (task2) => to(task2, tasks),
+      value: tasks
+    };
+  }
+  __name(to, "to");
+  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];
+      }
+    };
+  }
+  __name(snapShot, "snapShot");
+  function addDecoToClass(c, key, handler, type = "normal") {
+    handler(type === "normal" ? c.prototype : c, key);
+  }
+  __name(addDecoToClass, "addDecoToClass");
+
+  // src/namespace.ts
+  var activeInstance = {};
+  function injectProperty(key, value) {
+    activeInstance[key] = value;
+    return activeInstance;
+  }
+  __name(injectProperty, "injectProperty");
+  function getProperty(key) {
+    return activeInstance[key];
+  }
+  __name(getProperty, "getProperty");
+
+  // src/custom/decorator.ts
+  function Watcher(eventName, options) {
+    return (obj, key) => {
+      setModalVar(obj, key);
+      regisHandler(obj, key, {
+        init(instance) {
+          getProperty("watcher")?.({
+            eventName,
+            instance,
+            key,
+            options
+          });
+        }
+      });
+    };
+  }
+  __name(Watcher, "Watcher");
+  function Storage(storeKey) {
+    return (target, key) => {
+      let tag;
+      if (key) {
+        init(target);
+        tag = storeKey || target._namespace.__TAG__;
+        const uniTag = Symbol(tag);
+        setModalVar(target, uniTag);
+        regisHandler(target, uniTag, {
+          init: (instance) => {
+            getProperty("storage")?.({
+              instance,
+              key,
+              tag
+            });
+          }
+        });
+      } else {
+        init(target.prototype);
+        tag = storeKey || `${target.prototype._namespace.__TAG__}_${key}`;
+        const uniTag = Symbol(tag);
+        setModalVar(target.prototype, uniTag);
+        regisHandler(target.prototype, uniTag, {
+          init: (instance) => {
+            getProperty("storage")?.({
+              instance,
+              key: "",
+              tag
+            });
+          }
+        });
+      }
+    };
+  }
+  __name(Storage, "Storage");
+  return __toCommonJS(src_exports);
+})();

package/dist/index.js

@@ -45,22 +45,7 @@ __export(src_exports, {
   getTag: () => getTag,
   init: () => init,
   injectProperty: () => injectProperty,
-  isArray: () => isArray,
-  isBoolean: () => isBoolean,
-  isCnName: () => isCnName,
-  isDate: () => isDate,
-  isEnName: () => isEnName,
-  isHexColor: () => isHexColor,
-  isIdCard: () => isIdCard,
-  isLandline: () => isLandline,
-  isMailBox: () => isMailBox,
-  isMobile: () => isMobile,
-  isNumber: () => isNumber,
-  isObject: () => isObject2,
   isPhecda: () => isPhecda,
-  isPostalCode: () => isPostalCode,
-  isString: () => isString,
-  isWechat: () => isWechat,
   mergeOptions: () => mergeOptions,
   mergeState: () => mergeState,
   plainToClass: () => plainToClass,
@@ -73,8 +58,6 @@ __export(src_exports, {
   setModalVar: () => setModalVar,
   snapShot: () => snapShot,
   to: () => to,
-  toNumber: () => toNumber,
-  toString: () => toString,
   validate: () => validate
 });
 module.exports = __toCommonJS(src_exports);
@@ -301,29 +284,6 @@ function Tag(tag) {
   };
 }
 __name(Tag, "Tag");
-function Storage(target) {
-  init(target.prototype);
-  const tag = target.prototype._namespace.__TAG__;
-  if (tag === "")
-    throw new Error("miss tag");
-  const uniTag = Symbol(tag);
-  setModalVar(target.prototype, uniTag);
-  regisHandler(target.prototype, uniTag, {
-    init: (instance) => {
-      const { state } = instance;
-      globalThis.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];
-      }
-    }
-  });
-}
-__name(Storage, "Storage");
 function Global(target) {
   if (!globalThis.__PHECDA__)
     globalThis.__PHECDA__ = {};
@@ -408,83 +368,6 @@ function addDecoToClass(c, key, handler, type = "normal") {
 }
 __name(addDecoToClass, "addDecoToClass");
 
-// src/preset/rule.ts
-function isArray(info) {
-  return Rule((param) => Array.isArray(param), info || "it should be an array");
-}
-__name(isArray, "isArray");
-function isBoolean(info) {
-  return Rule((param) => [
-    true,
-    false
-  ].includes(param), info || "it should be true or false");
-}
-__name(isBoolean, "isBoolean");
-function isNumber(info) {
-  return Rule((param) => typeof param === "number", info || "it should be true or false");
-}
-__name(isNumber, "isNumber");
-function isString(info) {
-  return Rule((param) => typeof param === "string", info || "it should be a string");
-}
-__name(isString, "isString");
-function isObject2(info) {
-  return Rule((param) => {
-    return Object.prototype.toString.call(param) === "[object Object]";
-  }, info || "it should be an object");
-}
-__name(isObject2, "isObject");
-function isMobile(info) {
-  return Rule(/^((\+|00)86)?1((3[\d])|(4[5,6,7,9])|(5[0-3,5-9])|(6[5-7])|(7[0-8])|(8[\d])|(9[1,8,9]))\d{8}$/, info || "it should be a mobile phone number");
-}
-__name(isMobile, "isMobile");
-function isLandline(info) {
-  return Rule(/\d{3}-\d{8}|\d{4}-\d{7}/, info || "it should be a mobile phone number");
-}
-__name(isLandline, "isLandline");
-function isMailBox(info) {
-  return Rule(/^[a-zA-Z0-9.!#$%&'*+\/=?^_`{|}~-]+@[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?(?:\.[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?)*$/, info || "it should be a mailbox  number");
-}
-__name(isMailBox, "isMailBox");
-function isIdCard(info) {
-  return Rule(/(^\d{8}(0\d|10|11|12)([0-2]\d|30|31)\d{3}$)|(^\d{6}(18|19|20)\d{2}(0\d|10|11|12)([0-2]\d|30|31)\d{3}(\d|X|x)$)/, info || "it should be an identity card number");
-}
-__name(isIdCard, "isIdCard");
-function isCnName(info) {
-  return Rule(/^([\u4E00-\u9FA5·]{2,16})$/, info || "\u9700\u8981\u662F\u4E00\u4E2A\u5408\u7406\u7684\u4E2D\u6587\u540D\u5B57");
-}
-__name(isCnName, "isCnName");
-function isEnName(info) {
-  return Rule(/(^[a-zA-Z]{1}[a-zA-Z\s]{0,20}[a-zA-Z]{1}$)/, info || "it should be a valid en-name");
-}
-__name(isEnName, "isEnName");
-function isDate(info) {
-  return Rule(/^(?:(?!0000)[0-9]{4}-(?:(?:0[1-9]|1[0-2])-(?:0[1-9]|1[0-9]|2[0-8])|(?:0[13-9]|1[0-2])-(?:29|30)|(?:0[13578]|1[02])-31)|(?:[0-9]{2}(?:0[48]|[2468][048]|[13579][26])|(?:0[48]|[2468][048]|[13579][26])00)-02-29)$/, info || "it should be a valid date");
-}
-__name(isDate, "isDate");
-function isWechat(info) {
-  return Rule(/^[a-zA-Z]([-_a-zA-Z0-9]{5,19})+$/, info || "it should be a valid date");
-}
-__name(isWechat, "isWechat");
-function isHexColor(info) {
-  return Rule(/^#?([a-fA-F0-9]{6}|[a-fA-F0-9]{3})$/, info || "it should be a valid hex-color");
-}
-__name(isHexColor, "isHexColor");
-function isPostalCode(info) {
-  return Rule(/^(0[1-7]|1[0-356]|2[0-7]|3[0-6]|4[0-7]|5[1-7]|6[1-7]|7[0-5]|8[013-6])\d{4}$/, info || "it should be a valid postal code");
-}
-__name(isPostalCode, "isPostalCode");
-
-// src/preset/pipe.ts
-function toNumber() {
-  return Pipe(to((param) => Number(param)));
-}
-__name(toNumber, "toNumber");
-function toString() {
-  return Pipe(to((param) => String(param)));
-}
-__name(toString, "toString");
-
 // src/namespace.ts
 var activeInstance = {};
 function injectProperty(key, value) {
@@ -514,6 +397,41 @@ function Watcher(eventName, options) {
   };
 }
 __name(Watcher, "Watcher");
+function Storage(storeKey) {
+  return (target, key) => {
+    let tag;
+    if (key) {
+      init(target);
+      tag = storeKey || target._namespace.__TAG__;
+      const uniTag = Symbol(tag);
+      setModalVar(target, uniTag);
+      regisHandler(target, uniTag, {
+        init: (instance) => {
+          getProperty("storage")?.({
+            instance,
+            key,
+            tag
+          });
+        }
+      });
+    } else {
+      init(target.prototype);
+      tag = storeKey || `${target.prototype._namespace.__TAG__}_${key}`;
+      const uniTag = Symbol(tag);
+      setModalVar(target.prototype, uniTag);
+      regisHandler(target.prototype, uniTag, {
+        init: (instance) => {
+          getProperty("storage")?.({
+            instance,
+            key: "",
+            tag
+          });
+        }
+      });
+    }
+  };
+}
+__name(Storage, "Storage");
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   Clear,
@@ -540,22 +458,7 @@ __name(Watcher, "Watcher");
   getTag,
   init,
   injectProperty,
-  isArray,
-  isBoolean,
-  isCnName,
-  isDate,
-  isEnName,
-  isHexColor,
-  isIdCard,
-  isLandline,
-  isMailBox,
-  isMobile,
-  isNumber,
-  isObject,
   isPhecda,
-  isPostalCode,
-  isString,
-  isWechat,
   mergeOptions,
   mergeState,
   plainToClass,
@@ -568,7 +471,5 @@ __name(Watcher, "Watcher");
   setModalVar,
   snapShot,
   to,
-  toNumber,
-  toString,
   validate
 });