@shapeshift-labs/frontier-lang-parser 0.3.47 → 0.3.48

package/dist/action-body.js

@@ -53,6 +53,7 @@ function parseActionIfBlock(header, body, index, state) {
     id: details.id,
     name: details.name,
     comparisonType: details.comparisonType,
+    callType: details.callType,
     condition: details.condition,
     body: parseActionBodyRecords(body, state)
   });
@@ -65,11 +66,13 @@ function parseActionIfHeader(header, index) {
   const name = firstIdentifier(nameText) ?? `if_${index}`;
   const conditionText = explicitCondition?.[1]?.trim() || withoutId;
   const comparisonType = readInlineComparisonType(header);
+  const callType = readInlineCallType(header);
   return {
     id: idFrom(header, `action_body_if_${name}`),
     name,
     comparisonType,
-    condition: conditionText ? readActionValue(conditionText, { comparisonType }) : undefined
+    callType,
+    condition: conditionText ? readActionValue(conditionText, { comparisonType, callType }) : undefined
   };
 }
 
@@ -83,9 +86,10 @@ function parseActionBodyLine(line, index) {
     const path = readInlineWord('path', rest);
     const valueType = readInlineType(rest);
     const comparisonType = readInlineComparisonType(rest);
-    const value = readInlineActionValue('value', rest, { valueType, comparisonType });
+    const callType = readInlineCallType(rest);
+    const value = readInlineActionValue('value', rest, { valueType, comparisonType, callType });
     if (!path || !value) return undefined;
-    return compactRecord({ kind: 'patch', op: rowKind, id: idFrom(rest, `action_body_${rowKind}_${name}`), name, path, valueType, comparisonType, value });
+    return compactRecord({ kind: 'patch', op: rowKind, id: idFrom(rest, `action_body_${rowKind}_${name}`), name, path, valueType, comparisonType, callType, value });
   }
   if (rowKind === 'remove') {
     const path = readInlineWord('path', rest);
@@ -101,9 +105,10 @@ function parseActionBodyLine(line, index) {
   if (rowKind === 'let') {
     const valueType = readInlineType(rest);
     const comparisonType = readInlineComparisonType(rest);
-    const value = readInlineActionBindingValue('value', rest, { valueType, comparisonType });
+    const callType = readInlineCallType(rest);
+    const value = readInlineActionBindingValue('value', rest, { valueType, comparisonType, callType });
     if (!rawName || rawName.startsWith('@') || !isActionBindingName(name) || !value) return undefined;
-    return compactRecord({ kind: 'let', id: idFrom(rest, `action_body_let_${name}`), name, valueType, comparisonType, value });
+    return compactRecord({ kind: 'let', id: idFrom(rest, `action_body_let_${name}`), name, valueType, comparisonType, callType, value });
   }
   if (rowKind === 'return') {
     const valueText = stripIds(rawName?.startsWith('@') ? rest : `${rawName ?? ''}${rest ?? ''}`).trim();
@@ -195,6 +200,7 @@ 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 readInlineComparisonType(text) { return readInlineWord('compare', text) ?? readInlineWord('comparisonType', text) ?? readInlineWord('compareType', text); }
+function readInlineCallType(text) { return readInlineWord('call', text) ?? readInlineWord('callType', 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(); }

package/dist/action-expression-semantics.js

@@ -2,6 +2,7 @@ export const NUMERIC_OPERATORS = new Set(['+', '-', '*', '/', '%']);
 
 const ORDERED_COMPARISON_OPERATORS = new Set(['>', '>=', '<', '<=']);
 const NUMERIC_TYPES = new Set(['number', 'numeric', 'int', 'integer', 'float', 'double', 'decimal']);
+const CALL_TYPES = new Set(['text', 'string', 'bool', 'boolean', 'number', 'numeric', 'int', 'integer', 'float', 'double', 'decimal', 'json']);
 
 export function hasNumericOperator(node) {
   if (!node || typeof node !== 'object') return false;
@@ -22,10 +23,22 @@ export function hasNonLiteralOrderedComparison(node) {
   return false;
 }
 
+export function hasCallExpression(node) {
+  if (!node || typeof node !== 'object') return false;
+  if (node.kind === 'call') return true;
+  if (node.kind === 'binary' || node.kind === 'logical') return hasCallExpression(node.left) || hasCallExpression(node.right);
+  if (node.kind === 'unary') return hasCallExpression(node.argument);
+  return false;
+}
+
 export function isNumericType(value) {
   return NUMERIC_TYPES.has(String(value ?? '').trim().toLowerCase());
 }
 
+export function isSupportedCallType(value) {
+  return CALL_TYPES.has(String(value ?? '').trim().toLowerCase());
+}
+
 function isLiteralNumericComparison(node) {
   return node.left?.kind === 'literal' && typeof node.left.value === 'number' && node.right?.kind === 'literal' && typeof node.right.value === 'number';
 }

package/dist/action-expression-tokenizer.js

@@ -0,0 +1,92 @@
+import { NUMERIC_OPERATORS } from './action-expression-semantics.js';
+
+export 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 === '.' || 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');
+}
+
+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 === '(' || previous.text === ',');
+}
+
+function fail(reason) {
+  return { ok: false, reason };
+}

package/dist/action-expression.js

@@ -1,7 +1,9 @@
-import { NUMERIC_OPERATORS, hasNonLiteralOrderedComparison, hasNumericOperator, isNumericType } from './action-expression-semantics.js';
+import { hasCallExpression, hasNonLiteralOrderedComparison, hasNumericOperator, isNumericType, isSupportedCallType } from './action-expression-semantics.js';
+import { tokenizeActionExpression } from './action-expression-tokenizer.js';
 
 const IDENTIFIER = /^[A-Za-z_$][\w$-]*$/;
 const BLOCKED_REF_ROOTS = new Set(['globalThis', 'process', 'window', 'document', 'constructor', 'prototype', '__proto__', 'env']);
+const BLOCKED_CALL_ROOTS = new Set([...BLOCKED_REF_ROOTS, 'input', 'state', 'patches']);
 
 export function readActionValue(value, options = {}) {
   const parsed = parseActionValue(value, options);
@@ -19,10 +21,15 @@ export function parseActionValue(value, options = {}) {
   if (hasNonLiteralOrderedComparison(expression.ast) && !isNumericType(options.comparisonType ?? options.compareType)) {
     return fail((options.comparisonType ?? options.compareType) ? 'unsupported-action-comparison-type' : 'missing-action-comparison-type');
   }
+  if (hasCallExpression(expression.ast) && !isSupportedCallType(options.callType ?? options.call ?? options.returns)) {
+    return fail((options.callType ?? options.call ?? options.returns) ? 'unsupported-action-call-type' : 'missing-action-call-type');
+  }
   const valueType = options.valueType ?? options.type;
   const comparisonType = options.comparisonType ?? options.compareType;
-  if (expression.literal) return { ok: true, value: compactRecord({ value: expression.ast.value, valueType, comparisonType }) };
-  return { ok: true, value: compactRecord({ expression: text, expressionAst: expression.ast, valueType, comparisonType }) };
+  const callType = options.callType ?? options.call ?? options.returns;
+  const ast = callType ? attachCallType(expression.ast, callType) : expression.ast;
+  if (expression.literal) return { ok: true, value: compactRecord({ value: ast.value, valueType, comparisonType, callType }) };
+  return { ok: true, value: compactRecord({ expression: text, expressionAst: ast, valueType, comparisonType, callType }) };
 }
 
 export function parseActionExpression(value, options = {}) {
@@ -41,86 +48,6 @@ 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;
@@ -220,6 +147,7 @@ class ExpressionParser {
     const first = this.consumeIdentifier();
     if (!first) return { kind: 'literal', value: null };
     parts.push(first);
+    if (this.peek().type === 'punctuation' && this.peek().text === '(') return this.parseCall(first);
     while (this.matchPunctuation('.')) {
       const part = this.consumeIdentifier();
       if (!part) {
@@ -229,7 +157,7 @@ class ExpressionParser {
       parts.push(part);
     }
     if (this.peek().type === 'punctuation' && this.peek().text === '(') {
-      this.reject('unsupported-action-expression-ref');
+      this.reject('unsupported-action-call-callee');
       return refNode(parts);
     }
     if (BLOCKED_REF_ROOTS.has(parts[0])) {
@@ -239,6 +167,31 @@ class ExpressionParser {
     return refNode(parts);
   }
 
+  parseCall(callee) {
+    if (!IDENTIFIER.test(callee) || BLOCKED_CALL_ROOTS.has(callee)) {
+      this.reject('unsupported-action-call-callee');
+      return { kind: 'call', callee, args: [] };
+    }
+    this.matchPunctuation('(');
+    const args = [];
+    if (this.matchPunctuation(')')) return compactRecord({ kind: 'call', callee, args, callType: this.options.callType ?? this.options.call ?? this.options.returns });
+    while (this.ok) {
+      const argument = this.parseExpression();
+      if (hasCallExpression(argument)) this.reject('unsupported-action-call-argument');
+      args.push(argument);
+      if (this.matchPunctuation(')')) break;
+      if (!this.matchPunctuation(',')) {
+        this.reject('malformed-action-expression');
+        break;
+      }
+      if (this.peek().type === 'punctuation' && this.peek().text === ')') {
+        this.reject('malformed-action-expression');
+        break;
+      }
+    }
+    return compactRecord({ kind: 'call', callee, args, callType: this.options.callType ?? this.options.call ?? this.options.returns });
+  }
+
   consumeIdentifier() {
     const token = this.peek();
     if (token.type !== 'identifier' || !IDENTIFIER.test(token.text)) {
@@ -285,13 +238,6 @@ class ExpressionParser {
   }
 }
 
-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 refNode(parts) {
   const [root, ...rest] = parts;
   const scope = root === 'input' || root === 'state' || root === 'patches' ? root : 'local';
@@ -303,6 +249,14 @@ function fail(reason) {
   return { ok: false, reason };
 }
 
+function attachCallType(node, callType) {
+  if (!node || typeof node !== 'object') return node;
+  if (node.kind === 'call') return compactRecord({ ...node, callType });
+  if (node.kind === 'binary' || node.kind === 'logical') return { ...node, left: attachCallType(node.left, callType), right: attachCallType(node.right, callType) };
+  if (node.kind === 'unary') return { ...node, argument: attachCallType(node.argument, callType) };
+  return node;
+}
+
 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

@@ -91,10 +91,10 @@ function actionRowName(rowKind, rawName, rowIndex) {
 
 function validateActionRow(rowKind, rawName, rest, header) {
   if (!ACTION_BODY_ROWS.has(rowKind)) return { ok: false, reason: 'unsupported-action-body-row' };
-  if (rowKind === 'if') return validateActionExpressionText(readIfCondition(header), { comparisonType: readInlineComparisonType(header) });
+  if (rowKind === 'if') return validateActionExpressionText(readIfCondition(header), { comparisonType: readInlineComparisonType(header), callType: readInlineCallType(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), comparisonType: readInlineComparisonType(rest) });
+    return validateActionExpressionText(readInlineValue('value', rest), { valueType: readInlineType(rest), comparisonType: readInlineComparisonType(rest), callType: readInlineCallType(rest) });
   }
   if (rowKind === 'remove') {
     return readInlineWord('path', rest) ? { ok: true } : { ok: false, reason: 'missing-action-path' };
@@ -112,9 +112,9 @@ function validateActionRow(rowKind, rawName, rest, header) {
       return { ok: false, reason: 'unsupported-action-binding-name' };
     }
     const value = readInlineValue('value', rest);
-    const parsed = value ? parseActionValue(value, { valueType: readInlineType(rest), comparisonType: readInlineComparisonType(rest) }) : undefined;
+    const parsed = value ? parseActionValue(value, { valueType: readInlineType(rest), comparisonType: readInlineComparisonType(rest), callType: readInlineCallType(rest) }) : undefined;
     if (parsed?.ok) return { ok: true };
-    if (parsed?.reason === 'missing-action-expression-type' || parsed?.reason === 'unsupported-action-expression-type' || parsed?.reason === 'missing-action-comparison-type' || parsed?.reason === 'unsupported-action-comparison-type') {
+    if (parsed?.reason === 'missing-action-expression-type' || parsed?.reason === 'unsupported-action-expression-type' || parsed?.reason === 'missing-action-comparison-type' || parsed?.reason === 'unsupported-action-comparison-type' || parsed?.reason === 'missing-action-call-type' || parsed?.reason === 'unsupported-action-call-type' || parsed?.reason === 'unsupported-action-call-callee' || parsed?.reason === 'unsupported-action-call-argument') {
       return { ok: false, reason: parsed.reason };
     }
     return { ok: false, reason: 'unsupported-action-binding-value' };
@@ -138,6 +138,10 @@ function readInlineComparisonType(text) {
   return readInlineWord('compare', text) ?? readInlineWord('comparisonType', text) ?? readInlineWord('compareType', text);
 }
 
+function readInlineCallType(text) {
+  return readInlineWord('call', text) ?? readInlineWord('callType', text);
+}
+
 function readIfCondition(header) {
   const text = header.replace(/^if\b/, '').replace(/\{\s*$/, '').replace(/@id\(\s*["'][^"']+["']\s*\)/g, '').trim();
   const explicit = /\bcondition\s+(.+)$/.exec(text);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@shapeshift-labs/frontier-lang-parser",
-  "version": "0.3.47",
+  "version": "0.3.48",
   "description": "Parser for the first Frontier Lang .frontier syntax slice.",
   "type": "module",
   "main": "./dist/index.js",
@@ -22,7 +22,7 @@
   ],
   "scripts": {
     "build": "node scripts/build.mjs",
-    "test": "npm run build && node test/smoke.mjs && node test/action-body-smoke.mjs && node test/target-projection-aggregate-smoke.mjs && node test/conversion-constraint-fields-smoke.mjs && node test/conversion-evidence-smoke.mjs && node test/package-canvas-surface-smoke.mjs && node test/view-render-graph-smoke.mjs && node test/resource-graph-smoke.mjs && node test/interlingua-smoke.mjs && node test/dialect-registry-smoke.mjs",
+    "test": "npm run build && node test/smoke.mjs && node test/action-body-smoke.mjs && node test/action-call-smoke.mjs && node test/target-projection-aggregate-smoke.mjs && node test/conversion-constraint-fields-smoke.mjs && node test/conversion-evidence-smoke.mjs && node test/package-canvas-surface-smoke.mjs && node test/view-render-graph-smoke.mjs && node test/resource-graph-smoke.mjs && node test/interlingua-smoke.mjs && node test/dialect-registry-smoke.mjs",
     "typecheck": "node ./node_modules/typescript/bin/tsc --noEmit -p test/tsconfig.json",
     "fuzz": "npm run build && node fuzz/smoke.mjs",
     "bench": "npm run build && node bench/smoke.mjs",