@shapeshift-labs/frontier-lang-parser 0.3.44 → 0.3.46

package/dist/action-body.js

@@ -1,4 +1,5 @@
 import { readFrontierNestedBlocks } from './source-syntax-report.js';
+import { readActionValue } from './action-expression.js';
 
 export function readActionBodyRecords(body) {
   const records = [];
@@ -27,7 +28,8 @@ function parseActionBodyRecords(source, state) {
       const close = findMatchingBrace(source, open);
       if (close < 0) break;
       const index = state.index++;
-      records.push(parseActionIfBlock(ifHeader[1].trim(), source.slice(open + 1, close), index, state));
+      const record = parseActionIfBlock(ifHeader[1].trim(), source.slice(open + 1, close), index, state);
+      if (record) records.push(record);
       offset = close + 1;
       continue;
     }
@@ -45,6 +47,7 @@ function parseActionBodyRecords(source, state) {
 
 function parseActionIfBlock(header, body, index, state) {
   const details = parseActionIfHeader(header, index);
+  if (!details.condition) return undefined;
   return compactRecord({
     kind: 'if',
     id: details.id,
@@ -74,22 +77,34 @@ function parseActionBodyLine(line, index) {
   const name = rawName && !rawName.startsWith('@') ? rawName : `${rowKind}_${index}`;
   const rest = rawName?.startsWith('@') ? ` ${rawName}${rawRest ?? ''}` : (rawRest ?? '');
   if (rowKind === 'set' || rowKind === 'insert' || rowKind === 'merge') {
-    return compactRecord({ kind: 'patch', op: rowKind, id: idFrom(rest, `action_body_${rowKind}_${name}`), name, path: readInlineWord('path', rest), value: readInlineActionValue('value', rest) });
+    const path = readInlineWord('path', rest);
+    const valueType = readInlineType(rest);
+    const value = readInlineActionValue('value', rest, { valueType });
+    if (!path || !value) return undefined;
+    return compactRecord({ kind: 'patch', op: rowKind, id: idFrom(rest, `action_body_${rowKind}_${name}`), name, path, valueType, value });
   }
   if (rowKind === 'remove') {
-    return compactRecord({ kind: 'patch', op: 'remove', id: idFrom(rest, `action_body_remove_${name}`), name, path: readInlineWord('path', rest) });
+    const path = readInlineWord('path', rest);
+    if (!path) return undefined;
+    return compactRecord({ kind: 'patch', op: 'remove', id: idFrom(rest, `action_body_remove_${name}`), name, path });
   }
   if (rowKind === 'callEffect') {
-    return compactRecord({ kind: 'callEffect', id: idFrom(rest, `action_body_callEffect_${name}`), name, capability: readInlineWord('capability', rest) ?? readInlineWord('effect', rest) ?? name, input: readInlineActionValue('input', rest) });
+    const inputText = readInlineValue('input', rest);
+    const input = inputText ? readActionValue(inputText) : undefined;
+    if (inputText && !input) return undefined;
+    return compactRecord({ kind: 'callEffect', id: idFrom(rest, `action_body_callEffect_${name}`), name, capability: readInlineWord('capability', rest) ?? readInlineWord('effect', rest) ?? name, input });
   }
   if (rowKind === 'let') {
-    const value = readInlineActionBindingValue('value', rest);
+    const valueType = readInlineType(rest);
+    const value = readInlineActionBindingValue('value', rest, { valueType });
     if (!rawName || rawName.startsWith('@') || !isActionBindingName(name) || !value) return undefined;
-    return compactRecord({ kind: 'let', id: idFrom(rest, `action_body_let_${name}`), name, value });
+    return compactRecord({ kind: 'let', id: idFrom(rest, `action_body_let_${name}`), name, valueType, value });
   }
   if (rowKind === 'return') {
-    const valueText = rawName?.startsWith('@') ? rest.trim() : `${rawName ?? ''}${rest ?? ''}`.trim();
-    return compactRecord({ kind: 'return', id: idFrom(rest, `action_body_return_${index}`), value: valueText ? readActionValue(valueText) : undefined });
+    const valueText = stripIds(rawName?.startsWith('@') ? rest : `${rawName ?? ''}${rest ?? ''}`).trim();
+    const value = valueText ? readActionValue(valueText) : undefined;
+    if (valueText && !value) return undefined;
+    return compactRecord({ kind: 'return', id: idFrom(rest, `action_body_return_${index}`), value });
   }
   return undefined;
 }
@@ -158,31 +173,14 @@ function findMatchingBrace(source, open) {
   return -1;
 }
 
-function readInlineActionValue(label, text) {
-  const value = new RegExp('(?:^|\\s)' + label + '\\s+(.+?)(?=\\s+[A-Za-z_$][\\w$-]*\\s+|$)').exec(text)?.[1]?.trim();
-  return value ? readActionValue(value) : undefined;
-}
-
-function readInlineActionBindingValue(label, text) {
-  const value = readInlineActionValue(label, text);
-  return isSupportedBindingValue(value) ? value : undefined;
-}
-
-function readActionValue(value) {
-  const text = value.trim();
-  const quoted = /^["']([^"']*)["']$/.exec(text);
-  if (quoted) return { value: quoted[1] };
-  if (text === 'true') return { value: true };
-  if (text === 'false') return { value: false };
-  if (text === 'null') return { value: null };
-  if (/^-?\d+(?:\.\d+)?$/.test(text)) return { value: Number(text) };
-  return { expression: text };
+function readInlineActionValue(label, text, options = {}) {
+  const value = readInlineValue(label, text);
+  return value ? readActionValue(value, options) : undefined;
 }
 
-function isSupportedBindingValue(value) {
-  if (!value) return false;
-  if (Object.prototype.hasOwnProperty.call(value, 'value')) return true;
-  return /^[A-Za-z_$][\w$-]*(?:\.[A-Za-z_$][\w$-]*)*$/.test(String(value.expression ?? '').trim());
+function readInlineActionBindingValue(label, text, options = {}) {
+  const value = readInlineActionValue(label, text, options);
+  return value ?? undefined;
 }
 
 function isActionBindingName(value) {
@@ -190,6 +188,9 @@ function isActionBindingName(value) {
 }
 
 function idFrom(header, fallback) { return /@id\(\s*["']([^"']+)["']\s*\)/.exec(header)?.[1] ?? fallback; }
+function readInlineType(text) { return readInlineWord('type', text) ?? readInlineWord('valueType', text); }
 function readInlineWord(label, text) { return new RegExp('(?:^|\\s)' + label + '\\s+([^\\s,]+)').exec(text)?.[1]?.trim(); }
+function readInlineValue(label, text) { return new RegExp('(?:^|\\s)' + label + '\\s+(.+?)(?=\\s+[A-Za-z_$][\\w$-]*\\s+|$)').exec(text)?.[1]?.trim(); }
+function stripIds(text) { return String(text ?? '').replace(/@id\(\s*["'][^"']+["']\s*\)/g, '').trim(); }
 function firstIdentifier(text) { return /^([A-Za-z_$][\w$-]*)\b/.exec(text)?.[1]; }
 function compactRecord(record) { return Object.fromEntries(Object.entries(record).filter(([, value]) => value !== undefined && (!Array.isArray(value) || value.length > 0))); }

package/dist/action-expression.js

@@ -0,0 +1,316 @@
+const IDENTIFIER = /^[A-Za-z_$][\w$-]*$/;
+const BLOCKED_REF_ROOTS = new Set(['globalThis', 'process', 'window', 'document', 'constructor', 'prototype', '__proto__', 'env']);
+const NUMERIC_OPERATORS = new Set(['+', '-', '*', '/', '%']);
+const NUMERIC_TYPES = new Set(['number', 'numeric', 'int', 'integer', 'float', 'double', 'decimal']);
+
+export function readActionValue(value, options = {}) {
+  const parsed = parseActionValue(value, options);
+  return parsed.ok ? parsed.value : undefined;
+}
+
+export function parseActionValue(value, options = {}) {
+  const text = String(value ?? '').trim();
+  if (!text) return fail('missing-action-expression');
+  const expression = parseActionExpression(text, options);
+  if (!expression.ok) return expression;
+  if (hasNumericOperator(expression.ast) && !isNumericType(options.valueType ?? options.type)) {
+    return fail((options.valueType ?? options.type) ? 'unsupported-action-expression-type' : 'missing-action-expression-type');
+  }
+  const valueType = options.valueType ?? options.type;
+  if (expression.literal) return { ok: true, value: compactRecord({ value: expression.ast.value, valueType }) };
+  return { ok: true, value: compactRecord({ expression: text, expressionAst: expression.ast, valueType }) };
+}
+
+export function parseActionExpression(value, options = {}) {
+  const text = String(value ?? '').trim();
+  if (!text) return fail('missing-action-expression');
+  const tokens = tokenizeActionExpression(text);
+  if (!tokens.ok) return tokens;
+  const parser = new ExpressionParser(tokens.tokens, options);
+  const ast = parser.parseExpression();
+  if (!parser.ok) return fail(parser.reason);
+  if (parser.peek().type !== 'eof') return fail(parser.reasonForTrailingToken());
+  return { ok: true, ast, literal: ast.kind === 'literal' };
+}
+
+export function isSupportedActionValue(value, options = {}) {
+  return parseActionValue(value, options).ok;
+}
+
+function tokenizeActionExpression(text) {
+  const tokens = [];
+  let index = 0;
+  while (index < text.length) {
+    const char = text[index];
+    if (/\s/.test(char)) {
+      index++;
+      continue;
+    }
+    if (char === '"' || char === "'") {
+      const read = readStringToken(text, index);
+      if (!read.ok) return read;
+      tokens.push(read.token);
+      index = read.next;
+      continue;
+    }
+    const canReadSignedNumber = char !== '-' || canStartSignedNumber(tokens);
+    const number = canReadSignedNumber ? /^-?\d+(?:\.\d+)?/.exec(text.slice(index)) : undefined;
+    if (number) {
+      tokens.push({ type: 'number', value: Number(number[0]), text: number[0], start: index, end: index + number[0].length });
+      index += number[0].length;
+      continue;
+    }
+    const identifier = /^[A-Za-z_$][\w$-]*/.exec(text.slice(index));
+    if (identifier) {
+      tokens.push({ type: 'identifier', text: identifier[0], start: index, end: index + identifier[0].length });
+      index += identifier[0].length;
+      continue;
+    }
+    const triple = text.slice(index, index + 3);
+    if (triple === '===' || triple === '!==') return fail('unsupported-action-expression-operator');
+    const double = text.slice(index, index + 2);
+    if (double === '&&' || double === '||' || double === '==' || double === '!=' || double === '>=' || double === '<=') {
+      tokens.push({ type: 'operator', text: double, start: index, end: index + 2 });
+      index += 2;
+      continue;
+    }
+    if (char === '!' || char === '>' || char === '<' || NUMERIC_OPERATORS.has(char)) {
+      tokens.push({ type: 'operator', text: char, start: index, end: index + 1 });
+      index++;
+      continue;
+    }
+    if (char === '(' || char === ')' || char === '.') {
+      tokens.push({ type: 'punctuation', text: char, start: index, end: index + 1 });
+      index++;
+      continue;
+    }
+    if ('=&|?:[]{}'.includes(char)) return fail('unsupported-action-expression-operator');
+    return fail('malformed-action-expression');
+  }
+  tokens.push({ type: 'eof', text: '', start: text.length, end: text.length });
+  return { ok: true, tokens };
+}
+
+function readStringToken(text, start) {
+  const quote = text[start];
+  let value = '';
+  let index = start + 1;
+  while (index < text.length) {
+    const char = text[index];
+    if (char === quote) {
+      return { ok: true, token: { type: 'string', value, text: text.slice(start, index + 1), start, end: index + 1 }, next: index + 1 };
+    }
+    if (char === '\\') {
+      const next = text[index + 1];
+      if (next === undefined) return fail('malformed-action-expression');
+      if (next === 'n') value += '\n';
+      else if (next === 'r') value += '\r';
+      else if (next === 't') value += '\t';
+      else if (next === '\\' || next === '"' || next === "'") value += next;
+      else return fail('malformed-action-expression');
+      index += 2;
+      continue;
+    }
+    value += char;
+    index++;
+  }
+  return fail('malformed-action-expression');
+}
+
+class ExpressionParser {
+  constructor(tokens, options) {
+    this.tokens = tokens;
+    this.options = options;
+    this.index = 0;
+    this.ok = true;
+    this.reason = undefined;
+  }
+
+  parseExpression() {
+    return this.parseLogicalOr();
+  }
+
+  parseLogicalOr() {
+    let left = this.parseLogicalAnd();
+    while (this.matchOperator('||')) left = { kind: 'logical', op: '||', left, right: this.parseLogicalAnd() };
+    return left;
+  }
+
+  parseLogicalAnd() {
+    let left = this.parseComparison();
+    while (this.matchOperator('&&')) left = { kind: 'logical', op: '&&', left, right: this.parseComparison() };
+    return left;
+  }
+
+  parseComparison() {
+    let left = this.parseAdditive();
+    const operator = this.peek();
+    if (operator.type === 'operator' && ['==', '!=', '>', '>=', '<', '<='].includes(operator.text)) {
+      this.index++;
+      left = { kind: 'binary', op: operator.text, left, right: this.parseAdditive() };
+      if (this.peek().type === 'operator' && ['==', '!=', '>', '>=', '<', '<='].includes(this.peek().text)) {
+        this.reject('malformed-action-expression');
+      }
+    }
+    return left;
+  }
+
+  parseAdditive() {
+    let left = this.parseMultiplicative();
+    while (this.peek().type === 'operator' && (this.peek().text === '+' || this.peek().text === '-')) {
+      const operator = this.peek().text;
+      this.index++;
+      left = { kind: 'binary', op: operator, left, right: this.parseMultiplicative() };
+    }
+    return left;
+  }
+
+  parseMultiplicative() {
+    let left = this.parseUnary();
+    while (this.peek().type === 'operator' && (this.peek().text === '*' || this.peek().text === '/' || this.peek().text === '%')) {
+      const operator = this.peek().text;
+      this.index++;
+      left = { kind: 'binary', op: operator, left, right: this.parseUnary() };
+    }
+    return left;
+  }
+
+  parseUnary() {
+    if (this.matchOperator('!')) return { kind: 'unary', op: '!', argument: this.parseUnary() };
+    return this.parsePrimary();
+  }
+
+  parsePrimary() {
+    const token = this.peek();
+    if (token.type === 'number') {
+      this.index++;
+      return { kind: 'literal', value: token.value };
+    }
+    if (token.type === 'string') {
+      this.index++;
+      return { kind: 'literal', value: token.value };
+    }
+    if (token.type === 'identifier') {
+      if (token.text === 'true' || token.text === 'false') {
+        this.index++;
+        return { kind: 'literal', value: token.text === 'true' };
+      }
+      if (token.text === 'null') {
+        this.index++;
+        return { kind: 'literal', value: null };
+      }
+      return this.parseRef();
+    }
+    if (token.type === 'punctuation' && token.text === '(') {
+      this.index++;
+      const expression = this.parseExpression();
+      if (!this.matchPunctuation(')')) this.reject('malformed-action-expression');
+      return expression;
+    }
+    this.reject('malformed-action-expression');
+    return { kind: 'literal', value: null };
+  }
+
+  parseRef() {
+    const parts = [];
+    const first = this.consumeIdentifier();
+    if (!first) return { kind: 'literal', value: null };
+    parts.push(first);
+    while (this.matchPunctuation('.')) {
+      const part = this.consumeIdentifier();
+      if (!part) {
+        this.reject('unsupported-action-expression-ref');
+        return refNode(parts);
+      }
+      parts.push(part);
+    }
+    if (this.peek().type === 'punctuation' && this.peek().text === '(') {
+      this.reject('unsupported-action-expression-ref');
+      return refNode(parts);
+    }
+    if (BLOCKED_REF_ROOTS.has(parts[0])) {
+      this.reject('unsupported-action-expression-ref');
+      return refNode(parts);
+    }
+    return refNode(parts);
+  }
+
+  consumeIdentifier() {
+    const token = this.peek();
+    if (token.type !== 'identifier' || !IDENTIFIER.test(token.text)) {
+      this.reject('unsupported-action-expression-ref');
+      return undefined;
+    }
+    this.index++;
+    return token.text;
+  }
+
+  matchOperator(operator) {
+    const token = this.peek();
+    if (token.type === 'operator' && token.text === operator) {
+      this.index++;
+      return true;
+    }
+    return false;
+  }
+
+  matchPunctuation(text) {
+    const token = this.peek();
+    if (token.type === 'punctuation' && token.text === text) {
+      this.index++;
+      return true;
+    }
+    return false;
+  }
+
+  peek() {
+    return this.tokens[this.index] ?? this.tokens[this.tokens.length - 1];
+  }
+
+  reject(reason) {
+    if (!this.ok) return;
+    this.ok = false;
+    this.reason = reason;
+  }
+
+  reasonForTrailingToken() {
+    const token = this.peek();
+    if (token.type === 'operator') return 'unsupported-action-expression-operator';
+    if (token.type === 'punctuation' && (token.text === '.' || token.text === '(' || token.text === '[')) return 'unsupported-action-expression-ref';
+    return 'malformed-action-expression';
+  }
+}
+
+function canStartSignedNumber(tokens) {
+  const previous = tokens[tokens.length - 1];
+  if (!previous) return true;
+  if (previous.type === 'operator') return true;
+  return previous.type === 'punctuation' && previous.text === '(';
+}
+
+function hasNumericOperator(node) {
+  if (!node || typeof node !== 'object') return false;
+  if (node.kind === 'binary') return NUMERIC_OPERATORS.has(node.op) || hasNumericOperator(node.left) || hasNumericOperator(node.right);
+  if (node.kind === 'logical') return hasNumericOperator(node.left) || hasNumericOperator(node.right);
+  if (node.kind === 'unary') return hasNumericOperator(node.argument);
+  return false;
+}
+
+function isNumericType(value) {
+  return NUMERIC_TYPES.has(String(value ?? '').trim().toLowerCase());
+}
+
+function refNode(parts) {
+  const [root, ...rest] = parts;
+  const scope = root === 'input' || root === 'state' || root === 'patches' ? root : 'local';
+  const path = scope === 'local' ? parts : rest;
+  return { kind: 'ref', name: parts.join('.'), scope, path };
+}
+
+function fail(reason) {
+  return { ok: false, reason };
+}
+
+function compactRecord(record) {
+  return Object.fromEntries(Object.entries(record).filter(([, value]) => value !== undefined && (!Array.isArray(value) || value.length > 0)));
+}

package/dist/action-syntax-children.js

@@ -1,3 +1,5 @@
+import { parseActionValue } from './action-expression.js';
+
 const ACTION_BODY_ROWS = new Set(['set', 'insert', 'remove', 'merge', 'callEffect', 'return', 'if', 'let']);
 
 export function readActionSyntaxChildren(source, block, options) {
@@ -56,7 +58,7 @@ function actionSyntaxChild(source, block, options, line, state, parentActionBody
   const rowKind = row?.[1] ?? 'unknown';
   const name = actionRowName(rowKind, row?.[2], rowIndex);
   const rest = row?.[2]?.startsWith('@') ? ` ${row[2]}${row[3] ?? ''}` : (row?.[3] ?? '');
-  const validation = validateActionRow(rowKind, row?.[2], rest);
+  const validation = validateActionRow(rowKind, row?.[2], rest, line.text);
   const recognized = ACTION_BODY_ROWS.has(rowKind) && validation.ok;
   return cleanRecord({
     kind: recognized ? 'actionBodyRow' : 'actionUnknownRow',
@@ -87,14 +89,34 @@ function actionRowName(rowKind, rawName, rowIndex) {
   return rawName && !rawName.startsWith('@') ? rawName : `${rowKind}_${rowIndex}`;
 }
 
-function validateActionRow(rowKind, rawName, rest) {
+function validateActionRow(rowKind, rawName, rest, header) {
   if (!ACTION_BODY_ROWS.has(rowKind)) return { ok: false, reason: 'unsupported-action-body-row' };
-  if (rowKind !== 'let') return { ok: true };
-  if (!rawName || rawName.startsWith('@') || !/^[A-Za-z_$][\w$-]*$/.test(rawName)) {
-    return { ok: false, reason: 'unsupported-action-binding-name' };
+  if (rowKind === 'if') return validateActionExpressionText(readIfCondition(header));
+  if (rowKind === 'set' || rowKind === 'insert' || rowKind === 'merge') {
+    if (!readInlineWord('path', rest)) return { ok: false, reason: 'missing-action-path' };
+    return validateActionExpressionText(readInlineValue('value', rest), { valueType: readInlineType(rest) });
+  }
+  if (rowKind === 'remove') {
+    return readInlineWord('path', rest) ? { ok: true } : { ok: false, reason: 'missing-action-path' };
+  }
+  if (rowKind === 'callEffect') {
+    const input = readInlineValue('input', rest);
+    return input ? validateActionExpressionText(input) : { ok: true };
+  }
+  if (rowKind === 'return') {
+    const value = readReturnValue(rawName, rest);
+    return value ? validateActionExpressionText(value) : { ok: true };
   }
-  const value = readInlineValue('value', rest);
-  if (!value || !isSupportedBindingValue(value)) {
+  if (rowKind === 'let') {
+    if (!rawName || rawName.startsWith('@') || !/^[A-Za-z_$][\w$-]*$/.test(rawName)) {
+      return { ok: false, reason: 'unsupported-action-binding-name' };
+    }
+    const value = readInlineValue('value', rest);
+    const parsed = value ? parseActionValue(value, { valueType: readInlineType(rest) }) : undefined;
+    if (parsed?.ok) return { ok: true };
+    if (parsed?.reason === 'missing-action-expression-type' || parsed?.reason === 'unsupported-action-expression-type') {
+      return { ok: false, reason: parsed.reason };
+    }
     return { ok: false, reason: 'unsupported-action-binding-value' };
   }
   return { ok: true };
@@ -104,10 +126,32 @@ function readInlineValue(label, text) {
   return new RegExp('(?:^|\\s)' + label + '\\s+(.+?)(?=\\s+[A-Za-z_$][\\w$-]*\\s+|$)').exec(text)?.[1]?.trim();
 }
 
-function isSupportedBindingValue(value) {
-  if (/^["'][^"']*["']$/.test(value)) return true;
-  if (/^(true|false|null|-?\d+(?:\.\d+)?)$/.test(value)) return true;
-  return /^[A-Za-z_$][\w$-]*(?:\.[A-Za-z_$][\w$-]*)*$/.test(value);
+function readInlineWord(label, text) {
+  return new RegExp('(?:^|\\s)' + label + '\\s+([^\\s,]+)').exec(text)?.[1]?.trim();
+}
+
+function readInlineType(text) {
+  return readInlineWord('type', text) ?? readInlineWord('valueType', text);
+}
+
+function readIfCondition(header) {
+  const text = header.replace(/^if\b/, '').replace(/\{\s*$/, '').replace(/@id\(\s*["'][^"']+["']\s*\)/g, '').trim();
+  const explicit = /\bcondition\s+(.+)$/.exec(text);
+  return explicit ? explicit[1].trim() : text;
+}
+
+function readReturnValue(rawName, rest) {
+  if (rawName?.startsWith('@')) return stripIds(`${rawName}${rest ?? ''}`).trim();
+  return stripIds(`${rawName ?? ''}${rest ?? ''}`).trim();
+}
+
+function stripIds(text) {
+  return String(text ?? '').replace(/@id\(\s*["'][^"']+["']\s*\)/g, '').trim();
+}
+
+function validateActionExpressionText(text, options = {}) {
+  const parsed = parseActionValue(text, options);
+  return parsed.ok ? { ok: true } : { ok: false, reason: parsed.reason };
 }
 
 function readNestedBodyBlocks(kind, source) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@shapeshift-labs/frontier-lang-parser",
-  "version": "0.3.44",
+  "version": "0.3.46",
   "description": "Parser for the first Frontier Lang .frontier syntax slice.",
   "type": "module",
   "main": "./dist/index.js",