@reekon-tools/boldr-utils 1.4.16 → 1.4.17

package/dist/formulas/calculateFormula.js

@@ -102,24 +102,6 @@ export const calculateFormula = (formula, formulas, columns, tableConfig, measur
             currentMappings[variable] = mapping;
         }
     }
-    // Validate that all required inputs are filled out
-    const missingInputs = [];
-    for (const [variable, mapping] of Object.entries(currentMappings)) {
-        const mappingObj = typeof mapping === 'string'
-            ? { id: mapping, type: 'column' }
-            : mapping;
-        // Only check column references (formula references are handled separately)
-        if (mappingObj.type === 'column' || !mappingObj.type) {
-            const columnId = mappingObj.id;
-            if (!(columnId in valueMap)) {
-                missingInputs.push(variable);
-            }
-        }
-    }
-    if (missingInputs.length > 0) {
-        console.warn(`Not all inputs are filled out. Missing values for: ${missingInputs.join(', ')}`);
-        return null;
-    }
     const result = evaluateFormula({
         expression: formula.expression,
         mappings: currentMappings,

package/dist/formulas/evaluateFormula.js

@@ -1,19 +1,52 @@
 import { Units } from '../types/firestore.js';
 import { create, all } from 'mathjs';
-// Create a custom mathjs instance with degree-based trigonometric functions
-const math = create(all);
 // Helper to convert degrees to radians
 const degToRad = (degrees) => (degrees * Math.PI) / 180;
-// Import degree-based trigonometric functions
-math.import({
-    sin: (x) => Math.sin(degToRad(x)),
-    cos: (x) => Math.cos(degToRad(x)),
-    tan: (x) => Math.tan(degToRad(x)),
-    asin: (x) => (Math.asin(x) * 180) / Math.PI,
-    acos: (x) => (Math.acos(x) * 180) / Math.PI,
-    atan: (x) => (Math.atan(x) * 180) / Math.PI,
-    atan2: (y, x) => (Math.atan2(y, x) * 180) / Math.PI,
-}, { override: true });
+// Helper to convert radians to degrees
+const radToDeg = (radians) => (radians * 180) / Math.PI;
+// Create a custom mathjs instance with degree-based trigonometric functions
+const math = create(all);
+// Create degree-based trigonometric functions that accept degrees as input
+// and return results in degrees for inverse functions
+// These functions handle mathjs types by converting to numbers
+const degreeTrigFunctions = {
+    sin: (x) => {
+        const degrees = typeof x === 'number' ? x : Number(x);
+        return Math.sin(degToRad(degrees));
+    },
+    cos: (x) => {
+        const degrees = typeof x === 'number' ? x : Number(x);
+        return Math.cos(degToRad(degrees));
+    },
+    tan: (x) => {
+        const degrees = typeof x === 'number' ? x : Number(x);
+        return Math.tan(degToRad(degrees));
+    },
+    asin: (x) => {
+        const value = typeof x === 'number' ? x : Number(x);
+        return radToDeg(Math.asin(value));
+    },
+    acos: (x) => {
+        const value = typeof x === 'number' ? x : Number(x);
+        return radToDeg(Math.acos(value));
+    },
+    atan: (x) => {
+        const value = typeof x === 'number' ? x : Number(x);
+        return radToDeg(Math.atan(value));
+    },
+    atan2: (y, x) => {
+        const yVal = typeof y === 'number' ? y : Number(y);
+        const xVal = typeof x === 'number' ? x : Number(x);
+        return radToDeg(Math.atan2(yVal, xVal));
+    },
+};
+// Override the trigonometric functions in mathjs using import
+// The override: true option ensures existing functions are replaced
+math.import(degreeTrigFunctions, { override: true });
+// Verify the functions are overridden
+if (typeof math.sin !== 'function') {
+    console.warn('Warning: math.sin override may have failed');
+}
 const compile = math.compile.bind(math);
 const mathUnit = math.unit.bind(math);
 // Cache for evaluated formulas to improve performance
@@ -136,6 +169,30 @@ export function evaluateFormula({ expression, mappings, valueMap, unit, formulas
         }
         evaluationStack.add(formulaId);
         try {
+            // Validate that all required inputs are available before building scope
+            const missingInputs = [];
+            for (const [variable, rawMapping] of Object.entries(currentMappings)) {
+                const mapping = normalizeMapping(rawMapping);
+                if (mapping.type === 'measurement') {
+                    // Check if column reference exists in valueMap
+                    if (!(mapping.id in valueMap)) {
+                        missingInputs.push(variable);
+                    }
+                }
+                else if (mapping.type === 'formula') {
+                    // Check if formula reference exists
+                    const referencedFormula = formulas.find((f) => f.id === mapping.id);
+                    if (!referencedFormula) {
+                        missingInputs.push(variable);
+                    }
+                    // Note: We don't validate nested formula inputs here to avoid double evaluation
+                    // The nested formula will validate its own inputs when evaluated
+                }
+            }
+            // If any direct inputs are missing, throw an error
+            if (missingInputs.length > 0) {
+                throw new Error(`Missing required inputs for formula ${formulaId}: ${missingInputs.join(', ')}`);
+            }
             const scope = {};
             const normalizedUnit = normalizeUnitForMathJS(unit);
             // Build scope by resolving each variable
@@ -143,6 +200,7 @@ export function evaluateFormula({ expression, mappings, valueMap, unit, formulas
                 const mapping = normalizeMapping(rawMapping);
                 if (mapping.type === 'measurement') {
                     // Handle measurement/column reference
+                    // At this point we know it exists (validated above), but use ?? 0 as fallback
                     const micrometers = valueMap[mapping.id] ?? 0;
                     if (micrometers === 0) {
                         console.warn(`⚠️ Zero or missing value for mapping ID "${mapping.id}"`);
@@ -157,6 +215,7 @@ export function evaluateFormula({ expression, mappings, valueMap, unit, formulas
                         throw new Error(`Referenced formula not found: ${mapping.id}`);
                     }
                     // Recursively evaluate the referenced formula
+                    // If it has missing inputs, it will throw an error which we'll catch
                     const nestedResult = evaluateNestedFormula(referencedFormula.id, referencedFormula.expression, referencedFormula.variableToColumnMap);
                     // Convert result to current unit with error handling
                     let resultInUnit;
@@ -233,8 +292,14 @@ export function evaluateFormula({ expression, mappings, valueMap, unit, formulas
         return result;
     }
     catch (err) {
+        const errorMessage = err instanceof Error ? err.message : String(err);
+        // If the error is about missing inputs, return null to match the behavior in temp.ts
+        if (errorMessage.includes('Missing required inputs') || errorMessage.includes('missing')) {
+            console.warn('❌ Formula evaluation failed due to missing inputs:', errorMessage);
+            return null;
+        }
         console.warn('❌ Formula evaluation failed:', err);
-        return err instanceof Error ? err.message : 'Error';
+        return errorMessage;
     }
 }
 // Legacy createFormulaScope function for backward compatibility

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@reekon-tools/boldr-utils",
-  "version": "1.4.16",
+  "version": "1.4.17",
   "description": "Shared utilities for formulas and measurement conversion used in Reekon apps",
   "author": "REEKON Tools",
   "license": "MIT",