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

package/dist/action-body.js

@@ -78,9 +78,10 @@ function parseActionBodyLine(line, index) {
   const rest = rawName?.startsWith('@') ? ` ${rawName}${rawRest ?? ''}` : (rawRest ?? '');
   if (rowKind === 'set' || rowKind === 'insert' || rowKind === 'merge') {
     const path = readInlineWord('path', rest);
-    const value = readInlineActionValue('value', 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, value });
+    return compactRecord({ kind: 'patch', op: rowKind, id: idFrom(rest, `action_body_${rowKind}_${name}`), name, path, valueType, value });
   }
   if (rowKind === 'remove') {
     const path = readInlineWord('path', rest);
@@ -94,9 +95,10 @@ function parseActionBodyLine(line, index) {
     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 = stripIds(rawName?.startsWith('@') ? rest : `${rawName ?? ''}${rest ?? ''}`).trim();
@@ -171,13 +173,13 @@ function findMatchingBrace(source, open) {
   return -1;
 }
 
-function readInlineActionValue(label, text) {
+function readInlineActionValue(label, text, options = {}) {
   const value = readInlineValue(label, text);
-  return value ? readActionValue(value) : undefined;
+  return value ? readActionValue(value, options) : undefined;
 }
 
-function readInlineActionBindingValue(label, text) {
-  const value = readInlineActionValue(label, text);
+function readInlineActionBindingValue(label, text, options = {}) {
+  const value = readInlineActionValue(label, text, options);
   return value ?? undefined;
 }
 
@@ -186,6 +188,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 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.js

@@ -1,5 +1,7 @@
 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);
@@ -11,8 +13,12 @@ export function parseActionValue(value, options = {}) {
   if (!text) return fail('missing-action-expression');
   const expression = parseActionExpression(text, options);
   if (!expression.ok) return expression;
-  if (expression.literal) return { ok: true, value: { value: expression.ast.value } };
-  return { ok: true, value: { expression: text, expressionAst: expression.ast } };
+  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 = {}) {
@@ -47,7 +53,8 @@ function tokenizeActionExpression(text) {
       index = read.next;
       continue;
     }
-    const number = /^-?\d+(?:\.\d+)?/.exec(text.slice(index));
+    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;
@@ -67,7 +74,7 @@ function tokenizeActionExpression(text) {
       index += 2;
       continue;
     }
-    if (char === '!' || char === '>' || char === '<') {
+    if (char === '!' || char === '>' || char === '<' || NUMERIC_OPERATORS.has(char)) {
       tokens.push({ type: 'operator', text: char, start: index, end: index + 1 });
       index++;
       continue;
@@ -77,7 +84,7 @@ function tokenizeActionExpression(text) {
       index++;
       continue;
     }
-    if ('+-*/%=&|?:[]{}'.includes(char)) return fail('unsupported-action-expression-operator');
+    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 });
@@ -136,11 +143,11 @@ class ExpressionParser {
   }
 
   parseComparison() {
-    let left = this.parseUnary();
+    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.parseUnary() };
+      left = { kind: 'binary', op: operator.text, left, right: this.parseAdditive() };
       if (this.peek().type === 'operator' && ['==', '!=', '>', '>=', '<', '<='].includes(this.peek().text)) {
         this.reject('malformed-action-expression');
       }
@@ -148,6 +155,26 @@ class ExpressionParser {
     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();
@@ -254,6 +281,25 @@ 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 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';
@@ -264,3 +310,7 @@ function refNode(parts) {
 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

@@ -94,7 +94,7 @@ function validateActionRow(rowKind, rawName, rest, header) {
   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));
+    return validateActionExpressionText(readInlineValue('value', rest), { valueType: readInlineType(rest) });
   }
   if (rowKind === 'remove') {
     return readInlineWord('path', rest) ? { ok: true } : { ok: false, reason: 'missing-action-path' };
@@ -112,8 +112,12 @@ function validateActionRow(rowKind, rawName, rest, header) {
       return { ok: false, reason: 'unsupported-action-binding-name' };
     }
     const value = readInlineValue('value', rest);
-    const parsed = value ? parseActionValue(value) : undefined;
-    return parsed?.ok ? { ok: true } : { ok: false, reason: 'unsupported-action-binding-value' };
+    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 };
 }
@@ -126,6 +130,10 @@ 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);
@@ -141,8 +149,8 @@ function stripIds(text) {
   return String(text ?? '').replace(/@id\(\s*["'][^"']+["']\s*\)/g, '').trim();
 }
 
-function validateActionExpressionText(text) {
-  const parsed = parseActionValue(text);
+function validateActionExpressionText(text, options = {}) {
+  const parsed = parseActionValue(text, options);
   return parsed.ok ? { ok: true } : { ok: false, reason: parsed.reason };
 }
 

package/package.json

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