@reekon-tools/boldr-utils 1.4.17 → 1.4.18

package/dist/formulas/calculateFormula.js

@@ -102,6 +102,24 @@ 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,52 +1,8 @@
 import { Units } from '../types/firestore.js';
 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');
-}
+// Create a custom mathjs instance configured to use degrees instead of radians
+// @ts-ignore
+const math = create(all, { angle: 'deg' });
 const compile = math.compile.bind(math);
 const mathUnit = math.unit.bind(math);
 // Cache for evaluated formulas to improve performance
@@ -169,30 +125,6 @@ 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
@@ -200,7 +132,6 @@ 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}"`);
@@ -215,7 +146,6 @@ 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;
@@ -292,14 +222,8 @@ 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 errorMessage;
+        return err instanceof Error ? err.message : 'Error';
     }
 }
 // Legacy createFormulaScope function for backward compatibility

package/dist/types/firestore.d.ts

@@ -248,6 +248,29 @@ export interface Measurement extends FirestoreDoc, Timestamps, CreatedBy {
     type?: MeasurementType;
     note?: string;
 }
+export interface Label extends FirestoreDoc, Timestamps {
+    name: string;
+    projectId: string;
+    jobId: string;
+    rows: LabelRow[];
+    rowSizes: number[];
+    isPublic: boolean;
+}
+export interface LabelRow {
+    id: string;
+    cells: LabelCell[];
+    colSizes: number[];
+}
+export interface LabelCell {
+    id: string;
+    type: 'none' | 'image' | 'text' | 'qr' | 'company' | 'icon' | 'measurement';
+    fileId?: string;
+    value?: string;
+    groupId?: string;
+    columnId?: string;
+    index?: number;
+    columnType?: ColumnType;
+}
 export declare enum Units {
     Centimeters = "cm",
     Millimeters = "mm",

package/package.json

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