@tachybase/schema 0.23.41 → 0.23.48

package/lib/path/destructor.js

@@ -0,0 +1,151 @@
+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 = (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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var destructor_exports = {};
+__export(destructor_exports, {
+  deleteInByDestructor: () => deleteInByDestructor,
+  existInByDestructor: () => existInByDestructor,
+  getDestructor: () => getDestructor,
+  getInByDestructor: () => getInByDestructor,
+  parseDestructorRules: () => parseDestructorRules,
+  setDestructor: () => setDestructor,
+  setInByDestructor: () => setInByDestructor
+});
+module.exports = __toCommonJS(destructor_exports);
+var import_shared = require("./shared");
+var import_types = require("./types");
+const DestructorCache = /* @__PURE__ */ new Map();
+const isValid = /* @__PURE__ */ __name((val) => val !== void 0 && val !== null, "isValid");
+const getDestructor = /* @__PURE__ */ __name((source) => {
+  return DestructorCache.get(source);
+}, "getDestructor");
+const setDestructor = /* @__PURE__ */ __name((source, rules) => {
+  DestructorCache.set(source, rules);
+}, "setDestructor");
+const parseDestructorRules = /* @__PURE__ */ __name((node) => {
+  const rules = [];
+  if ((0, import_types.isObjectPattern)(node)) {
+    let index = 0;
+    node.properties.forEach((child) => {
+      rules[index] = {
+        path: []
+      };
+      rules[index].key = child.key.value;
+      rules[index].path.push(child.key.value);
+      if ((0, import_types.isIdentifier)(child.value)) {
+        rules[index].key = child.value.value;
+      }
+      const basePath = rules[index].path;
+      const childRules = parseDestructorRules(child.value);
+      let k = index;
+      childRules.forEach((rule) => {
+        if (rules[k]) {
+          rules[k].key = rule.key;
+          rules[k].path = basePath.concat(rule.path);
+        } else {
+          rules[k] = {
+            key: rule.key,
+            path: basePath.concat(rule.path)
+          };
+        }
+        k++;
+      });
+      if (k > index) {
+        index = k;
+      } else {
+        index++;
+      }
+    });
+    return rules;
+  } else if ((0, import_types.isArrayPattern)(node)) {
+    let index = 0;
+    node.elements.forEach((child, key) => {
+      rules[index] = {
+        path: []
+      };
+      rules[index].key = key;
+      rules[index].path.push(key);
+      if ((0, import_types.isIdentifier)(child)) {
+        rules[index].key = child.value;
+      }
+      const basePath = rules[index].path;
+      const childRules = parseDestructorRules(child);
+      let k = index;
+      childRules.forEach((rule) => {
+        if (rules[k]) {
+          rules[k].key = rule.key;
+          rules[k].path = basePath.concat(rule.path);
+        } else {
+          rules[k] = {
+            key: rule.key,
+            path: basePath.concat(rule.path)
+          };
+        }
+        k++;
+      });
+      if (k > index) {
+        index = k;
+      } else {
+        index++;
+      }
+    });
+    return rules;
+  }
+  if ((0, import_types.isDestructorExpression)(node)) {
+    return parseDestructorRules(node.value);
+  }
+  return rules;
+}, "parseDestructorRules");
+const setInByDestructor = /* @__PURE__ */ __name((source, rules, value, mutators) => {
+  rules.forEach(({ key, path }) => {
+    mutators.setIn([key], source, mutators.getIn(path, value));
+  });
+}, "setInByDestructor");
+const getInByDestructor = /* @__PURE__ */ __name((source, rules, mutators) => {
+  let response = {};
+  if (rules.length) {
+    if ((0, import_shared.isNum)(rules[0].path[0])) {
+      response = [];
+    }
+  }
+  source = isValid(source) ? source : {};
+  rules.forEach(({ key, path }) => {
+    mutators.setIn(path, response, source[key]);
+  });
+  return response;
+}, "getInByDestructor");
+const deleteInByDestructor = /* @__PURE__ */ __name((source, rules, mutators) => {
+  rules.forEach(({ key }) => {
+    mutators.deleteIn([key], source);
+  });
+}, "deleteInByDestructor");
+const existInByDestructor = /* @__PURE__ */ __name((source, rules, start, mutators) => {
+  return rules.every(({ key }) => {
+    return mutators.existIn([key], source, start);
+  });
+}, "existInByDestructor");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  deleteInByDestructor,
+  existInByDestructor,
+  getDestructor,
+  getInByDestructor,
+  parseDestructorRules,
+  setDestructor,
+  setInByDestructor
+});

package/lib/path/index.d.ts

@@ -0,0 +1,51 @@
+import { Node, Pattern, Segments } from './types';
+declare const isMatcher: unique symbol;
+export declare class Path {
+    entire: string | RegExp;
+    segments: Segments;
+    isMatchPattern: boolean;
+    isWildMatchPattern: boolean;
+    isRegExp: boolean;
+    haveRelativePattern: boolean;
+    haveExcludePattern: boolean;
+    matchScore: number;
+    tree: Node;
+    private matchCache;
+    private includesCache;
+    constructor(input: Pattern, base?: Pattern);
+    toString(): string;
+    toArr(): (string | number)[];
+    get length(): number;
+    concat: (...args: Pattern[]) => Path;
+    slice: (start?: number, end?: number) => Path;
+    push: (...items: Pattern[]) => Path;
+    pop: () => Path;
+    splice: (start: number, deleteCount?: number, ...items: Array<string | number>) => Path;
+    forEach: (callback: (key: string | number) => any) => void;
+    map: (callback: (key: string | number) => any) => any[];
+    reduce: <T>(callback: (buf: T, item: string | number, index: number) => T, initial: T) => T;
+    parent: () => Path;
+    includes: (pattern: Pattern) => any;
+    transform: <T>(regexp: string | RegExp, callback: (...args: string[]) => T) => T | string;
+    match: (pattern: Pattern) => boolean;
+    matchAliasGroup: (name: Pattern, alias: Pattern) => boolean;
+    existIn: (source?: any, start?: number | Path) => any;
+    getIn: (source?: any) => any;
+    setIn: (source?: any, value?: any) => any;
+    deleteIn: (source?: any) => any;
+    ensureIn: (source?: any, defaults?: any) => any;
+    static match(pattern: Pattern): {
+        (target: any): boolean;
+        path: Path;
+        [isMatcher]: boolean;
+    };
+    static isPathPattern(target: any): target is Pattern;
+    static transform<T>(pattern: Pattern, regexp: string | RegExp, callback: (...args: string[]) => T): any;
+    static parse(path?: Pattern, base?: Pattern): Path;
+    static getIn: (source: any, pattern: Pattern) => any;
+    static setIn: (source: any, pattern: Pattern, value: any) => any;
+    static deleteIn: (source: any, pattern: Pattern) => any;
+    static existIn: (source: any, pattern: Pattern, start?: number | Path) => any;
+    static ensureIn: (source: any, pattern: Pattern, defaultValue?: any) => any;
+}
+export { type Pattern };