@tachybase/schema 0.23.41 → 0.23.48

package/lib/path/shared.js

@@ -0,0 +1,121 @@
+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 shared_exports = {};
+__export(shared_exports, {
+  isArr: () => isArr,
+  isAssignable: () => isAssignable,
+  isBool: () => isBool,
+  isEqual: () => isEqual,
+  isFn: () => isFn,
+  isNum: () => isNum,
+  isNumberLike: () => isNumberLike,
+  isObj: () => isObj,
+  isPlainObj: () => isPlainObj,
+  isRegExp: () => isRegExp,
+  isSegmentEqual: () => isSegmentEqual,
+  isStr: () => isStr,
+  toArr: () => toArr
+});
+module.exports = __toCommonJS(shared_exports);
+const toString = Object.prototype.toString;
+const isType = /* @__PURE__ */ __name((type) => (obj) => toString.call(obj) === `[object ${type}]`, "isType");
+const isFn = isType("Function");
+const isArr = Array.isArray || isType("Array");
+const isPlainObj = isType("Object");
+const isStr = isType("String");
+const isBool = isType("Boolean");
+const isNum = isType("Number");
+const isObj = /* @__PURE__ */ __name((val) => typeof val === "object", "isObj");
+const isRegExp = isType("RegExp");
+const isNumberLike = /* @__PURE__ */ __name((t) => {
+  return isNum(t) || /^(\d+)(\.\d+)?$/.test(t);
+}, "isNumberLike");
+const isArray = isArr;
+const keyList = Object.keys;
+const hasProp = Object.prototype.hasOwnProperty;
+const toArr = /* @__PURE__ */ __name((val) => Array.isArray(val) ? val : val !== void 0 ? [val] : [], "toArr");
+const isAssignable = /* @__PURE__ */ __name((val) => {
+  return typeof val === "object" || typeof val === "function";
+}, "isAssignable");
+const isEqual = /* @__PURE__ */ __name((a, b) => {
+  if (a === b) {
+    return true;
+  }
+  if (a && b && typeof a === "object" && typeof b === "object") {
+    const arrA = isArray(a);
+    const arrB = isArray(b);
+    let i;
+    let length;
+    let key;
+    if (arrA && arrB) {
+      length = a.length;
+      if (length !== b.length) {
+        return false;
+      }
+      for (i = length; i-- !== 0; ) {
+        if (!isEqual(a[i], b[i])) {
+          return false;
+        }
+      }
+      return true;
+    }
+    if (arrA !== arrB) {
+      return false;
+    }
+    const keys = keyList(a);
+    length = keys.length;
+    if (length !== keyList(b).length) {
+      return false;
+    }
+    for (i = length; i-- !== 0; ) {
+      if (!hasProp.call(b, keys[i])) {
+        return false;
+      }
+    }
+    for (i = length; i-- !== 0; ) {
+      key = keys[i];
+      if (!isEqual(a[key], b[key])) {
+        return false;
+      }
+    }
+    return true;
+  }
+  return a !== a && b !== b;
+}, "isEqual");
+const isSegmentEqual = /* @__PURE__ */ __name((a, b) => {
+  a = typeof a === "symbol" ? a : `${a}`;
+  b = typeof b === "symbol" ? b : `${b}`;
+  return a === b;
+}, "isSegmentEqual");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  isArr,
+  isAssignable,
+  isBool,
+  isEqual,
+  isFn,
+  isNum,
+  isNumberLike,
+  isObj,
+  isPlainObj,
+  isRegExp,
+  isSegmentEqual,
+  isStr,
+  toArr
+});

package/lib/path/tokenizer.d.ts

@@ -0,0 +1,27 @@
+import { Context } from './contexts';
+import { Token } from './tokens';
+export declare class Tokenizer {
+    input: string;
+    state: {
+        context: Context[];
+        type: Token;
+        pos: number;
+        value?: any;
+    };
+    type_: Token;
+    constructor(input: string);
+    curContext(): Context;
+    includesContext(context: Context): boolean;
+    unexpect(type?: Token): Error;
+    expectNext(type?: Token, next?: Token): void;
+    expectPrev(type?: Token, prev?: Token): void;
+    match(type?: Token): boolean;
+    skipSpace(): void;
+    next(): void;
+    getCode(pos?: number): number;
+    eat(type: any): boolean;
+    readKeyWord(): void;
+    readIgnoreString(): void;
+    finishToken(type: Token, value?: any): void;
+    readToken(code: number, prevCode: number): void;
+}

package/lib/path/tokenizer.js

@@ -0,0 +1,269 @@
+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 tokenizer_exports = {};
+__export(tokenizer_exports, {
+  Tokenizer: () => Tokenizer
+});
+module.exports = __toCommonJS(tokenizer_exports);
+var import_contexts = require("./contexts");
+var import_tokens = require("./tokens");
+const nonASCIIWhitespace = /[\u1680\u180e\u2000-\u200a\u202f\u205f\u3000\ufeff]/;
+const fullCharCodeAtPos = /* @__PURE__ */ __name((input, pos) => {
+  if (String.fromCharCode) return input.codePointAt(pos);
+  const code = input.charCodeAt(pos);
+  if (code <= 55295 || code >= 57344) return code;
+  const next = input.charCodeAt(pos + 1);
+  return (code << 10) + next - 56613888;
+}, "fullCharCodeAtPos");
+const isRewordCode = /* @__PURE__ */ __name((code) => code === 42 || code === 46 || code === 33 || code === 91 || code === 93 || code === 40 || code === 41 || code === 44 || code === 58 || code === 126 || code === 123 || code === 125, "isRewordCode");
+const getError = /* @__PURE__ */ __name((message, props) => {
+  const err = new Error(message);
+  Object.assign(err, props);
+  return err;
+}, "getError");
+const slice = /* @__PURE__ */ __name((string, start, end) => {
+  let str = "";
+  for (let i = start; i < end; i++) {
+    const ch = string.charAt(i);
+    if (ch !== "\\") {
+      str += ch;
+    }
+  }
+  return str;
+}, "slice");
+const _Tokenizer = class _Tokenizer {
+  constructor(input) {
+    this.input = input;
+    this.state = {
+      context: [],
+      type: null,
+      pos: 0
+    };
+    this.type_ = null;
+  }
+  curContext() {
+    return this.state.context[this.state.context.length - 1];
+  }
+  includesContext(context) {
+    for (let len = this.state.context.length - 1; len >= 0; len--) {
+      if (this.state.context[len] === context) {
+        return true;
+      }
+    }
+    return false;
+  }
+  unexpect(type) {
+    type = type || this.state.type;
+    return getError(`Unexpect token "${type.flag}" in ${this.state.pos} char.`, {
+      pos: this.state.pos
+    });
+  }
+  expectNext(type, next) {
+    if (type && type.expectNext) {
+      if (next && !type.expectNext.call(this, next)) {
+        throw getError(
+          `Unexpect token "${next.flag}" token should not be behind "${type.flag}" token.(${this.state.pos}th char)`,
+          {
+            pos: this.state.pos
+          }
+        );
+      }
+    }
+  }
+  expectPrev(type, prev) {
+    if (type && type.expectPrev) {
+      if (prev && !type.expectPrev.call(this, prev)) {
+        throw getError(`Unexpect token "${type.flag}" should not be behind "${prev.flag}"(${this.state.pos}th char).`, {
+          pos: this.state.pos
+        });
+      }
+    }
+  }
+  match(type) {
+    return this.state.type === type;
+  }
+  skipSpace() {
+    if (this.curContext() === import_contexts.bracketDContext) return;
+    loop: while (this.state.pos < this.input.length) {
+      const ch = this.input.charCodeAt(this.state.pos);
+      switch (ch) {
+        case 32:
+        case 160:
+          ++this.state.pos;
+          break;
+        case 13:
+          if (this.input.charCodeAt(this.state.pos + 1) === 10) {
+            ++this.state.pos;
+          }
+        case 10:
+        case 8232:
+        case 8233:
+          ++this.state.pos;
+          break;
+        default:
+          if (ch > 8 && ch < 14 || ch >= 5760 && nonASCIIWhitespace.test(String.fromCharCode(ch))) {
+            ++this.state.pos;
+          } else {
+            break loop;
+          }
+      }
+    }
+  }
+  next() {
+    this.type_ = this.state.type;
+    if (this.input.length <= this.state.pos) {
+      return this.finishToken(import_tokens.eofTok);
+    }
+    this.skipSpace();
+    this.readToken(this.getCode(), this.state.pos > 0 ? this.getCode(this.state.pos - 1) : -Infinity);
+  }
+  getCode(pos = this.state.pos) {
+    return fullCharCodeAtPos(this.input, pos);
+  }
+  eat(type) {
+    if (this.match(type)) {
+      this.next();
+      return true;
+    } else {
+      return false;
+    }
+  }
+  readKeyWord() {
+    let startPos = this.state.pos, string = "";
+    while (true) {
+      const code = this.getCode();
+      const prevCode = this.getCode(this.state.pos - 1);
+      if (this.input.length === this.state.pos) {
+        string = slice(this.input, startPos, this.state.pos + 1);
+        break;
+      }
+      if (!isRewordCode(code) || prevCode === 92) {
+        if (code === 32 || code === 160 || code === 10 || code === 8232 || code === 8233) {
+          string = slice(this.input, startPos, this.state.pos);
+          break;
+        }
+        if (code === 13 && this.input.charCodeAt(this.state.pos + 1) === 10) {
+          string = slice(this.input, startPos, this.state.pos);
+          break;
+        }
+        if (code > 8 && code < 14 || code >= 5760 && nonASCIIWhitespace.test(String.fromCharCode(code))) {
+          string = slice(this.input, startPos, this.state.pos);
+          break;
+        }
+        this.state.pos++;
+      } else {
+        string = slice(this.input, startPos, this.state.pos);
+        break;
+      }
+    }
+    this.finishToken(import_tokens.nameTok, string);
+  }
+  readIgnoreString() {
+    let startPos = this.state.pos, prevCode, string = "";
+    while (true) {
+      const code = this.getCode();
+      if (this.state.pos >= this.input.length) break;
+      if ((code === 91 || code === 93) && prevCode === 92) {
+        this.state.pos++;
+        prevCode = "";
+      } else if (code === 93 && prevCode === 93) {
+        string = this.input.slice(startPos, this.state.pos - 1).replace(/\\([[\]])/g, "$1");
+        this.state.pos++;
+        break;
+      } else {
+        this.state.pos++;
+        prevCode = code;
+      }
+    }
+    this.finishToken(import_tokens.ignoreTok, string);
+    this.finishToken(import_tokens.bracketDRTok);
+  }
+  finishToken(type, value) {
+    const preType = this.state.type;
+    this.state.type = type;
+    if (value !== void 0) this.state.value = value;
+    this.expectNext(preType, type);
+    this.expectPrev(type, preType);
+    if (type.updateContext) {
+      type.updateContext.call(this, preType);
+    }
+  }
+  readToken(code, prevCode) {
+    if (prevCode === 92) {
+      return this.readKeyWord();
+    }
+    if (this.input.length <= this.state.pos) {
+      this.finishToken(import_tokens.eofTok);
+    } else if (this.curContext() === import_contexts.bracketDContext) {
+      this.readIgnoreString();
+    } else if (code === 123) {
+      this.state.pos++;
+      this.finishToken(import_tokens.braceLTok);
+    } else if (code === 125) {
+      this.state.pos++;
+      this.finishToken(import_tokens.braceRTok);
+    } else if (code === 42) {
+      this.state.pos++;
+      if (this.getCode() === 42) {
+        this.state.pos++;
+        return this.finishToken(import_tokens.dbStarTok);
+      }
+      this.finishToken(import_tokens.starTok);
+    } else if (code === 33) {
+      this.state.pos++;
+      this.finishToken(import_tokens.bangTok);
+    } else if (code === 46) {
+      this.state.pos++;
+      this.finishToken(import_tokens.dotTok);
+    } else if (code === 91) {
+      this.state.pos++;
+      if (this.getCode() === 91) {
+        this.state.pos++;
+        return this.finishToken(import_tokens.bracketDLTok);
+      }
+      this.finishToken(import_tokens.bracketLTok);
+    } else if (code === 126) {
+      this.state.pos++;
+      this.finishToken(import_tokens.expandTok);
+    } else if (code === 93) {
+      this.state.pos++;
+      this.finishToken(import_tokens.bracketRTok);
+    } else if (code === 40) {
+      this.state.pos++;
+      this.finishToken(import_tokens.parenLTok);
+    } else if (code === 41) {
+      this.state.pos++;
+      this.finishToken(import_tokens.parenRTok);
+    } else if (code === 44) {
+      this.state.pos++;
+      this.finishToken(import_tokens.commaTok);
+    } else if (code === 58) {
+      this.state.pos++;
+      this.finishToken(import_tokens.colonTok);
+    } else {
+      this.readKeyWord();
+    }
+  }
+};
+__name(_Tokenizer, "Tokenizer");
+let Tokenizer = _Tokenizer;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Tokenizer
+});

package/lib/path/tokens.d.ts

@@ -0,0 +1,27 @@
+interface ITokenProps {
+    expectNext?: (next?: Token) => boolean;
+    expectPrev?: (prev?: Token) => boolean;
+    updateContext?: (prev?: Token) => void;
+}
+export type Token = ITokenProps & {
+    flag: string;
+};
+export declare const nameTok: Token;
+export declare const starTok: Token;
+export declare const dbStarTok: Token;
+export declare const dotTok: Token;
+export declare const bangTok: Token;
+export declare const colonTok: Token;
+export declare const braceLTok: Token;
+export declare const braceRTok: Token;
+export declare const bracketLTok: Token;
+export declare const bracketRTok: Token;
+export declare const bracketDLTok: Token;
+export declare const bracketDRTok: Token;
+export declare const parenLTok: Token;
+export declare const parenRTok: Token;
+export declare const commaTok: Token;
+export declare const ignoreTok: Token;
+export declare const expandTok: Token;
+export declare const eofTok: Token;
+export {};

package/lib/path/tokens.js

@@ -0,0 +1,216 @@
+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 tokens_exports = {};
+__export(tokens_exports, {
+  bangTok: () => bangTok,
+  braceLTok: () => braceLTok,
+  braceRTok: () => braceRTok,
+  bracketDLTok: () => bracketDLTok,
+  bracketDRTok: () => bracketDRTok,
+  bracketLTok: () => bracketLTok,
+  bracketRTok: () => bracketRTok,
+  colonTok: () => colonTok,
+  commaTok: () => commaTok,
+  dbStarTok: () => dbStarTok,
+  dotTok: () => dotTok,
+  eofTok: () => eofTok,
+  expandTok: () => expandTok,
+  ignoreTok: () => ignoreTok,
+  nameTok: () => nameTok,
+  parenLTok: () => parenLTok,
+  parenRTok: () => parenRTok,
+  starTok: () => starTok
+});
+module.exports = __toCommonJS(tokens_exports);
+var import_contexts = require("./contexts");
+const TokenType = /* @__PURE__ */ __name((flag, props) => {
+  return {
+    flag,
+    ...props
+  };
+}, "TokenType");
+const nameTok = TokenType("name", {
+  expectNext(next) {
+    if (this.includesContext(import_contexts.destructorContext)) {
+      return next === nameTok || next === commaTok || next === bracketRTok || next === braceRTok || next === colonTok;
+    }
+    return next === dotTok || next === commaTok || next === eofTok || next === bracketRTok || next === parenRTok || next === colonTok || next === expandTok || next === bracketLTok;
+  }
+});
+const starTok = TokenType("*", {
+  expectNext(next) {
+    return next === dotTok || next === parenLTok || next === bracketLTok || next === eofTok || next === commaTok || next === parenRTok;
+  }
+});
+const dbStarTok = TokenType("**", {
+  expectNext(next) {
+    return next === dotTok || next === bracketLTok || next === eofTok || next === commaTok || next === parenRTok;
+  }
+});
+const dotTok = TokenType(".", {
+  expectNext(next) {
+    return next === dotTok || next === nameTok || next === bracketDLTok || next === starTok || next === dbStarTok || next === bracketLTok || next === braceLTok || next === eofTok;
+  },
+  expectPrev(prev) {
+    return prev === dotTok || prev === nameTok || prev === bracketDRTok || prev === starTok || prev === parenRTok || prev === bracketRTok || prev === expandTok || prev === braceRTok;
+  }
+});
+const bangTok = TokenType("!", {
+  expectNext(next) {
+    return next === nameTok || next === bracketDLTok;
+  }
+});
+const colonTok = TokenType(":", {
+  expectNext(next) {
+    if (this.includesContext(import_contexts.destructorContext)) {
+      return next === nameTok || next === braceLTok || next === bracketLTok;
+    }
+    return next === nameTok || next === bracketDLTok || next === bracketRTok;
+  }
+});
+const braceLTok = TokenType("{", {
+  expectNext(next) {
+    return next === nameTok;
+  },
+  expectPrev(prev) {
+    if (this.includesContext(import_contexts.destructorContext)) {
+      return prev === colonTok || prev === commaTok || prev === bracketLTok;
+    }
+    return prev === dotTok || prev === colonTok || prev === parenLTok;
+  },
+  updateContext() {
+    this.state.context.push(import_contexts.braceContext);
+  }
+});
+const braceRTok = TokenType("}", {
+  expectNext(next) {
+    if (this.includesContext(import_contexts.destructorContext)) {
+      return next === commaTok || next === braceRTok || next === eofTok || next === bracketRTok;
+    }
+    return next === dotTok || next === eofTok || next === commaTok;
+  },
+  expectPrev(prev) {
+    return prev === nameTok || prev === braceRTok || prev === bracketRTok;
+  },
+  updateContext() {
+    this.state.context.pop(import_contexts.braceContext);
+  }
+});
+const bracketLTok = TokenType("[", {
+  expectNext(next) {
+    if (this.includesContext(import_contexts.destructorContext)) {
+      return next === nameTok || next === bracketLTok || next === braceLTok || next === bracketRTok;
+    }
+    return next === nameTok || next === bracketDLTok || next === colonTok || next === bracketLTok || next === ignoreTok || next === bracketRTok;
+  },
+  expectPrev(prev) {
+    if (this.includesContext(import_contexts.destructorContext)) {
+      return prev === colonTok || prev === commaTok || prev === bracketLTok;
+    }
+    return prev === starTok || prev === bracketLTok || prev === dotTok || prev === nameTok || prev === parenLTok || // never reach
+    prev === commaTok;
+  },
+  updateContext() {
+    this.state.context.push(import_contexts.bracketContext);
+  }
+});
+const bracketRTok = TokenType("]", {
+  expectNext(next) {
+    if (this.includesContext(import_contexts.destructorContext)) {
+      return next === commaTok || next === braceRTok || next === bracketRTok || next === eofTok;
+    }
+    return next === dotTok || next === eofTok || next === commaTok || next === parenRTok || next === bracketRTok;
+  },
+  updateContext() {
+    if (this.includesContext(import_contexts.bracketArrayContext)) return;
+    if (!this.includesContext(import_contexts.bracketContext)) throw this.unexpect();
+    this.state.context.pop();
+  }
+});
+const bracketDLTok = TokenType("[[", {
+  updateContext() {
+    this.state.context.push(import_contexts.bracketDContext);
+  }
+});
+const bracketDRTok = TokenType("]]", {
+  updateContext() {
+    if (this.curContext() !== import_contexts.bracketDContext) throw this.unexpect();
+    this.state.context.pop();
+  }
+});
+const parenLTok = TokenType("(", {
+  expectNext(next) {
+    return next === nameTok || next === bracketDLTok || next === braceLTok || next === bangTok || next === bracketLTok;
+  },
+  expectPrev(prev) {
+    return prev === starTok;
+  },
+  updateContext() {
+    this.state.context.push(import_contexts.parenContext);
+  }
+});
+const parenRTok = TokenType(")", {
+  expectNext(next) {
+    return next === dotTok || next === eofTok || next === commaTok || next === parenRTok;
+  },
+  updateContext() {
+    if (this.curContext() !== import_contexts.parenContext) throw this.unexpect();
+    this.state.context.pop();
+  }
+});
+const commaTok = TokenType(",", {
+  expectNext(next) {
+    return next === nameTok || next === bracketDLTok || next === bracketLTok || next === braceLTok;
+  }
+});
+const ignoreTok = TokenType("ignore", {
+  expectNext(next) {
+    return next === bracketDRTok;
+  },
+  expectPrev(prev) {
+    return prev === bracketDLTok;
+  }
+});
+const expandTok = TokenType("expandTok", {
+  expectNext(next) {
+    return next === dotTok || next === eofTok || next === commaTok || next === parenRTok;
+  }
+});
+const eofTok = TokenType("eof");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  bangTok,
+  braceLTok,
+  braceRTok,
+  bracketDLTok,
+  bracketDRTok,
+  bracketLTok,
+  bracketRTok,
+  colonTok,
+  commaTok,
+  dbStarTok,
+  dotTok,
+  eofTok,
+  expandTok,
+  ignoreTok,
+  nameTok,
+  parenLTok,
+  parenRTok,
+  starTok
+});