@tachybase/schema 0.23.40 → 0.23.47

package/lib/path/matcher.js

@@ -0,0 +1,197 @@
+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 matcher_exports = {};
+__export(matcher_exports, {
+  Matcher: () => Matcher
+});
+module.exports = __toCommonJS(matcher_exports);
+var import_shared = require("./shared");
+var import_types = require("./types");
+const _Matcher = class _Matcher {
+  constructor(tree, record) {
+    this.tree = tree;
+    this.stack = [];
+    this.excluding = false;
+    this.wildcards = [];
+    this.record = record;
+  }
+  next(node, pos) {
+    if (node.after) {
+      return this.matchNode(node.after, pos);
+    }
+    if ((0, import_types.isWildcardOperator)(node) && !node.filter) {
+      if (this.excluding) {
+        return false;
+      } else {
+        if (pos === 0 || node.optional) return true;
+        return !!this.take(pos);
+      }
+    }
+    const isLastToken = pos === this.path.length - 1;
+    if (isLastToken) {
+      return !!this.take(pos);
+    } else {
+      const wildcard = this.wildcards.pop();
+      if (wildcard && wildcard.after) {
+        return this.next(wildcard, pos);
+      }
+    }
+    return false;
+  }
+  shot() {
+    var _a;
+    if (((_a = this.record) == null ? void 0 : _a.score) >= 0) {
+      this.record.score++;
+    }
+  }
+  take(pos) {
+    return String(this.path[pos] ?? "");
+  }
+  matchExcludeIdentifier(matched, node, pos) {
+    const isLastToken = pos === this.path.length - 1;
+    const isContainToken = pos < this.path.length;
+    if (!node.after) {
+      this.excluding = false;
+    }
+    if (matched) {
+      if (node.after) {
+        return this.next(node, pos);
+      }
+      if (isLastToken) {
+        return false;
+      }
+    }
+    if (isLastToken) {
+      return true;
+    }
+    return isContainToken;
+  }
+  matchIdentifier(node, pos) {
+    const current = this.take(pos);
+    let matched = false;
+    if ((0, import_types.isExpandOperator)(node.after)) {
+      if (current.indexOf(node.value) === 0) {
+        this.shot();
+        matched = true;
+      }
+      if (this.excluding) {
+        return this.matchExcludeIdentifier(matched, node.after, pos);
+      } else {
+        return matched && this.next(node.after, pos);
+      }
+    } else if (current === node.value) {
+      this.shot();
+      matched = true;
+    }
+    if (this.excluding) {
+      return this.matchExcludeIdentifier(matched, node, pos);
+    } else {
+      return matched && this.next(node, pos);
+    }
+  }
+  matchIgnoreExpression(node, pos) {
+    return (0, import_shared.isEqual)(node.value, this.take(pos)) && this.next(node, pos);
+  }
+  matchDestructorExpression(node, pos) {
+    return (0, import_shared.isEqual)(node.source, this.take(pos)) && this.next(node, pos);
+  }
+  matchExpandOperator(node, pos) {
+    return this.next(node, pos);
+  }
+  matchWildcardOperator(node, pos) {
+    let matched = false;
+    if (node.filter) {
+      this.stack.push(node);
+      matched = this.matchNode(node.filter, pos);
+      this.stack.pop();
+    } else {
+      matched = this.next(node, pos);
+    }
+    return matched;
+  }
+  matchGroupExpression(node, pos) {
+    let excluding = false;
+    if (node.isExclude) {
+      excluding = !this.excluding;
+    }
+    return (0, import_shared.toArr)(node.value)[excluding ? "every" : "some"]((item) => {
+      this.wildcards = this.stack.slice();
+      this.excluding = excluding;
+      return this.matchNode(item, pos);
+    });
+  }
+  matchRangeExpression(node, pos) {
+    const current = Number(this.take(pos));
+    if (node.start) {
+      if (node.end) {
+        return current >= Number(node.start.value) && current <= Number(node.end.value);
+      } else {
+        return current >= Number(node.start.value);
+      }
+    } else {
+      if (node.end) {
+        return current <= Number(node.end.value);
+      } else {
+        this.wildcards = this.stack.slice();
+        return this.next(node, pos);
+      }
+    }
+  }
+  matchNode(node, pos = 0) {
+    if ((0, import_types.isDotOperator)(node)) {
+      return this.next(node, pos + 1);
+    } else if ((0, import_types.isIdentifier)(node)) {
+      return this.matchIdentifier(node, pos);
+    } else if ((0, import_types.isIgnoreExpression)(node)) {
+      return this.matchIgnoreExpression(node, pos);
+    } else if ((0, import_types.isDestructorExpression)(node)) {
+      return this.matchDestructorExpression(node, pos);
+    } else if ((0, import_types.isExpandOperator)(node)) {
+      return this.matchExpandOperator(node, pos);
+    } else if ((0, import_types.isWildcardOperator)(node)) {
+      return this.matchWildcardOperator(node, pos);
+    } else if ((0, import_types.isGroupExpression)(node)) {
+      return this.matchGroupExpression(node, pos);
+    } else if ((0, import_types.isRangeExpression)(node)) {
+      return this.matchRangeExpression(node, pos);
+    }
+    return false;
+  }
+  match(path) {
+    this.path = path;
+    return { matched: this.matchNode(this.tree), record: this.record };
+  }
+  static matchSegments(source, target, record) {
+    if (source.length !== target.length) return { matched: false, record };
+    const match = /* @__PURE__ */ __name((pos = 0) => {
+      const current = (0, import_shared.isSegmentEqual)(source[pos], target[pos]);
+      if ((record == null ? void 0 : record.score) >= 0) {
+        record.score++;
+      }
+      return current && (pos < source.length - 1 ? match(pos + 1) : true);
+    }, "match");
+    return { matched: match(), record };
+  }
+};
+__name(_Matcher, "Matcher");
+let Matcher = _Matcher;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Matcher
+});

package/lib/path/parser.d.ts

@@ -0,0 +1,33 @@
+import { Path } from './index';
+import { Tokenizer } from './tokenizer';
+import { Token } from './tokens';
+import { ArrayPatternNode, DestructorExpressionNode, ExpandOperatorNode, GroupExpressionNode, IdentifierNode, IgnoreExpressionNode, Node, ObjectPatternNode, ObjectPatternPropertyNode, RangeExpressionNode, Segments, WildcardOperatorNode } from './types';
+export declare class Parser extends Tokenizer {
+    isMatchPattern: boolean;
+    isWildMatchPattern: boolean;
+    haveExcludePattern: boolean;
+    haveRelativePattern: boolean;
+    base: Path;
+    relative: string | number;
+    data: {
+        segments: Segments;
+        tree?: Node;
+    };
+    constructor(input: string, base?: Path);
+    parse(): Node;
+    append(parent: Node, node: Node): void;
+    parseAtom(type: Token): Node;
+    pushSegments(key: string | number): void;
+    parseIdentifier(): IdentifierNode;
+    parseExpandOperator(): ExpandOperatorNode;
+    parseWildcardOperator(): WildcardOperatorNode;
+    parseDestructorExpression(): DestructorExpressionNode;
+    parseArrayPattern(): ArrayPatternNode;
+    parseArrayPatternElements(): any[];
+    parseObjectPattern(): ObjectPatternNode;
+    parseObjectProperties(): ObjectPatternPropertyNode[];
+    parseDotOperator(): Node;
+    parseIgnoreExpression(): IgnoreExpressionNode;
+    parseGroupExpression(parent: Node): GroupExpressionNode;
+    parseRangeExpression(parent: Node): RangeExpressionNode;
+}

package/lib/path/parser.js

@@ -0,0 +1,379 @@
+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 parser_exports = {};
+__export(parser_exports, {
+  Parser: () => Parser
+});
+module.exports = __toCommonJS(parser_exports);
+var import_contexts = require("./contexts");
+var import_destructor = require("./destructor");
+var import_shared = require("./shared");
+var import_tokenizer = require("./tokenizer");
+var import_tokens = require("./tokens");
+const createTreeBySegments = /* @__PURE__ */ __name((segments = [], afterNode) => {
+  const segLen = segments.length;
+  const build = /* @__PURE__ */ __name((start = 0) => {
+    const after = start < segLen - 1 ? build(start + 1) : afterNode;
+    const dot = after && {
+      type: "DotOperator",
+      after
+    };
+    return {
+      type: "Identifier",
+      value: segments[start],
+      after: dot
+    };
+  }, "build");
+  return build();
+}, "createTreeBySegments");
+const calculate = /* @__PURE__ */ __name((a, b, operator) => {
+  if ((0, import_shared.isNumberLike)(a) && (0, import_shared.isNumberLike)(b)) {
+    if (operator === "+") return String(Number(a) + Number(b));
+    if (operator === "-") return String(Number(a) - Number(b));
+    if (operator === "*") return String(Number(a) * Number(b));
+    if (operator === "/") return String(Number(a) / Number(b));
+  } else {
+    if (operator === "+") return String(a) + String(b);
+    if (operator === "-") return "NaN";
+    if (operator === "*") return "NaN";
+    if (operator === "/") return "NaN";
+  }
+  return String(Number(b));
+}, "calculate");
+const _Parser = class _Parser extends import_tokenizer.Tokenizer {
+  constructor(input, base) {
+    super(input);
+    this.isMatchPattern = false;
+    this.isWildMatchPattern = false;
+    this.haveExcludePattern = false;
+    this.haveRelativePattern = false;
+    this.base = base;
+  }
+  parse() {
+    let node;
+    this.data = {
+      segments: []
+    };
+    if (!this.eat(import_tokens.eofTok)) {
+      this.next();
+      node = this.parseAtom(this.state.type);
+    }
+    this.data.tree = node;
+    return node;
+  }
+  append(parent, node) {
+    if (parent && node) {
+      parent.after = node;
+    }
+  }
+  parseAtom(type) {
+    switch (type) {
+      case import_tokens.braceLTok:
+      case import_tokens.bracketLTok:
+        if (this.includesContext(import_contexts.destructorContext)) {
+          if (type === import_tokens.braceLTok) {
+            return this.parseObjectPattern();
+          } else {
+            return this.parseArrayPattern();
+          }
+        }
+        return this.parseDestructorExpression();
+      case import_tokens.nameTok:
+        return this.parseIdentifier();
+      case import_tokens.expandTok:
+        return this.parseExpandOperator();
+      case import_tokens.dbStarTok:
+      case import_tokens.starTok:
+        return this.parseWildcardOperator();
+      case import_tokens.bracketDLTok:
+        return this.parseIgnoreExpression();
+      case import_tokens.dotTok:
+        return this.parseDotOperator();
+    }
+  }
+  pushSegments(key) {
+    this.data.segments.push(key);
+  }
+  parseIdentifier() {
+    const node = {
+      type: "Identifier",
+      value: this.state.value
+    };
+    const hasNotInDestructor = !this.includesContext(import_contexts.destructorContext) && !this.isMatchPattern && !this.isWildMatchPattern;
+    this.next();
+    if (this.includesContext(import_contexts.bracketArrayContext)) {
+      if (this.state.type !== import_tokens.bracketRTok) {
+        throw this.unexpect();
+      } else {
+        this.state.context.pop();
+        this.next();
+      }
+    } else if (hasNotInDestructor) {
+      this.pushSegments(node.value);
+    }
+    if (this.state.type === import_tokens.bracketLTok) {
+      this.next();
+      if (this.state.type !== import_tokens.nameTok) {
+        throw this.unexpect();
+      }
+      this.state.context.push(import_contexts.bracketArrayContext);
+      let isNumberKey = false;
+      if (/^\d+$/.test(this.state.value)) {
+        isNumberKey = true;
+      }
+      const value = this.state.value;
+      this.pushSegments(isNumberKey ? Number(value) : value);
+      const after = this.parseAtom(this.state.type);
+      if (isNumberKey) {
+        after.arrayIndex = true;
+      }
+      this.append(node, after);
+    } else {
+      this.append(node, this.parseAtom(this.state.type));
+    }
+    return node;
+  }
+  parseExpandOperator() {
+    const node = {
+      type: "ExpandOperator"
+    };
+    this.isMatchPattern = true;
+    this.isWildMatchPattern = true;
+    this.data.segments = [];
+    this.next();
+    this.append(node, this.parseAtom(this.state.type));
+    return node;
+  }
+  parseWildcardOperator() {
+    const node = {
+      type: "WildcardOperator"
+    };
+    if (this.state.type === import_tokens.dbStarTok) {
+      node.optional = true;
+    }
+    this.isMatchPattern = true;
+    this.isWildMatchPattern = true;
+    this.data.segments = [];
+    this.next();
+    if (this.state.type === import_tokens.parenLTok) {
+      node.filter = this.parseGroupExpression(node);
+    } else if (this.state.type === import_tokens.bracketLTok) {
+      node.filter = this.parseRangeExpression(node);
+    }
+    this.append(node, this.parseAtom(this.state.type));
+    return node;
+  }
+  parseDestructorExpression() {
+    const node = {
+      type: "DestructorExpression"
+    };
+    this.state.context.push(import_contexts.destructorContext);
+    const startPos = this.state.pos - 1;
+    node.value = this.state.type === import_tokens.braceLTok ? this.parseObjectPattern() : this.parseArrayPattern();
+    const endPos = this.state.pos;
+    this.state.context.pop();
+    node.source = this.input.substring(startPos, endPos).replace(/\[\s*([+\-*/])?\s*([^,\]\s]*)\s*\]/, (match, operator, target) => {
+      if (this.relative !== void 0) {
+        if (operator) {
+          if (target) {
+            return calculate(this.relative, target, operator);
+          } else {
+            return calculate(this.relative, 1, operator);
+          }
+        } else {
+          if (target) {
+            return calculate(this.relative, target, "+");
+          } else {
+            return String(this.relative);
+          }
+        }
+      }
+      return match;
+    }).replace(/\s*\.\s*/g, "").replace(/\s*/g, "");
+    if (this.relative === void 0) {
+      (0, import_destructor.setDestructor)(node.source, (0, import_destructor.parseDestructorRules)(node));
+    }
+    this.relative = void 0;
+    this.pushSegments(node.source);
+    this.next();
+    this.append(node, this.parseAtom(this.state.type));
+    return node;
+  }
+  parseArrayPattern() {
+    const node = {
+      type: "ArrayPattern",
+      elements: []
+    };
+    this.next();
+    node.elements = this.parseArrayPatternElements();
+    return node;
+  }
+  parseArrayPatternElements() {
+    const nodes = [];
+    while (this.state.type !== import_tokens.bracketRTok && this.state.type !== import_tokens.eofTok) {
+      nodes.push(this.parseAtom(this.state.type));
+      if (this.state.type === import_tokens.bracketRTok) {
+        if (this.includesContext(import_contexts.destructorContext)) {
+          this.next();
+        }
+        return nodes;
+      }
+      this.next();
+    }
+    return nodes;
+  }
+  parseObjectPattern() {
+    const node = {
+      type: "ObjectPattern",
+      properties: []
+    };
+    this.next();
+    node.properties = this.parseObjectProperties();
+    return node;
+  }
+  parseObjectProperties() {
+    const nodes = [];
+    while (this.state.type !== import_tokens.braceRTok && this.state.type !== import_tokens.eofTok) {
+      const node = {
+        type: "ObjectPatternProperty",
+        key: this.parseAtom(this.state.type)
+      };
+      nodes.push(node);
+      if (this.state.type === import_tokens.colonTok) {
+        this.next();
+        node.value = this.parseAtom(this.state.type);
+      }
+      if (this.state.type === import_tokens.braceRTok) {
+        if (this.includesContext(import_contexts.destructorContext)) {
+          this.next();
+        }
+        return nodes;
+      }
+      this.next();
+    }
+    return nodes;
+  }
+  parseDotOperator() {
+    const node = {
+      type: "DotOperator"
+    };
+    const prevToken = this.type_;
+    if (!prevToken && this.base) {
+      if (this.base.isMatchPattern) {
+        throw new Error("Base path must be an absolute path.");
+      }
+      this.data.segments = this.base.toArr();
+      while (this.state.type === import_tokens.dotTok) {
+        this.relative = this.data.segments.pop();
+        this.haveRelativePattern = true;
+        this.next();
+      }
+      return createTreeBySegments(this.data.segments.slice(), this.parseAtom(this.state.type));
+    } else {
+      this.next();
+    }
+    this.append(node, this.parseAtom(this.state.type));
+    return node;
+  }
+  parseIgnoreExpression() {
+    this.next();
+    const value = String(this.state.value).replace(/\s*/g, "");
+    const node = {
+      type: "IgnoreExpression",
+      value
+    };
+    this.pushSegments(value);
+    this.next();
+    this.append(node, this.parseAtom(this.state.type));
+    this.next();
+    return node;
+  }
+  parseGroupExpression(parent) {
+    const node = {
+      type: "GroupExpression",
+      value: []
+    };
+    this.isMatchPattern = true;
+    this.data.segments = [];
+    this.next();
+    loop: while (true) {
+      switch (this.state.type) {
+        case import_tokens.commaTok:
+          this.next();
+          break;
+        case import_tokens.bangTok:
+          node.isExclude = true;
+          this.haveExcludePattern = true;
+          this.next();
+          break;
+        case import_tokens.eofTok:
+          break loop;
+        case import_tokens.parenRTok:
+          break loop;
+        default:
+          node.value.push(this.parseAtom(this.state.type));
+      }
+    }
+    this.next();
+    this.append(parent, this.parseAtom(this.state.type));
+    return node;
+  }
+  parseRangeExpression(parent) {
+    const node = {
+      type: "RangeExpression"
+    };
+    this.next();
+    this.isMatchPattern = true;
+    this.data.segments = [];
+    let start = false, hasColon = false;
+    loop: while (true) {
+      switch (this.state.type) {
+        case import_tokens.colonTok:
+          hasColon = true;
+          start = true;
+          this.next();
+          break;
+        case import_tokens.bracketRTok:
+          if (!hasColon && !node.end) {
+            node.end = node.start;
+          }
+          break loop;
+        case import_tokens.commaTok:
+          throw this.unexpect();
+        case import_tokens.eofTok:
+          break loop;
+        default:
+          if (!start) {
+            node.start = this.parseAtom(this.state.type);
+          } else {
+            node.end = this.parseAtom(this.state.type);
+          }
+      }
+    }
+    this.next();
+    this.append(parent, this.parseAtom(this.state.type));
+    return node;
+  }
+};
+__name(_Parser, "Parser");
+let Parser = _Parser;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Parser
+});

package/lib/path/shared.d.ts

@@ -0,0 +1,13 @@
+export declare const isFn: (obj: unknown) => obj is (...args: any[]) => any;
+export declare const isArr: (arg: any) => arg is any[];
+export declare const isPlainObj: (obj: unknown) => obj is object;
+export declare const isStr: (obj: unknown) => obj is string;
+export declare const isBool: (obj: unknown) => obj is boolean;
+export declare const isNum: (obj: unknown) => obj is number;
+export declare const isObj: (val: unknown) => val is object;
+export declare const isRegExp: (obj: unknown) => obj is RegExp;
+export declare const isNumberLike: (t: any) => boolean;
+export declare const toArr: <T>(val: T | T[]) => T[];
+export declare const isAssignable: (val: any) => boolean;
+export declare const isEqual: (a: any, b: any) => boolean;
+export declare const isSegmentEqual: (a: any, b: any) => boolean;