@tachybase/schema 0.23.41 → 0.23.47

package/lib/path/index.js

@@ -0,0 +1,513 @@
+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 path_exports = {};
+__export(path_exports, {
+  Path: () => Path
+});
+module.exports = __toCommonJS(path_exports);
+var import_destructor = require("./destructor");
+var import_matcher = require("./matcher");
+var import_parser = require("./parser");
+var import_shared = require("./shared");
+const pathCache = /* @__PURE__ */ new Map();
+const isMatcher = Symbol("PATH_MATCHER");
+const isValid = /* @__PURE__ */ __name((val) => val !== void 0 && val !== null, "isValid");
+const isSimplePath = /* @__PURE__ */ __name((val) => val.indexOf("*") === -1 && val.indexOf("~") === -1 && val.indexOf("[") === -1 && val.indexOf("]") === -1 && val.indexOf(",") === -1 && val.indexOf(":") === -1 && val.indexOf(" ") === -1 && val[0] !== ".", "isSimplePath");
+const isAssignable = /* @__PURE__ */ __name((val) => typeof val === "object" || typeof val === "function", "isAssignable");
+const isNumberIndex = /* @__PURE__ */ __name((val) => (0, import_shared.isStr)(val) ? /^\d+$/.test(val) : (0, import_shared.isNum)(val), "isNumberIndex");
+const getIn = /* @__PURE__ */ __name((segments, source) => {
+  for (let i = 0; i < segments.length; i++) {
+    const index = segments[i];
+    const rules = (0, import_destructor.getDestructor)(index);
+    if (!rules) {
+      if (!isValid(source)) return;
+      source = source[index];
+    } else {
+      source = (0, import_destructor.getInByDestructor)(source, rules, { setIn, getIn });
+      break;
+    }
+  }
+  return source;
+}, "getIn");
+const setIn = /* @__PURE__ */ __name((segments, source, value) => {
+  for (let i = 0; i < segments.length; i++) {
+    const index = segments[i];
+    const rules = (0, import_destructor.getDestructor)(index);
+    if (!rules) {
+      if (!isValid(source) || !isAssignable(source)) return;
+      if ((0, import_shared.isArr)(source) && !isNumberIndex(index)) {
+        return;
+      }
+      if (!isValid(source[index])) {
+        if (value === void 0) {
+          if (source[index] === null) source[index] = value;
+          return;
+        }
+        if (i < segments.length - 1) {
+          source[index] = (0, import_shared.isNum)(segments[i + 1]) ? [] : {};
+        }
+      }
+      if (i === segments.length - 1) {
+        source[index] = value;
+      }
+      source = source[index];
+    } else {
+      (0, import_destructor.setInByDestructor)(source, rules, value, { setIn, getIn });
+      break;
+    }
+  }
+}, "setIn");
+const deleteIn = /* @__PURE__ */ __name((segments, source) => {
+  for (let i = 0; i < segments.length; i++) {
+    const index = segments[i];
+    const rules = (0, import_destructor.getDestructor)(index);
+    if (!rules) {
+      if (i === segments.length - 1 && isValid(source)) {
+        delete source[index];
+        return;
+      }
+      if (!isValid(source) || !isAssignable(source)) return;
+      source = source[index];
+      if (!(0, import_shared.isObj)(source)) {
+        return;
+      }
+    } else {
+      (0, import_destructor.deleteInByDestructor)(source, rules, {
+        setIn,
+        getIn,
+        deleteIn
+      });
+      break;
+    }
+  }
+}, "deleteIn");
+const hasOwnProperty = Object.prototype.hasOwnProperty;
+const existIn = /* @__PURE__ */ __name((segments, source, start) => {
+  if (start instanceof Path) {
+    start = start.length;
+  }
+  for (let i = start; i < segments.length; i++) {
+    const index = segments[i];
+    const rules = (0, import_destructor.getDestructor)(index);
+    if (!rules) {
+      if (i === segments.length - 1) {
+        return hasOwnProperty.call(source, index);
+      }
+      if (!isValid(source) || !isAssignable(source)) return false;
+      source = source[index];
+      if (!(0, import_shared.isObj)(source)) {
+        return false;
+      }
+    } else {
+      return (0, import_destructor.existInByDestructor)(source, rules, start, {
+        setIn,
+        getIn,
+        deleteIn,
+        existIn
+      });
+    }
+  }
+}, "existIn");
+const parse = /* @__PURE__ */ __name((pattern, base) => {
+  if (pattern instanceof Path) {
+    return {
+      entire: pattern.entire,
+      segments: pattern.segments.slice(),
+      isRegExp: false,
+      haveRelativePattern: pattern.haveRelativePattern,
+      isWildMatchPattern: pattern.isWildMatchPattern,
+      isMatchPattern: pattern.isMatchPattern,
+      haveExcludePattern: pattern.haveExcludePattern,
+      tree: pattern.tree
+    };
+  } else if ((0, import_shared.isStr)(pattern)) {
+    if (!pattern) {
+      return {
+        entire: "",
+        segments: [],
+        isRegExp: false,
+        isWildMatchPattern: false,
+        haveExcludePattern: false,
+        isMatchPattern: false
+      };
+    }
+    if (isSimplePath(pattern)) {
+      return {
+        entire: pattern,
+        segments: pattern.split("."),
+        isRegExp: false,
+        isWildMatchPattern: false,
+        haveExcludePattern: false,
+        isMatchPattern: false
+      };
+    }
+    const parser = new import_parser.Parser(pattern, Path.parse(base));
+    const tree = parser.parse();
+    if (!parser.isMatchPattern) {
+      const segments = parser.data.segments;
+      return {
+        entire: segments.join("."),
+        segments,
+        tree,
+        isRegExp: false,
+        haveRelativePattern: parser.haveRelativePattern,
+        isWildMatchPattern: false,
+        haveExcludePattern: false,
+        isMatchPattern: false
+      };
+    } else {
+      return {
+        entire: pattern,
+        segments: [],
+        isRegExp: false,
+        haveRelativePattern: false,
+        isWildMatchPattern: parser.isWildMatchPattern,
+        haveExcludePattern: parser.haveExcludePattern,
+        isMatchPattern: true,
+        tree
+      };
+    }
+  } else if ((0, import_shared.isFn)(pattern) && pattern[isMatcher]) {
+    return parse(pattern["path"]);
+  } else if ((0, import_shared.isArr)(pattern)) {
+    return {
+      entire: pattern.join("."),
+      segments: pattern.reduce((buf, key) => {
+        return buf.concat(parseString(key));
+      }, []),
+      isRegExp: false,
+      haveRelativePattern: false,
+      isWildMatchPattern: false,
+      haveExcludePattern: false,
+      isMatchPattern: false
+    };
+  } else if ((0, import_shared.isRegExp)(pattern)) {
+    return {
+      entire: pattern,
+      segments: [],
+      isRegExp: true,
+      haveRelativePattern: false,
+      isWildMatchPattern: false,
+      haveExcludePattern: false,
+      isMatchPattern: true
+    };
+  } else {
+    return {
+      entire: "",
+      isRegExp: false,
+      segments: pattern !== void 0 ? [pattern] : [],
+      haveRelativePattern: false,
+      isWildMatchPattern: false,
+      haveExcludePattern: false,
+      isMatchPattern: false
+    };
+  }
+}, "parse");
+const parseString = /* @__PURE__ */ __name((source) => {
+  if ((0, import_shared.isStr)(source)) {
+    source = source.replace(/\s*/g, "");
+    try {
+      const { segments, isMatchPattern } = parse(source);
+      return !isMatchPattern ? segments : source;
+    } catch (e) {
+      return source;
+    }
+  } else if (source instanceof Path) {
+    return source.segments;
+  }
+  return source;
+}, "parseString");
+const _Path = class _Path {
+  constructor(input, base) {
+    this.concat = /* @__PURE__ */ __name((...args) => {
+      if (this.isMatchPattern || this.isRegExp) {
+        throw new Error(`${this.entire} cannot be concat`);
+      }
+      const path = new _Path("");
+      path.segments = this.segments.concat(...args.map((s) => parseString(s)));
+      path.entire = path.segments.join(".");
+      return path;
+    }, "concat");
+    this.slice = /* @__PURE__ */ __name((start, end) => {
+      if (this.isMatchPattern || this.isRegExp) {
+        throw new Error(`${this.entire} cannot be slice`);
+      }
+      const path = new _Path("");
+      path.segments = this.segments.slice(start, end);
+      path.entire = path.segments.join(".");
+      return path;
+    }, "slice");
+    this.push = /* @__PURE__ */ __name((...items) => {
+      return this.concat(...items);
+    }, "push");
+    this.pop = /* @__PURE__ */ __name(() => {
+      if (this.isMatchPattern || this.isRegExp) {
+        throw new Error(`${this.entire} cannot be pop`);
+      }
+      return new _Path(this.segments.slice(0, this.segments.length - 1));
+    }, "pop");
+    this.splice = /* @__PURE__ */ __name((start, deleteCount, ...items) => {
+      if (this.isMatchPattern || this.isRegExp) {
+        throw new Error(`${this.entire} cannot be splice`);
+      }
+      items = items.reduce((buf, item) => buf.concat(parseString(item)), []);
+      const segments_ = this.segments.slice();
+      segments_.splice(start, deleteCount, ...items);
+      return new _Path(segments_);
+    }, "splice");
+    this.forEach = /* @__PURE__ */ __name((callback) => {
+      if (this.isMatchPattern || this.isRegExp) {
+        throw new Error(`${this.entire} cannot be each`);
+      }
+      this.segments.forEach(callback);
+    }, "forEach");
+    this.map = /* @__PURE__ */ __name((callback) => {
+      if (this.isMatchPattern || this.isRegExp) {
+        throw new Error(`${this.entire} cannot be map`);
+      }
+      return this.segments.map(callback);
+    }, "map");
+    this.reduce = /* @__PURE__ */ __name((callback, initial) => {
+      if (this.isMatchPattern || this.isRegExp) {
+        throw new Error(`${this.entire} cannot be reduce`);
+      }
+      return this.segments.reduce(callback, initial);
+    }, "reduce");
+    this.parent = /* @__PURE__ */ __name(() => {
+      return this.slice(0, this.length - 1);
+    }, "parent");
+    this.includes = /* @__PURE__ */ __name((pattern) => {
+      const { entire, segments, isMatchPattern } = _Path.parse(pattern);
+      const cache = this.includesCache.get(entire);
+      if (cache !== void 0) return cache;
+      const cacheWith = /* @__PURE__ */ __name((value) => {
+        this.includesCache.set(entire, value);
+        return value;
+      }, "cacheWith");
+      if (this.isMatchPattern) {
+        if (!isMatchPattern) {
+          return cacheWith(this.match(segments));
+        } else {
+          throw new Error(`${this.entire} cannot be used to match ${entire}`);
+        }
+      }
+      if (isMatchPattern) {
+        throw new Error(`${this.entire} cannot be used to match ${entire}`);
+      }
+      if (segments.length > this.segments.length) return cacheWith(false);
+      for (let i = 0; i < segments.length; i++) {
+        if (!(0, import_shared.isEqual)(String(segments[i]), String(this.segments[i]))) {
+          return cacheWith(false);
+        }
+      }
+      return cacheWith(true);
+    }, "includes");
+    this.transform = /* @__PURE__ */ __name((regexp, callback) => {
+      if (!(0, import_shared.isFn)(callback)) return "";
+      if (this.isMatchPattern) {
+        throw new Error(`${this.entire} cannot be transformed`);
+      }
+      const reg = new RegExp(regexp);
+      const args = this.segments.filter((key) => reg.test(key));
+      return callback(...args);
+    }, "transform");
+    this.match = /* @__PURE__ */ __name((pattern) => {
+      var _a, _b;
+      const path = _Path.parse(pattern);
+      const cache = this.matchCache.get(path.entire);
+      if (cache !== void 0) {
+        if (cache.record && cache.record.score !== void 0) {
+          this.matchScore = cache.record.score;
+        }
+        return cache.matched;
+      }
+      const cacheWith = /* @__PURE__ */ __name((value) => {
+        this.matchCache.set(path.entire, value);
+        return value;
+      }, "cacheWith");
+      if (path.isMatchPattern) {
+        if (this.isMatchPattern) {
+          throw new Error(`${path.entire} cannot match ${this.entire}`);
+        } else {
+          this.matchScore = 0;
+          return cacheWith(path.match(this.segments));
+        }
+      } else {
+        if (this.isMatchPattern) {
+          if (this.isRegExp) {
+            try {
+              return (_b = (_a = this["entire"]) == null ? void 0 : _a["test"]) == null ? void 0 : _b.call(_a, path.entire);
+            } finally {
+              this.entire.lastIndex = 0;
+            }
+          }
+          const record = {
+            score: 0
+          };
+          const result = cacheWith(new import_matcher.Matcher(this.tree, record).match(path.segments));
+          this.matchScore = record.score;
+          return result.matched;
+        } else {
+          const record = {
+            score: 0
+          };
+          const result = cacheWith(import_matcher.Matcher.matchSegments(this.segments, path.segments, record));
+          this.matchScore = record.score;
+          return result.matched;
+        }
+      }
+    }, "match");
+    //别名组匹配
+    this.matchAliasGroup = /* @__PURE__ */ __name((name, alias) => {
+      const namePath = _Path.parse(name);
+      const aliasPath = _Path.parse(alias);
+      const nameMatched = this.match(namePath);
+      const nameMatchedScore = this.matchScore;
+      const aliasMatched = this.match(aliasPath);
+      const aliasMatchedScore = this.matchScore;
+      if (this.haveExcludePattern) {
+        if (nameMatchedScore >= aliasMatchedScore) {
+          return nameMatched;
+        } else {
+          return aliasMatched;
+        }
+      } else {
+        return nameMatched || aliasMatched;
+      }
+    }, "matchAliasGroup");
+    this.existIn = /* @__PURE__ */ __name((source, start = 0) => {
+      return existIn(this.segments, source, start);
+    }, "existIn");
+    this.getIn = /* @__PURE__ */ __name((source) => {
+      return getIn(this.segments, source);
+    }, "getIn");
+    this.setIn = /* @__PURE__ */ __name((source, value) => {
+      setIn(this.segments, source, value);
+      return source;
+    }, "setIn");
+    this.deleteIn = /* @__PURE__ */ __name((source) => {
+      deleteIn(this.segments, source);
+      return source;
+    }, "deleteIn");
+    this.ensureIn = /* @__PURE__ */ __name((source, defaults) => {
+      const results = this.getIn(source);
+      if (results === void 0) {
+        this.setIn(source, defaults);
+        return this.getIn(source);
+      }
+      return results;
+    }, "ensureIn");
+    const {
+      tree,
+      segments,
+      entire,
+      isRegExp: isRegExp2,
+      isMatchPattern,
+      isWildMatchPattern,
+      haveRelativePattern,
+      haveExcludePattern
+    } = parse(input, base);
+    this.entire = entire;
+    this.segments = segments;
+    this.isMatchPattern = isMatchPattern;
+    this.isWildMatchPattern = isWildMatchPattern;
+    this.haveRelativePattern = haveRelativePattern;
+    this.isRegExp = isRegExp2;
+    this.haveExcludePattern = haveExcludePattern;
+    this.tree = tree;
+    this.matchCache = /* @__PURE__ */ new Map();
+    this.includesCache = /* @__PURE__ */ new Map();
+  }
+  toString() {
+    var _a;
+    return (_a = this.entire) == null ? void 0 : _a.toString();
+  }
+  toArr() {
+    var _a;
+    return (_a = this.segments) == null ? void 0 : _a.slice();
+  }
+  get length() {
+    return this.segments.length;
+  }
+  static match(pattern) {
+    const path = _Path.parse(pattern);
+    const matcher = /* @__PURE__ */ __name((target) => {
+      return path.match(target);
+    }, "matcher");
+    matcher[isMatcher] = true;
+    matcher.path = path;
+    return matcher;
+  }
+  static isPathPattern(target) {
+    return !!((0, import_shared.isStr)(target) || (0, import_shared.isArr)(target) || (0, import_shared.isRegExp)(target) || (0, import_shared.isFn)(target) && target[isMatcher]);
+  }
+  static transform(pattern, regexp, callback) {
+    return _Path.parse(pattern).transform(regexp, callback);
+  }
+  static parse(path = "", base) {
+    if (path instanceof _Path) {
+      const found = pathCache.get(path.entire);
+      if (found) {
+        return found;
+      } else {
+        pathCache.set(path.entire, path);
+        return path;
+      }
+    } else if (path && path[isMatcher]) {
+      return _Path.parse(path["path"]);
+    } else {
+      const key_ = base ? _Path.parse(base) : "";
+      const key = `${path}:${key_}`;
+      const found = pathCache.get(key);
+      if (found) {
+        return found;
+      } else {
+        path = new _Path(path, base);
+        pathCache.set(key, path);
+        return path;
+      }
+    }
+  }
+};
+__name(_Path, "Path");
+_Path.getIn = /* @__PURE__ */ __name((source, pattern) => {
+  const path = _Path.parse(pattern);
+  return path.getIn(source);
+}, "getIn");
+_Path.setIn = /* @__PURE__ */ __name((source, pattern, value) => {
+  const path = _Path.parse(pattern);
+  return path.setIn(source, value);
+}, "setIn");
+_Path.deleteIn = /* @__PURE__ */ __name((source, pattern) => {
+  const path = _Path.parse(pattern);
+  return path.deleteIn(source);
+}, "deleteIn");
+_Path.existIn = /* @__PURE__ */ __name((source, pattern, start) => {
+  const path = _Path.parse(pattern);
+  return path.existIn(source, start);
+}, "existIn");
+_Path.ensureIn = /* @__PURE__ */ __name((source, pattern, defaultValue) => {
+  const path = _Path.parse(pattern);
+  return path.ensureIn(source, defaultValue);
+}, "ensureIn");
+let Path = _Path;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Path
+});

package/lib/path/matcher.d.ts

@@ -0,0 +1,33 @@
+import { DestructorExpressionNode, ExpandOperatorNode, GroupExpressionNode, IdentifierNode, IgnoreExpressionNode, Node, RangeExpressionNode, Segments, WildcardOperatorNode } from './types';
+export interface IRecord {
+    score: number;
+}
+export declare class Matcher {
+    private tree;
+    private stack;
+    private record;
+    private excluding;
+    private wildcards;
+    private path;
+    constructor(tree: Node, record?: any);
+    next(node: Node, pos: number): any;
+    shot(): void;
+    take(pos: number): string;
+    matchExcludeIdentifier(matched: boolean, node: Node, pos: number): any;
+    matchIdentifier(node: IdentifierNode, pos: number): any;
+    matchIgnoreExpression(node: IgnoreExpressionNode, pos: number): any;
+    matchDestructorExpression(node: DestructorExpressionNode, pos: number): any;
+    matchExpandOperator(node: ExpandOperatorNode, pos: number): any;
+    matchWildcardOperator(node: WildcardOperatorNode, pos: number): any;
+    matchGroupExpression(node: GroupExpressionNode, pos: number): any;
+    matchRangeExpression(node: RangeExpressionNode, pos: number): any;
+    matchNode(node: Node, pos?: number): any;
+    match(path: Segments): {
+        matched: any;
+        record: IRecord;
+    };
+    static matchSegments(source: Segments, target: Segments, record?: any): {
+        matched: any;
+        record: any;
+    };
+}