@pactor-app/expression 0.1.0

package/dist/index.js

@@ -0,0 +1,575 @@
+// src/error.ts
+var ExpressionError = class extends Error {
+  constructor(message, pos) {
+    super(pos === void 0 ? message : `${message} (at position ${pos})`);
+    this.pos = pos;
+    this.name = "ExpressionError";
+  }
+};
+
+// src/tokenizer.ts
+var PUNCTUATORS = [
+  "===",
+  "!==",
+  "&&",
+  "||",
+  "==",
+  "!=",
+  "<=",
+  ">=",
+  "(",
+  ")",
+  ",",
+  ".",
+  "?",
+  ":",
+  "<",
+  ">",
+  "+",
+  "-",
+  "*",
+  "/",
+  "%",
+  "!",
+  "[",
+  "]",
+  "{",
+  "}"
+];
+var IDENTIFIER_START = /[A-Za-z_$]/;
+var IDENTIFIER_PART = /[A-Za-z0-9_$]/;
+var DIGIT = /[0-9]/;
+function tokenize(source) {
+  const tokens = [];
+  let i = 0;
+  while (i < source.length) {
+    const ch = source[i];
+    if (/\s/.test(ch)) {
+      i += 1;
+      continue;
+    }
+    if (DIGIT.test(ch)) {
+      const start = i;
+      while (i < source.length && DIGIT.test(source[i])) i += 1;
+      if (source[i] === ".") {
+        i += 1;
+        while (i < source.length && DIGIT.test(source[i])) i += 1;
+      }
+      tokens.push({ type: "number", value: source.slice(start, i), pos: start });
+      continue;
+    }
+    if (ch === "'" || ch === '"') {
+      const start = i;
+      const quote = ch;
+      i += 1;
+      let value = "";
+      let closed = false;
+      while (i < source.length) {
+        const c = source[i];
+        if (c === "\\") {
+          const next = source[i + 1];
+          if (next === void 0) break;
+          value += next === "n" ? "\n" : next === "t" ? "	" : next;
+          i += 2;
+          continue;
+        }
+        if (c === quote) {
+          closed = true;
+          i += 1;
+          break;
+        }
+        value += c;
+        i += 1;
+      }
+      if (!closed) {
+        throw new ExpressionError("unterminated string literal", start);
+      }
+      tokens.push({ type: "string", value, pos: start });
+      continue;
+    }
+    if (IDENTIFIER_START.test(ch)) {
+      const start = i;
+      while (i < source.length && IDENTIFIER_PART.test(source[i])) i += 1;
+      tokens.push({ type: "identifier", value: source.slice(start, i), pos: start });
+      continue;
+    }
+    const punct = PUNCTUATORS.find((p) => source.startsWith(p, i));
+    if (punct) {
+      tokens.push({ type: "punctuator", value: punct, pos: i });
+      i += punct.length;
+      continue;
+    }
+    throw new ExpressionError(`unexpected character "${ch}"`, i);
+  }
+  return tokens;
+}
+
+// src/parser.ts
+function parseExpression(source) {
+  const parser = new Parser(tokenize(source));
+  const node = parser.parseConditional();
+  parser.expectEnd();
+  return node;
+}
+var Parser = class {
+  constructor(tokens) {
+    this.tokens = tokens;
+    this.index = 0;
+  }
+  peek() {
+    return this.tokens[this.index];
+  }
+  next() {
+    const token = this.tokens[this.index];
+    if (!token) {
+      throw new ExpressionError("unexpected end of expression");
+    }
+    this.index += 1;
+    return token;
+  }
+  isPunctuator(value) {
+    const token = this.peek();
+    return token?.type === "punctuator" && token.value === value;
+  }
+  eatPunctuator(value) {
+    if (this.isPunctuator(value)) {
+      this.index += 1;
+      return true;
+    }
+    return false;
+  }
+  expectPunctuator(value) {
+    const token = this.peek();
+    if (!this.eatPunctuator(value)) {
+      throw new ExpressionError(`expected "${value}" but got "${token?.value ?? "end of expression"}"`, token?.pos);
+    }
+  }
+  expectEnd() {
+    const token = this.peek();
+    if (token) {
+      throw new ExpressionError(`unexpected token "${token.value}"`, token.pos);
+    }
+  }
+  parseConditional() {
+    const test = this.parseLogicalOr();
+    if (this.eatPunctuator("?")) {
+      const consequent = this.parseConditional();
+      this.expectPunctuator(":");
+      const alternate = this.parseConditional();
+      return { type: "ConditionalExpression", test, consequent, alternate };
+    }
+    return test;
+  }
+  parseLogicalOr() {
+    return this.parseBinaryChain(
+      () => this.parseLogicalAnd(),
+      ["||"],
+      "LogicalExpression"
+    );
+  }
+  parseLogicalAnd() {
+    return this.parseBinaryChain(
+      () => this.parseEquality(),
+      ["&&"],
+      "LogicalExpression"
+    );
+  }
+  parseEquality() {
+    return this.parseBinaryChain(
+      () => this.parseRelational(),
+      ["==", "!=", "===", "!=="],
+      "BinaryExpression"
+    );
+  }
+  parseRelational() {
+    return this.parseBinaryChain(
+      () => this.parseAdditive(),
+      ["<", "<=", ">", ">="],
+      "BinaryExpression"
+    );
+  }
+  parseAdditive() {
+    return this.parseBinaryChain(
+      () => this.parseMultiplicative(),
+      ["+", "-"],
+      "BinaryExpression"
+    );
+  }
+  parseMultiplicative() {
+    return this.parseBinaryChain(
+      () => this.parseUnary(),
+      ["*", "/", "%"],
+      "BinaryExpression"
+    );
+  }
+  parseBinaryChain(parseOperand, operators, kind) {
+    let left = parseOperand();
+    for (; ; ) {
+      const token = this.peek();
+      if (token?.type !== "punctuator" || !operators.includes(token.value)) {
+        return left;
+      }
+      this.next();
+      const right = parseOperand();
+      if (kind === "LogicalExpression") {
+        left = {
+          type: "LogicalExpression",
+          operator: token.value,
+          left,
+          right
+        };
+      } else {
+        left = {
+          type: "BinaryExpression",
+          operator: token.value,
+          left,
+          right
+        };
+      }
+    }
+  }
+  parseUnary() {
+    const token = this.peek();
+    if (token?.type === "punctuator" && (token.value === "!" || token.value === "-" || token.value === "+")) {
+      this.next();
+      return {
+        type: "UnaryExpression",
+        operator: token.value,
+        argument: this.parseUnary()
+      };
+    }
+    return this.parseMemberOrCall();
+  }
+  parseMemberOrCall() {
+    let node = this.parsePrimary();
+    for (; ; ) {
+      if (this.eatPunctuator(".")) {
+        const property = this.next();
+        if (property.type !== "identifier") {
+          throw new ExpressionError(
+            `expected property name after "." but got "${property.value}"`,
+            property.pos
+          );
+        }
+        node = {
+          type: "MemberExpression",
+          object: node,
+          property: { type: "Identifier", name: property.value },
+          computed: false
+        };
+        continue;
+      }
+      if (this.eatPunctuator("[")) {
+        const property = this.parseConditional();
+        this.expectPunctuator("]");
+        node = {
+          type: "MemberExpression",
+          object: node,
+          property,
+          computed: true
+        };
+        continue;
+      }
+      if (this.isPunctuator("(")) {
+        if (node.type !== "Identifier") {
+          throw new ExpressionError(
+            "member method calls are not allowed; only whitelisted functions can be called",
+            this.peek()?.pos
+          );
+        }
+        this.next();
+        const args = [];
+        if (!this.isPunctuator(")")) {
+          for (; ; ) {
+            args.push(this.parseConditional());
+            if (!this.eatPunctuator(",")) break;
+          }
+        }
+        this.expectPunctuator(")");
+        node = { type: "CallExpression", callee: node, arguments: args };
+        continue;
+      }
+      return node;
+    }
+  }
+  parsePrimary() {
+    const token = this.next();
+    if (token.type === "number") {
+      return { type: "Literal", value: Number(token.value) };
+    }
+    if (token.type === "string") {
+      return { type: "Literal", value: token.value };
+    }
+    if (token.type === "identifier") {
+      switch (token.value) {
+        case "true":
+          return { type: "Literal", value: true };
+        case "false":
+          return { type: "Literal", value: false };
+        case "null":
+          return { type: "Literal", value: null };
+        case "undefined":
+          return { type: "Literal", value: void 0 };
+        default:
+          return { type: "Identifier", name: token.value };
+      }
+    }
+    if (token.type === "punctuator" && token.value === "(") {
+      const node = this.parseConditional();
+      this.expectPunctuator(")");
+      return node;
+    }
+    if (token.type === "punctuator" && token.value === "{") {
+      const properties = [];
+      if (!this.isPunctuator("}")) {
+        for (; ; ) {
+          const keyToken = this.next();
+          if (keyToken.type !== "identifier" && keyToken.type !== "string") {
+            throw new ExpressionError(
+              `expected object key but got "${keyToken.value}"`,
+              keyToken.pos
+            );
+          }
+          this.expectPunctuator(":");
+          properties.push({
+            key: keyToken.value,
+            value: this.parseConditional()
+          });
+          if (!this.eatPunctuator(",")) break;
+        }
+      }
+      this.expectPunctuator("}");
+      return { type: "ObjectExpression", properties };
+    }
+    throw new ExpressionError(`unexpected token "${token.value}"`, token.pos);
+  }
+};
+
+// src/evaluator.ts
+import { Registry } from "@pactor-app/core";
+var FORBIDDEN_KEYS = /* @__PURE__ */ new Set(["__proto__", "prototype", "constructor"]);
+function isRecord(value) {
+  return typeof value === "object" && value !== null;
+}
+function readProperty(source, key) {
+  if (FORBIDDEN_KEYS.has(key)) {
+    return void 0;
+  }
+  if (Array.isArray(source)) {
+    if (key === "length") return source.length;
+    const index = Number(key);
+    if (Number.isInteger(index)) return source[index];
+    return void 0;
+  }
+  if (isRecord(source)) {
+    return Object.prototype.hasOwnProperty.call(source, key) ? source[key] : void 0;
+  }
+  return void 0;
+}
+function resolveFunction(name, scope, options) {
+  const { functions } = options;
+  let candidate;
+  if (functions instanceof Registry) {
+    candidate = functions.get(name);
+  } else if (functions) {
+    candidate = readProperty(functions, name);
+  }
+  if (typeof candidate !== "function") {
+    candidate = readProperty(scope, name);
+  }
+  if (typeof candidate !== "function") {
+    throw new ExpressionError(`function "${name}" is not registered`);
+  }
+  return candidate;
+}
+function evaluateNode(node, scope, options) {
+  switch (node.type) {
+    case "Literal":
+      return node.value;
+    case "Identifier":
+      return readProperty(scope, node.name);
+    case "MemberExpression": {
+      const object = evaluateNode(node.object, scope, options);
+      if (object === null || object === void 0) {
+        return void 0;
+      }
+      const property = node.computed ? evaluateNode(node.property, scope, options) : node.property.name;
+      if (typeof property !== "string" && typeof property !== "number") {
+        return void 0;
+      }
+      return readProperty(object, String(property));
+    }
+    case "UnaryExpression": {
+      const argument = evaluateNode(node.argument, scope, options);
+      switch (node.operator) {
+        case "!":
+          return !argument;
+        case "-":
+          return -argument;
+        case "+":
+          return +argument;
+      }
+      break;
+    }
+    case "BinaryExpression": {
+      const left = evaluateNode(node.left, scope, options);
+      const right = evaluateNode(node.right, scope, options);
+      switch (node.operator) {
+        case "==":
+          return left == right;
+        case "!=":
+          return left != right;
+        case "===":
+          return left === right;
+        case "!==":
+          return left !== right;
+        case "<":
+          return left < right;
+        case "<=":
+          return left <= right;
+        case ">":
+          return left > right;
+        case ">=":
+          return left >= right;
+        case "+":
+          return left + right;
+        case "-":
+          return left - right;
+        case "*":
+          return left * right;
+        case "/":
+          return left / right;
+        case "%":
+          return left % right;
+      }
+      break;
+    }
+    case "LogicalExpression":
+      if (node.operator === "&&") {
+        const left = evaluateNode(node.left, scope, options);
+        return left ? evaluateNode(node.right, scope, options) : left;
+      }
+      {
+        const left = evaluateNode(node.left, scope, options);
+        return left ? left : evaluateNode(node.right, scope, options);
+      }
+    case "ConditionalExpression":
+      return evaluateNode(node.test, scope, options) ? evaluateNode(node.consequent, scope, options) : evaluateNode(node.alternate, scope, options);
+    case "CallExpression": {
+      const fn = resolveFunction(node.callee.name, scope, options);
+      const args = node.arguments.map((arg) => evaluateNode(arg, scope, options));
+      return fn(...args);
+    }
+    case "ObjectExpression": {
+      const out = {};
+      for (const { key, value } of node.properties) {
+        if (FORBIDDEN_KEYS.has(key)) {
+          throw new ExpressionError(`object literal key "${key}" is not allowed`);
+        }
+        out[key] = evaluateNode(value, scope, options);
+      }
+      return out;
+    }
+  }
+}
+function evaluateExpression(source, scope = {}, options = {}) {
+  const node = typeof source === "string" ? parseExpression(source) : source;
+  return evaluateNode(node, scope, options);
+}
+
+// src/template.ts
+function hasExpression(value) {
+  return value.includes("${");
+}
+function splitTemplate(value) {
+  const segments = [];
+  let textStart = 0;
+  let i = 0;
+  while (i < value.length) {
+    if (value[i] === "$" && value[i + 1] === "{") {
+      if (i > textStart) {
+        segments.push({ kind: "text", text: value.slice(textStart, i) });
+      }
+      const exprPos = i;
+      i += 2;
+      let depth = 1;
+      let quote;
+      let source = "";
+      let closed = false;
+      while (i < value.length) {
+        const c = value[i];
+        if (quote !== void 0) {
+          if (c === "\\" && i + 1 < value.length) {
+            source += c + value[i + 1];
+            i += 2;
+            continue;
+          }
+          if (c === quote) {
+            quote = void 0;
+          }
+          source += c;
+          i += 1;
+          continue;
+        }
+        if (c === "'" || c === '"') {
+          quote = c;
+          source += c;
+          i += 1;
+          continue;
+        }
+        if (c === "{") {
+          depth += 1;
+          source += c;
+          i += 1;
+          continue;
+        }
+        if (c === "}") {
+          depth -= 1;
+          if (depth === 0) {
+            closed = true;
+            i += 1;
+            break;
+          }
+          source += c;
+          i += 1;
+          continue;
+        }
+        source += c;
+        i += 1;
+      }
+      if (!closed) {
+        throw new ExpressionError('unterminated "${" in template', exprPos);
+      }
+      segments.push({ kind: "expr", source, pos: exprPos });
+      textStart = i;
+      continue;
+    }
+    i += 1;
+  }
+  if (textStart < value.length) {
+    segments.push({ kind: "text", text: value.slice(textStart) });
+  }
+  return segments;
+}
+function stringify(value) {
+  return value === null || value === void 0 ? "" : String(value);
+}
+function resolveTemplate(value, scope = {}, options = {}) {
+  if (!hasExpression(value)) {
+    return value;
+  }
+  const segments = splitTemplate(value);
+  if (segments.length === 1 && segments[0].kind === "expr") {
+    return evaluateExpression(segments[0].source, scope, options);
+  }
+  return segments.map(
+    (segment) => segment.kind === "text" ? segment.text : stringify(evaluateExpression(segment.source, scope, options))
+  ).join("");
+}
+export {
+  ExpressionError,
+  evaluateExpression,
+  hasExpression,
+  parseExpression,
+  resolveTemplate
+};

package/package.json

@@ -0,0 +1,56 @@
+{
+  "name": "@pactor-app/expression",
+  "version": "0.1.0",
+  "description": "Pactor expression: controlled AST expression engine (no eval, no global access)",
+  "keywords": [
+    "pactor",
+    "dsl",
+    "server-driven-ui",
+    "expression",
+    "template",
+    "sandbox",
+    "parser"
+  ],
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/426-330/pactor.git",
+    "directory": "packages/expression"
+  },
+  "homepage": "https://github.com/426-330/pactor/tree/main/packages/expression",
+  "bugs": "https://github.com/426-330/pactor/issues",
+  "type": "module",
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": {
+        "types": "./dist/index.d.ts",
+        "default": "./dist/index.js"
+      },
+      "require": {
+        "types": "./dist/index.d.cts",
+        "default": "./dist/index.cjs"
+      }
+    }
+  },
+  "sideEffects": false,
+  "engines": {
+    "node": ">=18"
+  },
+  "files": [
+    "dist"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "@pactor-app/core": "0.1.0"
+  },
+  "scripts": {
+    "build": "tsup",
+    "test": "vitest run",
+    "typecheck": "tsc --noEmit"
+  }
+}