@reekon-tools/boldr-utils 1.4.15 → 1.4.17

package/dist/formulas/evaluateFormula.js

@@ -1,5 +1,54 @@
 import { Units } from '../types/firestore.js';
-import { compile, unit as mathUnit } from 'mathjs';
+import { create, all } from 'mathjs';
+// Helper to convert degrees to radians
+const degToRad = (degrees) => (degrees * Math.PI) / 180;
+// 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
 const formulaCache = new Map();
 function normalizeUnitForMathJS(unit) {
@@ -120,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
@@ -127,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}"`);
@@ -141,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;
@@ -217,8 +292,14 @@ export function evaluateFormula({ expression, mappings, valueMap, unit, formulas
         return result;
     }
     catch (err) {
-        console.error('❌ Formula evaluation failed:', err);
-        return err instanceof Error ? err.message : 'Error';
+        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 errorMessage;
     }
 }
 // Legacy createFormulaScope function for backward compatibility

package/package.json

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