@stndrds/schema 1.0.0-alpha.199 → 1.0.0-alpha.201

package/dist/index.js

@@ -2,7 +2,7 @@
 
 var chunkFRCDMQER_js = require('./chunk-FRCDMQER.js');
 require('./chunk-PGERPYDR.js');
-var chunkM5QIBMIH_js = require('./chunk-M5QIBMIH.js');
+var chunkNSM2JPC3_js = require('./chunk-NSM2JPC3.js');
 var chunkMZOEL7FN_js = require('./chunk-MZOEL7FN.js');
 require('./chunk-5WATIVCA.js');
 require('./chunk-O44XVGHE.js');
@@ -5207,310 +5207,6 @@ function isComputedFunctionName(name) {
   return Object.hasOwn(COMPUTED_FUNCTIONS, name);
 }
 
-// src/computed/parser.ts
-var ComputedFormulaParseError = class extends Error {
-  constructor(message) {
-    super(message);
-    this.name = "ComputedFormulaParseError";
-  }
-};
-function parseComputedFormula(expression) {
-  const parser = new Parser(tokenize(expression));
-  const ast = parser.parseExpression();
-  parser.expectEnd();
-  return ast;
-}
-function tokenize(expression) {
-  const tokens = [];
-  let index = 0;
-  while (index < expression.length) {
-    const char = expression[index];
-    if (char === " " || char === "	" || char === "\n" || char === "\r") {
-      index += 1;
-      continue;
-    }
-    if (char === '"' || char === "'") {
-      const result = scanString(expression, index, char);
-      tokens.push({ kind: "string", value: result.value, position: index });
-      index = result.nextIndex;
-      continue;
-    }
-    if (isDigit(char)) {
-      const result = scanNumber(expression, index);
-      tokens.push({ kind: "number", value: result.value, position: index });
-      index = result.nextIndex;
-      continue;
-    }
-    if (isIdentifierStart(char)) {
-      const result = scanIdentifier(expression, index);
-      const canonical = result.value.toLowerCase();
-      if (canonical === "true") {
-        tokens.push({ kind: "boolean", value: true, position: index });
-      } else if (canonical === "false") {
-        tokens.push({ kind: "boolean", value: false, position: index });
-      } else if (canonical === "null") {
-        tokens.push({ kind: "null", position: index });
-      } else {
-        tokens.push({ kind: "identifier", value: result.value, position: index });
-      }
-      index = result.nextIndex;
-      continue;
-    }
-    const twoChar = expression.slice(index, index + 2);
-    if (twoChar === ">=" || twoChar === "<=" || twoChar === "==" || twoChar === "!=") {
-      tokens.push({ kind: "operator", value: twoChar, position: index });
-      index += 2;
-      continue;
-    }
-    if (char === ">" || char === "<" || char === "+" || char === "-" || char === "*" || char === "/") {
-      tokens.push({ kind: "operator", value: char, position: index });
-      index += 1;
-      continue;
-    }
-    if (char === "(" || char === ")" || char === "," || char === ".") {
-      tokens.push({ kind: "punctuation", value: char, position: index });
-      index += 1;
-      continue;
-    }
-    throw new ComputedFormulaParseError(`Unexpected character "${char}" at position ${index}`);
-  }
-  return tokens;
-}
-function scanString(expression, startIndex, delimiter = '"') {
-  let value = "";
-  let index = startIndex + 1;
-  while (index < expression.length) {
-    const char = expression[index];
-    if (char === delimiter) {
-      return { value, nextIndex: index + 1 };
-    }
-    if (char === "\\") {
-      const escaped = expression[index + 1];
-      if (escaped === void 0) {
-        throw new ComputedFormulaParseError(`Unterminated string literal at position ${index}`);
-      }
-      value += decodeEscape(escaped, index);
-      index += 2;
-      continue;
-    }
-    value += char;
-    index += 1;
-  }
-  throw new ComputedFormulaParseError(`Unterminated string literal at position ${startIndex}`);
-}
-function decodeEscape(char, position) {
-  switch (char) {
-    case '"':
-    case "\\":
-      return char;
-    case "n":
-      return "\n";
-    case "r":
-      return "\r";
-    case "t":
-      return "	";
-    default:
-      throw new ComputedFormulaParseError(
-        `Unknown escape sequence "\\${char}" at position ${position}`
-      );
-  }
-}
-function scanNumber(expression, startIndex) {
-  let index = startIndex;
-  while (index < expression.length && isDigit(expression[index])) {
-    index += 1;
-  }
-  if (expression[index] === ".") {
-    const decimalStart = index;
-    index += 1;
-    if (!isDigit(expression[index])) {
-      throw new ComputedFormulaParseError(`Invalid number literal at position ${decimalStart}`);
-    }
-    while (index < expression.length && isDigit(expression[index])) {
-      index += 1;
-    }
-  }
-  const raw = expression.slice(startIndex, index);
-  const value = Number(raw);
-  if (!Number.isFinite(value)) {
-    throw new ComputedFormulaParseError(`Invalid number literal "${raw}"`);
-  }
-  return { value, nextIndex: index };
-}
-function scanIdentifier(expression, startIndex) {
-  let index = startIndex + 1;
-  while (index < expression.length && isIdentifierPart(expression[index])) {
-    index += 1;
-  }
-  return { value: expression.slice(startIndex, index), nextIndex: index };
-}
-function isDigit(char) {
-  return char !== void 0 && char >= "0" && char <= "9";
-}
-function isIdentifierStart(char) {
-  return char !== void 0 && /[A-Za-z_]/.test(char);
-}
-function isIdentifierPart(char) {
-  return char !== void 0 && /[A-Za-z0-9_]/.test(char);
-}
-var Parser = class {
-  constructor(tokens) {
-    this.tokens = tokens;
-    this.position = 0;
-  }
-  parseExpression() {
-    return this.parseBinaryExpression(0);
-  }
-  expectEnd() {
-    const token = this.peek();
-    if (token !== void 0) {
-      throw new ComputedFormulaParseError(
-        `Unexpected token ${describeToken(token)} at position ${token.position}`
-      );
-    }
-  }
-  parseBinaryExpression(minPrecedence) {
-    let left = this.parsePrimary();
-    while (true) {
-      const token = this.peek();
-      if (token?.kind !== "operator") {
-        return left;
-      }
-      const precedence = getOperatorPrecedence(token.value);
-      if (precedence < minPrecedence) {
-        return left;
-      }
-      const operator = token.value;
-      this.consume();
-      const right = this.parseBinaryExpression(precedence + 1);
-      left = { kind: "binary", operator, left, right };
-    }
-  }
-  parsePrimary() {
-    const token = this.consume();
-    if (token === void 0) {
-      throw new ComputedFormulaParseError("Unexpected end of expression");
-    }
-    switch (token.kind) {
-      case "string":
-      case "number":
-      case "boolean":
-        return { kind: "literal", value: token.value };
-      case "null":
-        return { kind: "literal", value: null };
-      case "identifier":
-        return this.parseIdentifier(token.value);
-      case "punctuation":
-        if (token.value === "(") {
-          const expression = this.parseExpression();
-          this.expectPunctuation(")");
-          return expression;
-        }
-        break;
-      case "operator":
-        if (token.value === "-") {
-          const next = this.consume();
-          if (next?.kind === "number") {
-            return { kind: "literal", value: -next.value };
-          }
-        }
-        break;
-    }
-    throw new ComputedFormulaParseError(
-      `Expected literal, path, call, or parenthesized expression at position ${token.position}`
-    );
-  }
-  parseIdentifier(identifier) {
-    if (this.matchPunctuation("(")) {
-      const args = [];
-      if (!this.matchPunctuation(")")) {
-        do {
-          args.push(this.parseExpression());
-        } while (this.matchPunctuation(","));
-        this.expectPunctuation(")");
-      }
-      return { kind: "call", functionName: identifier.toLowerCase(), args };
-    }
-    const parts = [identifier];
-    while (this.matchPunctuation(".")) {
-      const next = this.consume();
-      if (next?.kind !== "identifier") {
-        const position = next?.position ?? this.previousPosition();
-        throw new ComputedFormulaParseError(
-          `Expected attribute name after path separator at position ${position}`
-        );
-      }
-      parts.push(next.value);
-    }
-    return { kind: "path", parts };
-  }
-  expectPunctuation(value) {
-    if (!this.matchPunctuation(value)) {
-      const token = this.peek();
-      const position = token?.position ?? this.previousPosition();
-      throw new ComputedFormulaParseError(`Expected "${value}" at position ${position}`);
-    }
-  }
-  matchPunctuation(value) {
-    const token = this.peek();
-    if (token?.kind === "punctuation" && token.value === value) {
-      this.consume();
-      return true;
-    }
-    return false;
-  }
-  peek() {
-    return this.tokens[this.position];
-  }
-  consume() {
-    const token = this.tokens[this.position];
-    this.position += 1;
-    return token;
-  }
-  previousPosition() {
-    const previous = this.tokens[this.position - 1];
-    return previous?.position ?? 0;
-  }
-};
-function describeToken(token) {
-  switch (token.kind) {
-    case "identifier":
-    case "number":
-    case "string":
-    case "boolean":
-    case "operator":
-    case "punctuation":
-      return `"${String(token.value)}"`;
-    case "null":
-      return '"null"';
-    default: {
-      const exhaustive = token;
-      return exhaustive;
-    }
-  }
-}
-function getOperatorPrecedence(operator) {
-  switch (operator) {
-    case "*":
-    case "/":
-      return 3;
-    case "+":
-    case "-":
-      return 2;
-    case ">":
-    case "<":
-    case ">=":
-    case "<=":
-    case "==":
-    case "!=":
-      return 1;
-    default: {
-      const exhaustive = operator;
-      return exhaustive;
-    }
-  }
-}
-
 // src/computed/compiler.ts
 var ComputedFormulaCompileError = class extends Error {
   constructor(message) {
@@ -5580,7 +5276,7 @@ function assertAcyclicComputedDependencies(nodes) {
 }
 function parseCompileFormula(expression) {
   try {
-    return parseComputedFormula(expression);
+    return chunkNSM2JPC3_js.parseComputedFormula(expression);
   } catch (error) {
     if (error instanceof Error) {
       throw new ComputedFormulaCompileError(error.message);
@@ -6511,11 +6207,11 @@ function evaluateComputedAst(node, input) {
   return evaluateAst(node, input);
 }
 function evaluateComputedFormula(expression, input) {
-  return evaluateAst(parseComputedFormula(expression), input);
+  return evaluateAst(chunkNSM2JPC3_js.parseComputedFormula(expression), input);
 }
 function evaluateComputedFormulaWithResult(expression, input, returnType, decimals) {
   try {
-    const raw = evaluateAst(parseComputedFormula(expression), input);
+    const raw = evaluateAst(chunkNSM2JPC3_js.parseComputedFormula(expression), input);
     const value = returnType ? formatComputedResult(raw, returnType, decimals) : raw;
     return { value };
   } catch (error) {
@@ -7007,9 +6703,17 @@ Object.defineProperty(exports, "indexBy", {
   enumerable: true,
   get: function () { return chunkFRCDMQER_js.indexBy; }
 });
+Object.defineProperty(exports, "ComputedFormulaParseError", {
+  enumerable: true,
+  get: function () { return chunkNSM2JPC3_js.ComputedFormulaParseError; }
+});
 Object.defineProperty(exports, "parseAttributeConfig", {
   enumerable: true,
-  get: function () { return chunkM5QIBMIH_js.parseAttributeConfig; }
+  get: function () { return chunkNSM2JPC3_js.parseAttributeConfig; }
+});
+Object.defineProperty(exports, "parseComputedFormula", {
+  enumerable: true,
+  get: function () { return chunkNSM2JPC3_js.parseComputedFormula; }
 });
 Object.defineProperty(exports, "AccessDeniedError", {
   enumerable: true,
@@ -7201,7 +6905,6 @@ exports.COMPUTED_FUNCTIONS = COMPUTED_FUNCTIONS;
 exports.COMPUTED_FUNCTION_METADATA = COMPUTED_FUNCTION_METADATA;
 exports.COMPUTED_FUNCTION_NAMES = COMPUTED_FUNCTION_NAMES;
 exports.ComputedFormulaCompileError = ComputedFormulaCompileError;
-exports.ComputedFormulaParseError = ComputedFormulaParseError;
 exports.CustomTabConfig = CustomTabConfig;
 exports.DB_COLUMN_FIELDS = DB_COLUMN_FIELDS;
 exports.DEFAULT_DOCUMENT_SLOT = DEFAULT_DOCUMENT_SLOT;
@@ -7340,7 +7043,6 @@ exports.normalizeForEdgeRpc = normalizeForEdgeRpc;
 exports.number = number;
 exports.numberFlag = numberFlag;
 exports.object = object;
-exports.parseComputedFormula = parseComputedFormula;
 exports.parseLiveChannelKey = parseLiveChannelKey;
 exports.parseLiveSubscribePayload = parseLiveSubscribePayload;
 exports.parseLiveUnsubscribePayload = parseLiveUnsubscribePayload;