@idooel/components 0.0.2-beta.7 → 0.0.2-beta.8

package/dist/@idooel/components.esm.js

@@ -1,855 +1,8 @@
+import { parse as parse$1 } from '@idooel/expression';
 import moment from 'moment';
 import { type, net, route, util } from '@idooel/shared';
 import FileUpload from 'vue-upload-component';
 
-var __defProp$2 = Object.defineProperty;
-var __defNormalProp$2 = (obj, key, value) => key in obj ? __defProp$2(obj, key, {
-  enumerable: true,
-  configurable: true,
-  writable: true,
-  value
-}) : obj[key] = value;
-var __publicField$2 = (obj, key, value) => {
-  __defNormalProp$2(obj, typeof key !== "symbol" ? key + "" : key, value);
-  return value;
-};
-class LexerError extends Error {
-  constructor(message, index, line, column) {
-    super(message);
-    __publicField$2(this, "index");
-    __publicField$2(this, "line");
-    __publicField$2(this, "column");
-    this.name = "LexerError";
-    this.index = index;
-    this.line = line;
-    this.column = column;
-  }
-}
-class ParseError extends Error {
-  constructor(message, index, line, column) {
-    super(message);
-    __publicField$2(this, "index");
-    __publicField$2(this, "line");
-    __publicField$2(this, "column");
-    this.name = "ParseError";
-    this.index = index;
-    this.line = line;
-    this.column = column;
-  }
-}
-class EvalError extends Error {
-  constructor(message) {
-    super(message);
-    this.name = "EvalError";
-  }
-}
-var TokenKind = /* @__PURE__ */(TokenKind2 => {
-  TokenKind2["Identifier"] = "Identifier";
-  TokenKind2["Number"] = "Number";
-  TokenKind2["String"] = "String";
-  TokenKind2["Punctuator"] = "Punctuator";
-  TokenKind2["Operator"] = "Operator";
-  TokenKind2["EOF"] = "EOF";
-  return TokenKind2;
-})(TokenKind || {});
-const PUNCTUATORS = /* @__PURE__ */new Set(["(", ")", "{", "}", "[", "]", ".", ",", ":", "?"]);
-const MULTI_OPERATORS = ["?.", "??", "===", "!==", "==", "!=", "<=", ">=", "&&", "||"];
-const SINGLE_OPERATORS = /* @__PURE__ */new Set(["+", "-", "*", "/", "%", "<", ">", "!"]);
-function isDigit(ch) {
-  return ch >= "0" && ch <= "9";
-}
-function isIdentStart(ch) {
-  return ch >= "a" && ch <= "z" || ch >= "A" && ch <= "Z" || ch === "_" || ch === "$";
-}
-function isIdentPart(ch) {
-  return isIdentStart(ch) || isDigit(ch);
-}
-function lex(input) {
-  if (!input && input !== "") throw new LexerError("invalid input", 0, 1, 1);
-  const tokens = [];
-  let index = 0;
-  let line = 1;
-  let column = 1;
-  function current() {
-    return input.charAt(index);
-  }
-  function advance(n = 1) {
-    for (let i = 0; i < n; i++) {
-      const ch = input.charAt(index++);
-      if (ch === "\n") {
-        line++;
-        column = 1;
-      } else {
-        column++;
-      }
-    }
-  }
-  function make(kind, text, value, startIndex, startLine, startColumn) {
-    return {
-      kind,
-      text,
-      value,
-      index: startIndex ?? index,
-      line: startLine ?? line,
-      column: startColumn ?? column
-    };
-  }
-  while (index < input.length) {
-    const ch = current();
-    if (ch === " " || ch === "	" || ch === "\r" || ch === "\n" || ch === "\v" || ch === "\xA0") {
-      advance();
-      continue;
-    }
-    if (ch === "'" || ch === '"') {
-      const quote = ch;
-      const startIndex = index;
-      const startLine = line;
-      const startColumn = column;
-      advance();
-      let value = "";
-      let escaped = false;
-      while (index < input.length) {
-        const c = current();
-        if (escaped) {
-          if (c === "u") {
-            const hex = input.substring(index + 1, index + 5);
-            if (!/^[\da-f]{4}$/i.test(hex)) {
-              throw new LexerError(`invalid unicode escape \\u${hex}`, index, line, column);
-            }
-            value += String.fromCharCode(parseInt(hex, 16));
-            advance(5);
-          } else {
-            const ESCAPE = {
-              n: "\n",
-              f: "\f",
-              r: "\r",
-              t: "	",
-              v: "\v"
-            };
-            value += ESCAPE[c] ?? c;
-            advance();
-          }
-          escaped = false;
-          continue;
-        }
-        if (c === "\\") {
-          escaped = true;
-          advance();
-          continue;
-        }
-        if (c === quote) {
-          advance();
-          tokens.push(make("String" /* String */, input.slice(startIndex, index), value, startIndex, startLine, startColumn));
-          value = "";
-          break;
-        }
-        value += c;
-        advance();
-      }
-      if (value !== "") {
-        const last = tokens[tokens.length - 1];
-        if (!last || last.index !== startIndex) {
-          throw new LexerError("unterminated string", startIndex, startLine, startColumn);
-        }
-      }
-      continue;
-    }
-    if (isDigit(ch) || ch === "." && isDigit(input.charAt(index + 1))) {
-      const startIndex = index;
-      const startLine = line;
-      const startColumn = column;
-      let text = "";
-      while (index < input.length) {
-        let c = input.charAt(index).toLowerCase();
-        if (c === "." || isDigit(c)) {
-          text += c;
-        } else {
-          const c2 = input.charAt(index + 1);
-          if (c === "e" && (c2 === "+" || c2 === "-" || isDigit(c2))) {
-            text += c;
-          } else if ((c === "+" || c === "-") && isDigit(c2) && text.charAt(text.length - 1) === "e") {
-            text += c;
-          } else if ((c === "+" || c === "-") && (!c2 || !isDigit(c2)) && text.charAt(text.length - 1) === "e") {
-            throw new LexerError("dangling exponent", index, line, column);
-          } else {
-            break;
-          }
-        }
-        advance();
-      }
-      tokens.push(make("Number" /* Number */, text, Number(text), startIndex, startLine, startColumn));
-      continue;
-    }
-    if (isIdentStart(ch)) {
-      const startIndex = index;
-      const startLine = line;
-      const startColumn = column;
-      advance();
-      while (index < input.length && isIdentPart(current())) advance();
-      const text = input.slice(startIndex, index);
-      tokens.push(make("Identifier" /* Identifier */, text, void 0, startIndex, startLine, startColumn));
-      continue;
-    }
-    const three = input.substring(index, index + 3);
-    const two = input.substring(index, index + 2);
-    const one = input.substring(index, index + 1);
-    const multi = MULTI_OPERATORS.find(op => input.startsWith(op, index));
-    if (multi) {
-      tokens.push(make("Operator" /* Operator */, multi, void 0, index, line, column));
-      advance(multi.length);
-      continue;
-    }
-    if (PUNCTUATORS.has(one)) {
-      tokens.push(make("Punctuator" /* Punctuator */, one, void 0, index, line, column));
-      advance();
-      continue;
-    }
-    if (SINGLE_OPERATORS.has(one)) {
-      tokens.push(make("Operator" /* Operator */, one, void 0, index, line, column));
-      advance();
-      continue;
-    }
-    throw new LexerError(`invalid token '${three || two || one}'`, index, line, column);
-  }
-  tokens.push({
-    kind: "EOF" /* EOF */,
-    text: "<eof>",
-    index,
-    line,
-    column
-  });
-  return {
-    tokens
-  };
-}
-var __defProp$1 = Object.defineProperty;
-var __defNormalProp$1 = (obj, key, value) => key in obj ? __defProp$1(obj, key, {
-  enumerable: true,
-  configurable: true,
-  writable: true,
-  value
-}) : obj[key] = value;
-var __publicField$1 = (obj, key, value) => {
-  __defNormalProp$1(obj, typeof key !== "symbol" ? key + "" : key, value);
-  return value;
-};
-class LRUCache {
-  constructor(maxSize = 100) {
-    __publicField$1(this, "cache", /* @__PURE__ */new Map());
-    __publicField$1(this, "maxSize");
-    this.maxSize = maxSize;
-  }
-  get(key) {
-    const value = this.cache.get(key);
-    if (value !== void 0) {
-      this.cache.delete(key);
-      this.cache.set(key, value);
-    }
-    return value;
-  }
-  set(key, value) {
-    if (this.cache.has(key)) {
-      this.cache.delete(key);
-    }
-    if (this.cache.size >= this.maxSize) {
-      const firstKey = this.cache.keys().next().value;
-      if (firstKey !== void 0) {
-        this.cache.delete(firstKey);
-      }
-    }
-    this.cache.set(key, value);
-  }
-  clear() {
-    this.cache.clear();
-  }
-}
-const astCache = new LRUCache(100);
-function parseToAst(input) {
-  const cached = astCache.get(input);
-  if (cached !== void 0) {
-    return cached;
-  }
-  const {
-    tokens
-  } = lex(input);
-  const state = new Parser(tokens, input);
-  const result = state.parse();
-  astCache.set(input, result);
-  return result;
-}
-class Parser {
-  constructor(tokens, input) {
-    __publicField$1(this, "tokens");
-    __publicField$1(this, "input");
-    __publicField$1(this, "i", 0);
-    this.tokens = tokens;
-    this.input = input;
-  }
-  current() {
-    return this.tokens[this.i];
-  }
-  next() {
-    return this.tokens[this.i + 1];
-  }
-  eat() {
-    return this.tokens[this.i++];
-  }
-  matchText(text) {
-    return this.current()?.text === text;
-  }
-  expectText(text) {
-    const t = this.current();
-    if (!text || t?.text === text) {
-      this.i++;
-      return t;
-    }
-    return void 0;
-  }
-  consumeText(text) {
-    const t = this.expectText(text);
-    if (!t) this.error(this.current(), `unexpected token, expect '${text ?? "<any>"}'`);
-    return t;
-  }
-  error(t, message) {
-    throw new ParseError(`${message} at ${t.line}:${t.column}`, t.index, t.line, t.column);
-  }
-  parse() {
-    const t = this.current();
-    if (t && t.kind !== TokenKind.EOF && t.text !== "}" && t.text !== ")" && t.text !== "]") {
-      const expr = this.expression();
-      return expr;
-    }
-    return void 0;
-  }
-  expression() {
-    return this.ternary();
-  }
-  ternary() {
-    const test = this.nullish();
-    if (this.expectText("?")) {
-      const consequent = this.expression();
-      this.consumeText(":");
-      const alternate = this.expression();
-      const node = {
-        type: "ConditionalExpression",
-        test,
-        consequent,
-        alternate
-      };
-      return node;
-    }
-    return test;
-  }
-  nullish() {
-    let left = this.logicalOR();
-    while (this.expectText("??")) {
-      if (isLogicalAndOr(left)) {
-        this.error(this.current(), "Cannot mix ?? with && or || without parentheses");
-      }
-      const rightStart = this.current();
-      const right = this.logicalOR();
-      if (isLogicalAndOr(right)) {
-        this.error(rightStart, "Cannot mix ?? with && or || without parentheses");
-      }
-      const node = {
-        type: "LogicalExpression",
-        operator: "??",
-        left,
-        right
-      };
-      left = node;
-    }
-    return left;
-  }
-  logicalOR() {
-    let left = this.logicalAND();
-    while (this.expectText("||")) {
-      const right = this.logicalAND();
-      const node = {
-        type: "LogicalExpression",
-        operator: "||",
-        left,
-        right
-      };
-      left = node;
-    }
-    return left;
-  }
-  logicalAND() {
-    let left = this.equality();
-    while (this.expectText("&&")) {
-      const right = this.equality();
-      const node = {
-        type: "LogicalExpression",
-        operator: "&&",
-        left,
-        right
-      };
-      left = node;
-    }
-    return left;
-  }
-  equality() {
-    let left = this.relational();
-    while (true) {
-      if (this.expectText("===")) {
-        left = this.binary(left, "===", this.relational());
-      } else if (this.expectText("!==")) {
-        left = this.binary(left, "!==", this.relational());
-      } else if (this.expectText("==")) {
-        left = this.binary(left, "==", this.relational());
-      } else if (this.expectText("!=")) {
-        left = this.binary(left, "!=", this.relational());
-      } else break;
-    }
-    return left;
-  }
-  relational() {
-    let left = this.additive();
-    while (true) {
-      if (this.expectText("<=")) {
-        left = this.binary(left, "<=", this.additive());
-      } else if (this.expectText(">=")) {
-        left = this.binary(left, ">=", this.additive());
-      } else if (this.expectText("<")) {
-        left = this.binary(left, "<", this.additive());
-      } else if (this.expectText(">")) {
-        left = this.binary(left, ">", this.additive());
-      } else break;
-    }
-    return left;
-  }
-  additive() {
-    let left = this.multiplicative();
-    while (true) {
-      if (this.expectText("+")) {
-        left = this.binary(left, "+", this.multiplicative());
-      } else if (this.expectText("-")) {
-        left = this.binary(left, "-", this.multiplicative());
-      } else break;
-    }
-    return left;
-  }
-  multiplicative() {
-    let left = this.unary();
-    while (true) {
-      if (this.expectText("*")) {
-        left = this.binary(left, "*", this.unary());
-      } else if (this.expectText("/")) {
-        left = this.binary(left, "/", this.unary());
-      } else if (this.expectText("%")) {
-        left = this.binary(left, "%", this.unary());
-      } else break;
-    }
-    return left;
-  }
-  unary() {
-    if (this.expectText("+")) {
-      return this.primary();
-    }
-    if (this.expectText("-")) {
-      const arg = this.unary();
-      const node = {
-        type: "UnaryExpression",
-        operator: "-",
-        argument: arg
-      };
-      return node;
-    }
-    if (this.expectText("!")) {
-      const arg = this.unary();
-      const node = {
-        type: "UnaryExpression",
-        operator: "!",
-        argument: arg
-      };
-      return node;
-    }
-    return this.primary();
-  }
-  primary() {
-    const t = this.current();
-    let expr;
-    if (this.expectText("(")) {
-      expr = this.expression();
-      this.consumeText(")");
-    } else if (this.expectText("[")) {
-      expr = this.array();
-    } else if (this.expectText("{")) {
-      expr = this.object();
-    } else if (t.kind === TokenKind.Identifier && (t.text === "true" || t.text === "false" || t.text === "null" || t.text === "undefined")) {
-      const tok = this.eat();
-      const map = {
-        true: true,
-        false: false,
-        null: null,
-        undefined: void 0
-      };
-      const node = {
-        type: "Literal",
-        value: map[tok.text]
-      };
-      expr = node;
-    } else if (t.kind === TokenKind.Identifier) {
-      expr = this.identifier();
-    } else if (t.kind === TokenKind.Number || t.kind === TokenKind.String) {
-      const tok = this.eat();
-      const node = {
-        type: "Literal",
-        value: tok.kind === TokenKind.Number ? Number(tok.text) : String(tok.value)
-      };
-      expr = node;
-    } else {
-      this.error(t, "unexpected token in primary");
-    }
-    while (true) {
-      if (this.expectText("(")) {
-        const args = [];
-        if (!this.matchText(")")) {
-          do {
-            args.push(this.expression());
-          } while (this.expectText(","));
-        }
-        this.consumeText(")");
-        const call = {
-          type: "CallExpression",
-          callee: expr,
-          arguments: args,
-          optional: false
-        };
-        expr = call;
-        continue;
-      }
-      if (this.expectText("?.(")) ;
-      if (this.expectText(".")) {
-        const id = this.consumeIdentifier();
-        const prop = {
-          type: "Identifier",
-          name: id
-        };
-        const mem = {
-          type: "MemberExpression",
-          object: expr,
-          property: prop,
-          computed: false,
-          optional: false
-        };
-        expr = mem;
-        continue;
-      }
-      if (this.expectText("[")) {
-        const prop = this.expression();
-        this.consumeText("]");
-        const mem = {
-          type: "MemberExpression",
-          object: expr,
-          property: prop,
-          computed: true,
-          optional: false
-        };
-        expr = mem;
-        continue;
-      }
-      if (this.matchText("?.")) {
-        this.eat();
-        if (this.expectText("(")) {
-          const args = [];
-          if (!this.matchText(")")) {
-            do {
-              args.push(this.expression());
-            } while (this.expectText(","));
-          }
-          this.consumeText(")");
-          const call = {
-            type: "CallExpression",
-            callee: expr,
-            arguments: args,
-            optional: true
-          };
-          expr = call;
-          continue;
-        }
-        if (this.expectText("[")) {
-          const prop2 = this.expression();
-          this.consumeText("]");
-          const mem2 = {
-            type: "MemberExpression",
-            object: expr,
-            property: prop2,
-            computed: true,
-            optional: true
-          };
-          expr = mem2;
-          continue;
-        }
-        const id = this.consumeIdentifier();
-        const prop = {
-          type: "Identifier",
-          name: id
-        };
-        const mem = {
-          type: "MemberExpression",
-          object: expr,
-          property: prop,
-          computed: false,
-          optional: true
-        };
-        expr = mem;
-        continue;
-      }
-      break;
-    }
-    return expr;
-  }
-  identifier() {
-    const name = this.consumeIdentifier();
-    const node = {
-      type: "Identifier",
-      name
-    };
-    return node;
-  }
-  consumeIdentifier() {
-    const t = this.current();
-    if (t.kind !== TokenKind.Identifier) this.error(t, "identifier expected");
-    this.eat();
-    return t.text;
-  }
-  array() {
-    const elements = [];
-    if (!this.matchText("]")) {
-      do {
-        if (this.matchText("]")) break;
-        elements.push(this.expression());
-      } while (this.expectText(","));
-    }
-    this.consumeText("]");
-    return {
-      type: "ArrayExpression",
-      elements
-    };
-  }
-  object() {
-    const properties = [];
-    if (!this.matchText("}")) {
-      do {
-        if (this.matchText("}")) break;
-        const keyTok = this.eat();
-        let key;
-        if (keyTok.kind === TokenKind.String) key = String(keyTok.value);else if (keyTok.kind === TokenKind.Identifier) key = keyTok.text;else this.error(keyTok, "invalid object key");
-        this.consumeText(":");
-        const value = this.expression();
-        properties.push({
-          key,
-          value
-        });
-      } while (this.expectText(","));
-    }
-    this.consumeText("}");
-    return {
-      type: "ObjectExpression",
-      properties
-    };
-  }
-  binary(left, op, right) {
-    return {
-      type: "BinaryExpression",
-      operator: op,
-      left,
-      right
-    };
-  }
-}
-function isLogicalAndOr(node) {
-  return node.type === "LogicalExpression" && (node.operator === "&&" || node.operator === "||");
-}
-const DENY_KEYS = /* @__PURE__ */new Set(["__proto__", "prototype", "constructor"]);
-let evalOptions = {};
-let currentDepth = 0;
-function evaluate(ast, scope, options) {
-  if (!ast) return void 0;
-  evalOptions = options || {};
-  currentDepth = 0;
-  return exec(ast, scope);
-}
-function exec(node, scope) {
-  const maxDepth = evalOptions.maxDepth || 100;
-  if (++currentDepth > maxDepth) {
-    currentDepth--;
-    if (evalOptions.strict) {
-      throw new EvalError(`Maximum recursion depth (${maxDepth}) exceeded`);
-    }
-    return void 0;
-  }
-  try {
-    switch (node.type) {
-      case "Literal":
-        return node.value;
-      case "Identifier":
-        return readIdentifier(node, scope);
-      case "MemberExpression":
-        return readMember(node, scope);
-      case "CallExpression":
-        return callExpression(node, scope);
-      case "UnaryExpression":
-        return unaryExpression(node, scope);
-      case "BinaryExpression":
-        return binaryExpression(node, scope);
-      case "LogicalExpression":
-        return logicalExpression(node, scope);
-      case "ConditionalExpression":
-        return conditionalExpression(node, scope);
-      case "ArrayExpression":
-        return arrayExpression(node, scope);
-      case "ObjectExpression":
-        return objectExpression(node, scope);
-      default:
-        return void 0;
-    }
-  } finally {
-    currentDepth--;
-  }
-}
-function readIdentifier(node, scope) {
-  if (!scope) return void 0;
-  return scope[node.name];
-}
-function readMember(node, scope) {
-  const object = exec(node.object, scope);
-  if (object == null) {
-    return void 0;
-  }
-  const key = node.computed ? String(exec(node.property, scope)) : node.property.name;
-  if (DENY_KEYS.has(key)) {
-    if (evalOptions.strict) {
-      throw new EvalError(`Access to property "${key}" is not allowed`);
-    }
-    return void 0;
-  }
-  try {
-    return object[key];
-  } catch (err) {
-    if (evalOptions.strict) {
-      throw new EvalError(`Failed to access property "${key}": ${err}`);
-    }
-    return void 0;
-  }
-}
-function callExpression(node, scope) {
-  let fn;
-  let thisArg = void 0;
-  const calleeNode = node.callee;
-  if (calleeNode.type === "MemberExpression") {
-    const mem = calleeNode;
-    thisArg = exec(mem.object, scope);
-    if (thisArg == null) return void 0;
-    const key = mem.computed ? String(exec(mem.property, scope)) : mem.property.name;
-    if (DENY_KEYS.has(key)) {
-      if (evalOptions.strict) {
-        throw new EvalError(`Call to method "${key}" is not allowed`);
-      }
-      return void 0;
-    }
-    fn = thisArg[key];
-  } else {
-    fn = exec(node.callee, scope);
-  }
-  if (fn == null) return void 0;
-  if (typeof fn !== "function") {
-    if (evalOptions.strict) {
-      throw new EvalError(`Cannot call non-function value`);
-    }
-    return void 0;
-  }
-  const args = node.arguments.map(a => exec(a, scope));
-  try {
-    return fn.apply(thisArg, args);
-  } catch (err) {
-    if (evalOptions.strict) {
-      throw new EvalError(`Function call failed: ${err}`);
-    }
-    return void 0;
-  }
-}
-function unaryExpression(node, scope) {
-  const v = exec(node.argument, scope);
-  switch (node.operator) {
-    case "-":
-      return 0 - Number(v);
-    case "!":
-      return !v;
-    case "+":
-      return v;
-  }
-}
-function binaryExpression(node, scope) {
-  const a = exec(node.left, scope);
-  const b = exec(node.right, scope);
-  switch (node.operator) {
-    case "+":
-      return a + b;
-    case "-":
-      return a - b;
-    case "*":
-      return a * b;
-    case "/":
-      return a / b;
-    case "%":
-      return a % b;
-    case "==":
-      return a == b;
-    case "!=":
-      return a != b;
-    case "===":
-      return a === b;
-    case "!==":
-      return a !== b;
-    case "<":
-      return a < b;
-    case ">":
-      return a > b;
-    case "<=":
-      return a <= b;
-    case ">=":
-      return a >= b;
-  }
-}
-function logicalExpression(node, scope) {
-  if (node.operator === "&&") {
-    const left2 = exec(node.left, scope);
-    return left2 ? exec(node.right, scope) : left2;
-  }
-  if (node.operator === "||") {
-    const left2 = exec(node.left, scope);
-    return left2 ? left2 : exec(node.right, scope);
-  }
-  const left = exec(node.left, scope);
-  return left ?? exec(node.right, scope);
-}
-function conditionalExpression(node, scope) {
-  const test = exec(node.test, scope);
-  return test ? exec(node.consequent, scope) : exec(node.alternate, scope);
-}
-function arrayExpression(node, scope) {
-  return node.elements.map(e => exec(e, scope));
-}
-function objectExpression(node, scope) {
-  const out = {};
-  for (const p of node.properties) {
-    if (DENY_KEYS.has(p.key)) continue;
-    out[p.key] = exec(p.value, scope);
-  }
-  return out;
-}
-function compile(expression, options) {
-  if (!expression) throw new Error("expression is required");
-  const ast = parseToAst(expression);
-  return scope => evaluate(ast, scope, options);
-}
-function parse$1(expression, scope = {}, options) {
-  return compile(expression, options)(scope);
-}
-
 const CONTEXT = '__idooel__ele__context__';
 const AREA_NAMES = {
   BUTTON_GROUP: 'BUTTON_GROUP'