form0-core 0.1.4 → 0.1.6

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "form0-core",
-  "version": "0.1.4",
+  "version": "0.1.6",
   "publishConfig": {
     "registry": "https://registry.npmjs.org/"
   },

package/src/engine/calculation.js

@@ -9,7 +9,8 @@ export function evaluateCalculatedFields(
   helpers,
   securityConfig,
   contextResolver = null,
-  warningSystem = null
+  warningSystem = null,
+  runtimeDiagnostics = null
 ) {
   const fields = flattenFields(schema.elements);
 
@@ -40,10 +41,37 @@ export function evaluateCalculatedFields(
           context,
           securityConfig,
           false,
-          schema
+          schema,
+          {
+            suppressConsoleWarning: Array.isArray(runtimeDiagnostics),
+            onError: (error) => {
+              if (!Array.isArray(runtimeDiagnostics)) {
+                return;
+              }
+
+              runtimeDiagnostics.push({
+                fieldName: field.data_name,
+                message:
+                  error instanceof Error && error.message
+                    ? error.message
+                    : 'Unknown calculation runtime error.',
+              });
+            },
+          }
         );
       } catch (e) {
-        console.warn(`Calculation failed for ${field.data_name}:`, e.message);
+        if (Array.isArray(runtimeDiagnostics)) {
+          runtimeDiagnostics.push({
+            fieldName: field.data_name,
+            message:
+              e instanceof Error && e.message
+                ? e.message
+                : 'Unknown calculation runtime error.',
+          });
+        }
+        if (!Array.isArray(runtimeDiagnostics)) {
+          console.warn(`Calculation failed for ${field.data_name}:`, e.message);
+        }
       }
     }
   });

package/src/engine/context-resolver.js

@@ -93,7 +93,13 @@ export class ContextResolver {
 
     // Main form fields (no parent RepeatableSection) are always accessible
     if (fieldInfo.parentPath.length === 0) {
-      return this.buildAccessInfo('accessible', 'main_form', fieldName, fieldInfo, executionContext);
+      return this.buildAccessInfo(
+        'accessible',
+        'main_form',
+        fieldName,
+        fieldInfo,
+        executionContext
+      );
     }
 
     // RepeatableSection field access depends on execution context
@@ -246,7 +252,10 @@ export class ContextResolver {
    * @returns {boolean} True if they share the same RepeatableSection context
    */
   haveSameRepeatableSectionContext(parentPath1, parentPath2) {
-    return this.resolveRepeatableSectionAccessCode(parentPath1, parentPath2) !== 'different_repeatable_section';
+    return (
+      this.resolveRepeatableSectionAccessCode(parentPath1, parentPath2) !==
+      'different_repeatable_section'
+    );
   }
 
   resolveRepeatableSectionRelationship(
@@ -271,7 +280,10 @@ export class ContextResolver {
       return contextPath.length === 0 ? 'main_form' : 'same_repeatable_section';
     }
 
-    if (targetPath.length < contextPath.length && ContextResolver.isPrefix(targetPath, contextPath)) {
+    if (
+      targetPath.length < contextPath.length &&
+      ContextResolver.isPrefix(targetPath, contextPath)
+    ) {
       return targetPath.length === 0 ? 'main_form' : 'ancestor_repeatable_context';
     }
 
@@ -293,7 +305,12 @@ export class ContextResolver {
       level,
       code,
       message: `Field '${fieldName}' is not accessible from current context`,
-      suggestion: this.buildRestrictedAccessSuggestion(executionContext, fieldName, fieldInfo, code),
+      suggestion: this.buildRestrictedAccessSuggestion(
+        executionContext,
+        fieldName,
+        fieldInfo,
+        code
+      ),
       fieldInfo,
     };
   }
@@ -303,7 +320,7 @@ export class ContextResolver {
 
     if (contextType === 'calculation') {
       if (code === 'different_repeatable_section') {
-        return `CalculatedField can only access fields in the same RepeatableSection or ancestor contexts. Field '${fieldName}' is in RepeatableSection: ${fieldInfo.parentPath.join(' -> ')}`;
+        return `CalculatedField can only access fields in the same RepeatableSection or ancestor contexts. Field '${fieldName}' is in RepeatableSection: ${this.formatRepeatableSectionPath(fieldInfo.parentPath)}`;
       }
     }
 
@@ -322,6 +339,33 @@ export class ContextResolver {
     return 'Check the field access rules for your current context';
   }
 
+  formatRepeatableSectionPath(parentPath) {
+    if (!Array.isArray(parentPath) || parentPath.length === 0) {
+      return 'main form';
+    }
+
+    return parentPath
+      .map((_, index) => this.formatRepeatableSectionSegment(parentPath.slice(0, index + 1)))
+      .join(' -> ');
+  }
+
+  formatRepeatableSectionSegment(currentPath) {
+    for (const treeInfo of this.repeatableSectionTree.values()) {
+      if (!ContextResolver.pathsEqual(treeInfo.currentPath, currentPath)) {
+        continue;
+      }
+
+      const dataName = treeInfo.field?.data_name || treeInfo.preferredKey;
+      if (dataName === treeInfo.preferredKey) {
+        return dataName;
+      }
+
+      return `${dataName} (${treeInfo.preferredKey})`;
+    }
+
+    return currentPath[currentPath.length - 1];
+  }
+
   static isPrefix(prefix, fullPath) {
     if (prefix.length === 0) {
       return true;
@@ -381,7 +425,8 @@ export class ContextResolver {
           ? `Field '${fieldName}' does not exist in the form schema`
           : `Field '${fieldName}' is not accessible from current context`),
       suggestion:
-        accessInfo.suggestion || this.generateAccessSuggestion(executionContext, fieldName, fieldInfo),
+        accessInfo.suggestion ||
+        this.generateAccessSuggestion(executionContext, fieldName, fieldInfo),
       fieldContext: fieldInfo
         ? {
             parentPath: fieldInfo.parentPath,

package/src/engine/evaluator.js

@@ -3,19 +3,26 @@ import { __setEvalContext, __clearEvalContext } from '../builtins/control/eval.j
 import { __setDataNamesContext, __clearDataNamesContext } from '../builtins/schema/datanames.js';
 import { validateExpression, createSecureContext, withTimeout } from '../security/validation.js';
 import { DEFAULT_SECURITY_CONFIG } from '../security/config.js';
+import {
+  isMultilineCalculationExpression,
+  normalizeInlineCalculationExpression,
+} from '../utilities/calculation-expression-utils.js';
 
 export function runExpression(
   expr,
   context = {},
   securityConfig = DEFAULT_SECURITY_CONFIG,
   includeEventBuiltins = false,
-  schema = null
+  schema = null,
+  options = {}
 ) {
   try {
     // Validate expression based on security mode
     const validation = validateExpression(expr, securityConfig, includeEventBuiltins);
     if (!validation.valid) {
-      console.warn('[form0] Expression validation failed:', validation.reason);
+      if (!options.suppressConsoleWarning) {
+        console.warn('[form0] Expression validation failed:', validation.reason);
+      }
       return null;
     }
 
@@ -34,8 +41,7 @@ export function runExpression(
 
       try {
         // Handle both expressions and multi-line code (Windows-safe)
-        const isMultiLine =
-          expr.includes('\r\n') || expr.includes('\n') || expr.includes('function');
+        const isMultiLine = isMultilineCalculationExpression(expr);
 
         if (isMultiLine) {
           // Execute as code block (recompile each time for now)
@@ -46,7 +52,8 @@ export function runExpression(
           return consumed.called ? consumed.value : result;
         } else {
           // Execute as expression (existing behavior)
-          const fn = new Function(...keys, `return (${expr});`);
+          const inlineExpression = normalizeInlineCalculationExpression(expr);
+          const fn = new Function(...keys, `return (${inlineExpression});`);
           const result = fn(...values);
           const consumed = __consumeResult();
           return consumed.called ? consumed.value : result;
@@ -69,7 +76,12 @@ export function runExpression(
 
     return executeExpression();
   } catch (e) {
-    console.warn('[form0] Expression evaluation failed:', e.message);
+    if (typeof options.onError === 'function') {
+      options.onError(e);
+    }
+    if (!options.suppressConsoleWarning) {
+      console.warn('[form0] Expression evaluation failed:', e.message);
+    }
     return null;
   }
 }

package/src/engine/form-engine.js

@@ -19,6 +19,7 @@ export function createFormEngine({
   helpers = {},
   security = DEFAULT_SECURITY_CONFIG,
   warningSystem = null,
+  runtimeDiagnostics = null,
 }) {
   const { schema: preparedSchema, buildingPlanMeta } = expandBuildingPlanSchema(schema);
 
@@ -126,7 +127,8 @@ export function createFormEngine({
       allHelpers,
       security,
       contextResolver,
-      sharedWarningSystem
+      sharedWarningSystem,
+      runtimeDiagnostics
     );
     evaluateRequirement(form, values, required);
     evaluateVisibility(form, values, visible);

package/src/index.js

@@ -35,6 +35,7 @@ export {
   getCalculationBuiltinCatalog,
   getCalculationReferenceCatalog,
   analyzeCalculationExpression,
+  simulateCalculationExpression,
 } from './utilities/calculation-editor.js';
 export {
   getFormAIMetadata,

package/src/utilities/calculation-editor.js

@@ -4,8 +4,14 @@ import {
   CALCULATION_BUILTIN_DEFINITIONS,
 } from '../builtins/registry.js';
 import { ContextResolver } from '../engine/context-resolver.js';
+import { createFormEngine } from '../engine/form-engine.js';
+import { WarningSystem } from '../engine/warning-system.js';
 import { DEFAULT_SECURITY_CONFIG } from '../security/config.js';
 import { validateExpression } from '../security/validation.js';
+import {
+  isMultilineCalculationExpression,
+  normalizeInlineCalculationExpression,
+} from './calculation-expression-utils.js';
 import { flattenFields } from './field-helpers.js';
 
 const COMMON_GLOBAL_FUNCTIONS = new Set([
@@ -181,9 +187,7 @@ function toCalculationReferenceDefinition(field, resolver, executionContext) {
     type: typeof field.type === 'string' ? field.type : 'UnknownField',
     description: typeof field.description === 'string' ? field.description : null,
     displayStyle:
-      field.display &&
-      typeof field.display === 'object' &&
-      typeof field.display.style === 'string'
+      field.display && typeof field.display === 'object' && typeof field.display.style === 'string'
         ? field.display.style
         : typeof field.display === 'string'
           ? field.display
@@ -214,15 +218,15 @@ function addIssue(issues, issueKeys, issue) {
 }
 
 function validateSyntax(expression) {
-  const isMultiLine =
-    expression.includes('\r\n') || expression.includes('\n') || expression.includes('function');
+  const isMultiLine = isMultilineCalculationExpression(expression);
 
   if (isMultiLine) {
     new Function(expression);
     return;
   }
 
-  new Function(`return (${expression});`);
+  const inlineExpression = normalizeInlineCalculationExpression(expression);
+  new Function(`return (${inlineExpression});`);
 }
 
 function createSchemaFilteredSecurityConfig(securityConfig) {
@@ -236,6 +240,62 @@ function createSchemaFilteredSecurityConfig(securityConfig) {
   };
 }
 
+function deepClone(value) {
+  if (typeof structuredClone === 'function') {
+    return structuredClone(value);
+  }
+
+  return JSON.parse(JSON.stringify(value));
+}
+
+function cloneSimulationSchema(schema) {
+  if (schema && schema.form && Array.isArray(schema.form.elements)) {
+    return deepClone(schema);
+  }
+
+  return {
+    form: deepClone(normalizeFormSchema(schema)),
+  };
+}
+
+function findFieldByDataName(elements, fieldDataName) {
+  if (!Array.isArray(elements)) {
+    return null;
+  }
+
+  for (const element of elements) {
+    if (!element || typeof element !== 'object') {
+      continue;
+    }
+
+    if (element.data_name === fieldDataName) {
+      return element;
+    }
+
+    if (Array.isArray(element.elements)) {
+      const nestedMatch = findFieldByDataName(element.elements, fieldDataName);
+      if (nestedMatch) {
+        return nestedMatch;
+      }
+    }
+  }
+
+  return null;
+}
+
+function sanitizeCollectedWarnings(warnings) {
+  if (!Array.isArray(warnings)) {
+    return [];
+  }
+
+  return warnings.map((warning) => ({
+    message: warning?.message || '',
+    suggestion: warning?.suggestion || null,
+    context: warning?.context || null,
+    fieldContext: warning?.fieldContext || null,
+  }));
+}
+
 /**
  * @typedef {'stable' | 'advanced' | 'unavailable'} CalculationBuiltinStatus
  *
@@ -341,6 +401,7 @@ export function analyzeCalculationExpression({
   const usedBuiltinNames = new Set();
   const referencedFields = [];
   const referencedFieldNames = new Set();
+  const setResultCalls = [];
 
   const normalizedExpression = typeof expression === 'string' ? expression : '';
   const form = normalizeFormSchema(schema);
@@ -437,6 +498,10 @@ export function analyzeCalculationExpression({
         usedBuiltins.push(call.name);
       }
 
+      if (call.name === 'SETRESULT') {
+        setResultCalls.push(call);
+      }
+
       if (builtinMetadata.status === 'unavailable') {
         addIssue(
           issues,
@@ -482,6 +547,22 @@ export function analyzeCalculationExpression({
     );
   }
 
+  if (setResultCalls.length > 1) {
+    const duplicateSetResultCall = setResultCalls[1];
+    addIssue(
+      issues,
+      issueKeys,
+      createIssue({
+        code: 'multiple_setresult_calls',
+        severity: 'error',
+        message: 'SETRESULT() can only be used once in a CalculatedField expression.',
+        symbol: duplicateSetResultCall.name,
+        index: duplicateSetResultCall.index,
+        length: duplicateSetResultCall.length,
+      })
+    );
+  }
+
   for (const reference of extractFieldReferenceMatches(normalizedExpression)) {
     if (!referencedFieldNames.has(reference.fieldName)) {
       referencedFieldNames.add(reference.fieldName);
@@ -532,3 +613,94 @@ export function analyzeCalculationExpression({
     referencedFields,
   };
 }
+
+/**
+ * Simulate a CalculatedField expression against form0-core's real evaluation engine.
+ *
+ * @param {Object} options
+ * @param {Object} options.schema
+ * @param {string} options.fieldDataName
+ * @param {string} options.expression
+ * @param {Object} [options.values]
+ * @param {Object} [options.security]
+ * @returns {{
+ *   result: unknown,
+ *   runtimeError: string | null,
+ *   warnings: Array<{
+ *     message: string,
+ *     suggestion: string | null,
+ *     context: Object | null,
+ *     fieldContext: Object | null,
+ *   }>,
+ * }}
+ */
+export function simulateCalculationExpression({
+  schema,
+  fieldDataName,
+  expression,
+  values = {},
+  security = DEFAULT_SECURITY_CONFIG,
+}) {
+  const simulationSchema = cloneSimulationSchema(schema);
+  const form = normalizeFormSchema(simulationSchema);
+  const targetField = findFieldByDataName(form.elements, fieldDataName);
+
+  if (!targetField) {
+    return {
+      result: null,
+      runtimeError: `Field '${fieldDataName}' does not exist in the form schema.`,
+      warnings: [],
+    };
+  }
+
+  if (targetField.type !== 'CalculatedField') {
+    return {
+      result: null,
+      runtimeError: `Field '${fieldDataName}' is not a CalculatedField.`,
+      warnings: [],
+    };
+  }
+
+  targetField.calculate = typeof expression === 'string' ? expression : '';
+
+  const warningSystem = new WarningSystem({
+    enableCollection: true,
+    enableConsoleWarnings: false,
+  });
+  const runtimeDiagnostics = [];
+
+  try {
+    const engine = createFormEngine({
+      schema: simulationSchema,
+      initialValues:
+        values && typeof values === 'object' && !Array.isArray(values) ? values : {},
+      security,
+      warningSystem,
+      runtimeDiagnostics,
+    });
+
+    engine.eval();
+
+    const engineState = engine.getState();
+    const simulatedResult = engineState.values[fieldDataName];
+    const runtimeError =
+      runtimeDiagnostics.find((diagnostic) => diagnostic.fieldName === fieldDataName)?.message ||
+      runtimeDiagnostics[0]?.message ||
+      null;
+
+    return {
+      result: simulatedResult === undefined ? null : simulatedResult,
+      runtimeError,
+      warnings: sanitizeCollectedWarnings(warningSystem.getCollectedWarnings()),
+    };
+  } catch (error) {
+    return {
+      result: null,
+      runtimeError:
+        error instanceof Error && error.message
+          ? error.message
+          : 'Unknown calculation simulation error.',
+      warnings: sanitizeCollectedWarnings(warningSystem.getCollectedWarnings()),
+    };
+  }
+}

package/src/utilities/calculation-expression-utils.js

@@ -0,0 +1,15 @@
+export function isMultilineCalculationExpression(expression) {
+  const normalizedExpression = typeof expression === 'string' ? expression : '';
+
+  return (
+    normalizedExpression.includes('\r\n') ||
+    normalizedExpression.includes('\n') ||
+    normalizedExpression.includes('function')
+  );
+}
+
+export function normalizeInlineCalculationExpression(expression) {
+  const normalizedExpression = typeof expression === 'string' ? expression : '';
+
+  return normalizedExpression.replace(/;+\s*$/u, '');
+}