@reekon-tools/boldr-utils 1.3.7 → 1.3.8

package/dist/formulas/evaluateFormula.d.ts

@@ -1,11 +1,32 @@
 import { Units } from '../types/firestore.js';
+export interface EnhancedMapping {
+    id: string;
+    type?: 'measurement' | 'formula' | 'column';
+}
+export interface FormulaDefinition {
+    id: string;
+    name: string;
+    expression: string;
+    variableToColumnMap: Record<string, EnhancedMapping>;
+}
+export interface FormulaEvaluationOptions {
+    expression: string;
+    mappings: Record<string, EnhancedMapping | string>;
+    valueMap?: Record<string, number>;
+    unit: Units;
+    formulas?: FormulaDefinition[];
+    scope?: Record<string, number>;
+}
+export declare function evaluateFormula({ expression, mappings, valueMap, unit, formulas, scope, }: FormulaEvaluationOptions): number | string | null;
 export declare function createFormulaScope({ mappings, valueMap, unit, }: {
     mappings: Record<string, string>;
     valueMap: Record<string, number>;
     unit: Units;
 }): Record<string, number>;
-export declare function evaluateFormula({ expression, scope, unit, }: {
-    expression: string;
-    scope: Record<string, number>;
+export declare function createEnhancedFormulaScope({ mappings, valueMap, unit, formulas, }: {
+    mappings: Record<string, EnhancedMapping | string>;
+    valueMap: Record<string, number>;
     unit: Units;
-}): number | null;
+    formulas?: FormulaDefinition[];
+}): Record<string, number>;
+export declare function clearFormulaCache(): void;

package/dist/formulas/evaluateFormula.js

@@ -1,5 +1,7 @@
 import { Units } from '../types/firestore.js';
 import { compile, unit as mathUnit } from 'mathjs';
+// Cache for evaluated formulas to improve performance
+const formulaCache = new Map();
 function normalizeUnitForMathJS(unit) {
     switch (unit) {
         case Units.Centimeters:
@@ -23,6 +25,135 @@ function normalizeUnitForMathJS(unit) {
             return 'mm'; // fallback
     }
 }
+// Normalize mapping to EnhancedMapping format
+function normalizeMapping(mapping) {
+    if (typeof mapping === 'string') {
+        // Legacy format: just the ID
+        console.log('🔧 Converting legacy string mapping:', mapping);
+        return { id: mapping, type: 'measurement' };
+    }
+    // New format: ensure type defaults to 'measurement' and handle 'column' as 'measurement'
+    const normalizedType = mapping.type === 'column' ? 'measurement' : mapping.type || 'measurement';
+    console.log('🔧 Normalizing mapping:', mapping, '→', {
+        id: mapping.id,
+        type: normalizedType,
+    });
+    return { id: mapping.id, type: normalizedType };
+}
+// Unified formula evaluation function
+export function evaluateFormula({ expression, mappings, valueMap, unit, formulas = [], scope, }) {
+    // Legacy mode: if scope is provided, use it directly
+    if (scope) {
+        console.log('📜 Using legacy scope mode');
+        try {
+            const normalizedUnit = normalizeUnitForMathJS(unit);
+            const compiled = compile(expression);
+            const result = compiled.evaluate(scope);
+            const asUnit = mathUnit(result, normalizedUnit);
+            if (!asUnit.equalBase(mathUnit('1 um'))) {
+                throw new Error(`Incompatible unit: ${asUnit.formatUnits()} is not compatible with ${normalizedUnit}`);
+            }
+            return Math.round(asUnit.toNumber('um'));
+        }
+        catch (err) {
+            console.error(`Failed to evaluate formula`, err);
+            return null;
+        }
+    }
+    // Enhanced mode: use mappings and valueMap
+    if (!valueMap) {
+        console.error('❌ valueMap is required when not using scope');
+        return 'Error: valueMap is required';
+    }
+    const evaluationStack = new Set(); // For circular dependency detection
+    const cache = new Map(); // Local cache for this evaluation session
+    function evaluateNestedFormula(formulaId, currentExpression, currentMappings) {
+        console.log(`🔍 Evaluating nested formula: ${formulaId}`);
+        console.log(`📝 Expression: "${currentExpression}"`);
+        console.log('🗺️ Current mappings:', currentMappings);
+        // Check for circular dependency
+        if (evaluationStack.has(formulaId)) {
+            throw new Error(`Circular dependency detected involving formula: ${formulaId}`);
+        }
+        // Check cache first
+        const cacheKey = `${formulaId}_${unit}`;
+        if (cache.has(cacheKey)) {
+            console.log(`💾 Using cached result for ${formulaId}`);
+            return cache.get(cacheKey);
+        }
+        evaluationStack.add(formulaId);
+        try {
+            const scope = {};
+            const normalizedUnit = normalizeUnitForMathJS(unit);
+            console.log(`🔄 Converting to unit: ${unit} → ${normalizedUnit}`);
+            // Build scope by resolving each variable
+            for (const [variable, rawMapping] of Object.entries(currentMappings)) {
+                console.log(`\n🔧 Processing variable "${variable}":`, rawMapping);
+                const mapping = normalizeMapping(rawMapping);
+                console.log(`✅ Normalized mapping:`, mapping);
+                if (mapping.type === 'measurement') {
+                    // Handle measurement/column reference
+                    console.log(`📊 Looking up measurement ID "${mapping.id}" in valueMap`);
+                    const micrometers = valueMap[mapping.id] ?? 0;
+                    console.log(`📈 Found value: ${micrometers} micrometers`);
+                    if (micrometers === 0) {
+                        console.warn(`⚠️ Zero or missing value for mapping ID "${mapping.id}"`);
+                        console.log('🗂️ Available valueMap keys:', Object.keys(valueMap));
+                    }
+                    const valueInUnit = mathUnit(micrometers, 'um').toNumber(normalizedUnit);
+                    console.log(`🔢 Converted to ${normalizedUnit}: ${valueInUnit}`);
+                    scope[variable] = valueInUnit;
+                    console.log(`✅ Set scope["${variable}"] = ${valueInUnit}`);
+                }
+                else if (mapping.type === 'formula') {
+                    // Handle formula reference - recursively evaluate
+                    console.log(`🔄 Recursively evaluating formula "${mapping.id}"`);
+                    const referencedFormula = formulas.find((f) => f.id === mapping.id);
+                    if (!referencedFormula) {
+                        throw new Error(`Referenced formula not found: ${mapping.id}`);
+                    }
+                    // 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);
+                    console.log(`🔢 Nested formula result in ${normalizedUnit}: ${resultInUnit}`);
+                    scope[variable] = resultInUnit;
+                    console.log(`✅ Set scope["${variable}"] = ${resultInUnit} (from formula)`);
+                }
+            }
+            console.log('\n🎯 Final scope built:', scope);
+            // Evaluate the formula expression
+            console.log(`📊 Compiling expression: "${currentExpression}"`);
+            const compiled = compile(currentExpression);
+            console.log('🧮 Evaluating with scope:', scope);
+            const result = compiled.evaluate(scope);
+            console.log('📋 Raw evaluation result:', result, typeof result);
+            const asUnit = mathUnit(result, normalizedUnit);
+            console.log('📏 As unit object:', asUnit.toString());
+            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'));
+            console.log(`🎯 Final result: ${finalResult} micrometers`);
+            // Cache the result
+            cache.set(cacheKey, finalResult);
+            return finalResult;
+        }
+        finally {
+            evaluationStack.delete(formulaId);
+        }
+    }
+    try {
+        const result = evaluateNestedFormula('root', expression, mappings);
+        console.log(`🎉 Formula evaluation completed successfully: ${result}`);
+        return result;
+    }
+    catch (err) {
+        console.error('❌ Formula evaluation failed:', err);
+        return err instanceof Error ? err.message : 'Error';
+    }
+}
+// Legacy createFormulaScope function for backward compatibility
 export function createFormulaScope({ mappings, valueMap, unit, }) {
     const scope = {};
     const normalizedUnit = normalizeUnitForMathJS(unit);
@@ -34,19 +165,44 @@ export function createFormulaScope({ mappings, valueMap, unit, }) {
     }
     return scope;
 }
-export function evaluateFormula({ expression, scope, unit, }) {
-    try {
-        const normalizedUnit = normalizeUnitForMathJS(unit);
-        const compiled = compile(expression);
-        const result = compiled.evaluate(scope);
-        const asUnit = mathUnit(result, normalizedUnit);
-        if (!asUnit.equalBase(mathUnit('1 um'))) {
-            throw new Error(`Incompatible unit: ${asUnit.formatUnits()} is not compatible with ${normalizedUnit}`);
+// Enhanced createFormulaScope for new mapping structure
+export function createEnhancedFormulaScope({ mappings, valueMap, unit, formulas = [], }) {
+    const scope = {};
+    const normalizedUnit = normalizeUnitForMathJS(unit);
+    for (const [variable, rawMapping] of Object.entries(mappings)) {
+        const mapping = normalizeMapping(rawMapping);
+        if (mapping.type === 'measurement') {
+            const micrometers = valueMap[mapping.id] ?? 0;
+            const valueInUnit = mathUnit(micrometers, 'um').toNumber(normalizedUnit);
+            scope[variable] = valueInUnit;
+        }
+        else if (mapping.type === 'formula') {
+            // Find and evaluate the referenced formula
+            const referencedFormula = formulas.find((f) => f.id === mapping.id);
+            if (referencedFormula) {
+                const result = evaluateFormula({
+                    expression: referencedFormula.expression,
+                    mappings: referencedFormula.variableToColumnMap,
+                    valueMap,
+                    unit,
+                    formulas,
+                });
+                if (typeof result === 'number') {
+                    const valueInUnit = mathUnit(result, 'um').toNumber(normalizedUnit);
+                    scope[variable] = valueInUnit;
+                }
+                else {
+                    scope[variable] = 0; // Error case
+                }
+            }
+            else {
+                scope[variable] = 0; // Formula not found
+            }
         }
-        return Math.round(asUnit.toNumber('um'));
-    }
-    catch (err) {
-        console.error(`Failed to evaluate formula`, err);
-        return null;
     }
+    return scope;
+}
+// Utility function to clear formula cache
+export function clearFormulaCache() {
+    formulaCache.clear();
 }

package/dist/index.d.ts

@@ -1,4 +1,4 @@
-export { evaluateFormula, createFormulaScope, } from './formulas/evaluateFormula.js';
+export { evaluateFormula, createFormulaScope, createEnhancedFormulaScope, clearFormulaCache, type EnhancedMapping, type FormulaDefinition, type FormulaEvaluationOptions, } from './formulas/evaluateFormula.js';
 export { convertMicrometers } from './utils/micrometersToUnit.js';
 export { parseMeasurement } from './utils/parseMeasurement.js';
 export { useParseMeasurement } from './hooks/useParseMeasurement.js';

package/dist/index.js

@@ -1,4 +1,4 @@
-export { evaluateFormula, createFormulaScope, } from './formulas/evaluateFormula.js';
+export { evaluateFormula, createFormulaScope, createEnhancedFormulaScope, clearFormulaCache, } from './formulas/evaluateFormula.js';
 export { convertMicrometers } from './utils/micrometersToUnit.js';
 export { parseMeasurement } from './utils/parseMeasurement.js';
 export { useParseMeasurement } from './hooks/useParseMeasurement.js';

package/package.json

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