@reekon-tools/boldr-utils 1.4.13 → 1.4.15

package/dist/formulas/evaluateFormula.js

@@ -41,13 +41,60 @@ export function evaluateFormula({ expression, mappings, valueMap, unit, formulas
     if (scope) {
         try {
             const normalizedUnit = normalizeUnitForMathJS(unit);
-            const compiled = compile(expression);
-            const result = compiled.evaluate(scope);
-            const asUnit = mathUnit(result, normalizedUnit);
+            let compiled;
+            try {
+                compiled = compile(expression);
+            }
+            catch (compileErr) {
+                console.error(`Failed to compile formula expression`, compileErr);
+                return null;
+            }
+            let result;
+            try {
+                result = compiled.evaluate(scope);
+            }
+            catch (evalErr) {
+                // Handle divide by zero and other math errors
+                const errorMessage = evalErr instanceof Error ? evalErr.message : String(evalErr);
+                if (errorMessage.includes('divide') ||
+                    errorMessage.includes('division') ||
+                    errorMessage.includes('/') ||
+                    errorMessage.includes('Division by zero') ||
+                    errorMessage.includes('Cannot divide by zero')) {
+                    console.error(`Division by zero in formula`, evalErr);
+                    return null;
+                }
+                console.error(`Failed to evaluate formula`, evalErr);
+                return null;
+            }
+            // Check for invalid results (Infinity, NaN)
+            if (Number.isNaN(result)) {
+                console.error(`Formula result is NaN`);
+                return null;
+            }
+            if (!Number.isFinite(result)) {
+                console.error(`Formula result is Infinity`);
+                return null;
+            }
+            let asUnit;
+            try {
+                asUnit = mathUnit(result, normalizedUnit);
+            }
+            catch (unitErr) {
+                console.error(`Failed to convert result to unit`, unitErr);
+                return null;
+            }
             if (!asUnit.equalBase(mathUnit('1 um'))) {
-                throw new Error(`Incompatible unit: ${asUnit.formatUnits()} is not compatible with ${normalizedUnit}`);
+                console.error(`Incompatible unit: ${asUnit.formatUnits()} is not compatible with ${normalizedUnit}`);
+                return null;
             }
-            return Math.round(asUnit.toNumber('um'));
+            const finalResult = Math.round(asUnit.toNumber('um'));
+            // Check if final result is valid
+            if (!Number.isFinite(finalResult)) {
+                console.error(`Formula result is not a finite number`);
+                return null;
+            }
+            return finalResult;
         }
         catch (err) {
             console.error(`Failed to evaluate formula`, err);
@@ -95,23 +142,72 @@ export function evaluateFormula({ expression, mappings, valueMap, unit, formulas
                     }
                     // Recursively evaluate the referenced formula
                     const nestedResult = evaluateNestedFormula(referencedFormula.id, referencedFormula.expression, referencedFormula.variableToColumnMap);
-                    // Convert result to current unit
-                    const resultInUnit = mathUnit(nestedResult, 'um').toNumber(normalizedUnit);
+                    // Convert result to current unit with error handling
+                    let resultInUnit;
+                    try {
+                        resultInUnit = mathUnit(nestedResult, 'um').toNumber(normalizedUnit);
+                    }
+                    catch (unitErr) {
+                        throw new Error(`Failed to convert nested formula result to unit: ${unitErr instanceof Error ? unitErr.message : 'Unknown error'}`);
+                    }
                     scope[variable] = resultInUnit;
                 }
             }
-            // Evaluate the formula expression
-            const compiled = compile(currentExpression);
-            const result = compiled.evaluate(scope);
-            const asUnit = mathUnit(result, normalizedUnit);
+            // Evaluate the formula expression with error handling for math errors
+            let compiled;
+            try {
+                compiled = compile(currentExpression);
+            }
+            catch (compileErr) {
+                throw new Error(`Failed to compile formula expression: ${compileErr instanceof Error ? compileErr.message : 'Unknown error'}`);
+            }
+            let result;
+            try {
+                result = compiled.evaluate(scope);
+            }
+            catch (evalErr) {
+                // Handle divide by zero and other math errors
+                const errorMessage = evalErr instanceof Error ? evalErr.message : String(evalErr);
+                if (errorMessage.includes('divide') ||
+                    errorMessage.includes('division') ||
+                    errorMessage.includes('/') ||
+                    errorMessage.includes('Division by zero') ||
+                    errorMessage.includes('Cannot divide by zero')) {
+                    throw new Error(`Division by zero in formula: ${formulaId}`);
+                }
+                // Re-throw other evaluation errors
+                throw new Error(`Failed to evaluate formula: ${errorMessage}`);
+            }
+            // Check for invalid results (Infinity, NaN)
+            if (Number.isNaN(result)) {
+                throw new Error(`Formula result is NaN: ${formulaId}`);
+            }
+            if (!Number.isFinite(result)) {
+                throw new Error(`Formula result is Infinity: ${formulaId}`);
+            }
+            let asUnit;
+            try {
+                asUnit = mathUnit(result, normalizedUnit);
+            }
+            catch (unitErr) {
+                throw new Error(`Failed to convert result to unit: ${unitErr instanceof Error ? unitErr.message : 'Unknown error'}`);
+            }
             if (!asUnit.equalBase(mathUnit('1 um'))) {
                 throw new Error(`Incompatible unit: ${asUnit.formatUnits()} is not compatible with ${normalizedUnit}`);
             }
             const finalResult = Math.round(asUnit.toNumber('um'));
+            // Check if final result is valid
+            if (!Number.isFinite(finalResult)) {
+                throw new Error(`Formula result is not a finite number: ${formulaId}`);
+            }
             // Cache the result
             cache.set(cacheKey, finalResult);
             return finalResult;
         }
+        catch (err) {
+            // Re-throw the error so it can be caught by the outer try-catch
+            throw err;
+        }
         finally {
             evaluationStack.delete(formulaId);
         }

package/dist/types/layout.d.ts

@@ -32,24 +32,25 @@ export interface Face {
         measurementIds?: string[];
     };
 }
+export interface BackgroundImage {
+    id: string;
+    fileId: string;
+    opacity: number;
+    centerWorld: {
+        x: number;
+        y: number;
+    };
+    pixelSizeWorld: number;
+    widthPx: number;
+    heightPx: number;
+    rotationRad: number;
+}
 export interface Layout {
     id: string;
     name?: string;
     points: Record<string, Point>;
     edges: Record<string, Edge>;
     faces: Record<string, Face>;
-    backgroundImage?: {
-        fileId: string;
-        opacity: number;
-        centerWorld: {
-            x: number;
-            y: number;
-        };
-        pixelSizeWorld: number;
-        widthPx: number;
-        heightPx: number;
-        rotationRad: number;
-    };
     metadata?: {
         projectId?: string;
         jobId?: string;

package/dist/types/layout.js

@@ -1 +1,2 @@
 export {};
+// BackgroundImage is stored as a subcollection: layoutGroups/{groupId}/backgroundImages/{imageId}

package/package.json

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