@reekon-tools/boldr-utils 1.4.12 → 1.4.14

package/dist/formulas/evaluateFormula.js

@@ -29,16 +29,22 @@ function normalizeUnitForMathJS(unit) {
 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);
@@ -62,6 +68,9 @@ export function evaluateFormula({ expression, mappings, valueMap, unit, formulas
     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}`);
@@ -69,26 +78,36 @@ export function evaluateFormula({ expression, mappings, valueMap, unit, formulas
         // 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 = micrometers;
+                    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}`);
@@ -97,17 +116,25 @@ export function evaluateFormula({ expression, mappings, valueMap, unit, formulas
                     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;
@@ -118,6 +145,7 @@ export function evaluateFormula({ expression, mappings, valueMap, unit, formulas
     }
     try {
         const result = evaluateNestedFormula('root', expression, mappings);
+        console.log(`🎉 Formula evaluation completed successfully: ${result}`);
         return result;
     }
     catch (err) {
@@ -128,20 +156,25 @@ export function evaluateFormula({ expression, mappings, valueMap, unit, formulas
 // Legacy createFormulaScope function for backward compatibility
 export function createFormulaScope({ mappings, valueMap, unit, }) {
     const scope = {};
+    const normalizedUnit = normalizeUnitForMathJS(unit);
     for (const [variable, columnId] of Object.entries(mappings)) {
         const micrometers = valueMap[columnId] ?? 0;
-        scope[variable] = micrometers;
+        // Convert using math.js directly
+        const valueInUnit = mathUnit(micrometers, 'um').toNumber(normalizedUnit);
+        scope[variable] = valueInUnit;
     }
     return scope;
 }
 // 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;
-            scope[variable] = micrometers;
+            const valueInUnit = mathUnit(micrometers, 'um').toNumber(normalizedUnit);
+            scope[variable] = valueInUnit;
         }
         else if (mapping.type === 'formula') {
             // Find and evaluate the referenced formula
@@ -155,7 +188,8 @@ export function createEnhancedFormulaScope({ mappings, valueMap, unit, formulas
                     formulas,
                 });
                 if (typeof result === 'number') {
-                    scope[variable] = result;
+                    const valueInUnit = mathUnit(result, 'um').toNumber(normalizedUnit);
+                    scope[variable] = valueInUnit;
                 }
                 else {
                     scope[variable] = 0; // Error case

package/dist/index.d.ts

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

package/dist/index.js

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

package/dist/types/firestore.d.ts

@@ -5,11 +5,9 @@ interface Timestamps {
     createdAt: Date;
 }
 interface CreatedBy {
-    createdBy: {
-        firstName: string;
-        lastName: string;
-        userId: string;
-    };
+    firstName: string;
+    lastName: string;
+    userId: string;
 }
 export interface Organization extends FirestoreDoc, Timestamps {
     name: string;
@@ -64,20 +62,13 @@ export interface Project extends FirestoreDoc, Timestamps {
     city: string;
     zipCode: string;
     state: string;
-    collectionId: string | null;
-    index: number | null;
-}
-export declare enum TemplateType {
-    Layout = "layout",
-    Annotation = "annotation"
 }
-export interface Template extends Timestamps {
+export interface Template {
     id: string;
     name: string;
     description: string;
     diagramFileId: string | null;
     diagramUrl: string;
-    type?: TemplateType;
     tableConfig: ColumnConfig[];
     tolerances?: {
         [key: string]: {
@@ -87,49 +78,17 @@ export interface Template extends Timestamps {
             deviation: number;
         };
     };
-    isPublic: boolean;
-    orgId: string;
-    orgName: string;
-    parentFolderId?: string | null;
-}
-export interface SelectedTemplate extends FirestoreDoc {
-    count: number;
-    isPublic: boolean;
-    name: string;
-    groupType?: string;
-}
-export declare enum FileUploadType {
-    Annotation = "annotation",
-    Template = "template"
-}
-export interface FileUpload {
-    id: string;
-    name: string;
-    projectId: string;
-    jobId: string;
-    groupId: string;
-    type: FileUploadType;
-    folderPath: string;
-    thumbnailUrl: string | null;
-    fileType: string | null;
 }
 export declare enum FolderType {
     Project = "project",
-    Job = "job",
-    Template = "template"
+    Job = "job"
 }
-export interface ProjectFolder extends FirestoreDoc, Timestamps {
-    name: string;
-    parentFolderId: string | null;
-    projectId: string;
-}
-export interface Folder extends FirestoreDoc, Timestamps {
+export interface Folder extends FirestoreDoc {
     name: string;
     index: number;
     parentFolderId?: string | null;
     projectId: string | null;
     type: FolderType;
-    isPublic?: boolean;
 }
 export declare enum JobType {
     DEFAULT = "default",
@@ -140,8 +99,7 @@ export interface Job extends FirestoreDoc, Timestamps {
     folderId: string;
     progress: number;
     projectId: string;
-    totalTasks: number;
-    lastAccessed: Date;
+    totalTasks: string;
     toleranceConfig?: {
         thresholds: {
             id: string;
@@ -152,10 +110,8 @@ export interface Job extends FirestoreDoc, Timestamps {
     };
     areaMapFileId?: string;
     type?: JobType;
-    address?: string;
-    description?: string;
 }
-export interface Section extends Timestamps {
+export interface Section {
     id: string;
     name: string;
     tableConfig: ColumnConfig[];
@@ -184,12 +140,6 @@ export interface Group extends FirestoreDoc, Timestamps {
     formula?: any;
     isCompleted?: boolean;
     type?: string;
-    details?: {
-        material: string;
-        finish: string;
-        finishDate: string;
-    };
-    path?: string;
 }
 export declare enum ColumnType {
     Text = "text",
@@ -205,8 +155,7 @@ export declare enum ColumnType {
 export interface Formula extends FirestoreDoc, Timestamps {
     expression: string;
     name: string;
-    variables: string[];
-    variableToColumnMap: Record<string, any>;
+    varaibles: string[];
 }
 export interface ColumnConfig {
     id: string;
@@ -217,7 +166,6 @@ export interface ColumnConfig {
     withTolerance?: boolean;
     options?: string[];
     conversions?: Conversion[];
-    size?: number;
 }
 export interface Conversion {
     label: string;
@@ -259,7 +207,6 @@ export declare enum Units {
     FeetInchesFractional = "ft_in_frac"
 }
 export declare const convertUnitsToReadable: (targetUnit: Units) => "cm" | "mm" | "m" | "in" | "ft" | "in (fractional)" | "ft-in (decimal)" | "ft-in (fractional)" | null;
-export declare const convertUnitsToReadableShort: (targetUnit: Units) => "cm" | "mm" | "m" | "in" | "ft" | "ft-in";
 export declare enum FractionalTolerance {
     Fourth = "4",
     Eighth = "8",

package/dist/types/firestore.js

@@ -10,21 +10,10 @@ export var InvitationStatus;
     InvitationStatus["Pending"] = "pending";
     InvitationStatus["Accepted"] = "accepted";
 })(InvitationStatus || (InvitationStatus = {}));
-export var TemplateType;
-(function (TemplateType) {
-    TemplateType["Layout"] = "layout";
-    TemplateType["Annotation"] = "annotation";
-})(TemplateType || (TemplateType = {}));
-export var FileUploadType;
-(function (FileUploadType) {
-    FileUploadType["Annotation"] = "annotation";
-    FileUploadType["Template"] = "template";
-})(FileUploadType || (FileUploadType = {}));
 export var FolderType;
 (function (FolderType) {
     FolderType["Project"] = "project";
     FolderType["Job"] = "job";
-    FolderType["Template"] = "template";
 })(FolderType || (FolderType = {}));
 export var JobType;
 (function (JobType) {
@@ -81,28 +70,6 @@ export const convertUnitsToReadable = (targetUnit) => {
             return null;
     }
 };
-export const convertUnitsToReadableShort = (targetUnit) => {
-    switch (targetUnit) {
-        case Units.Meters:
-            return 'm';
-        case Units.Millimeters:
-            return 'mm';
-        case Units.Centimeters:
-            return 'cm';
-        case Units.Feet:
-            return 'ft';
-        case Units.FractionalInches:
-            return 'in';
-        case Units.Inches:
-            return 'in';
-        case Units.FeetInchesDecimal:
-            return 'ft-in';
-        case Units.FeetInchesFractional:
-            return 'ft-in';
-        default:
-            return targetUnit;
-    }
-};
 export var FractionalTolerance;
 (function (FractionalTolerance) {
     FractionalTolerance["Fourth"] = "4";

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/dist/utils/micrometersToUnit.d.ts

@@ -1,5 +1,5 @@
 import { DecimalTolerance, FractionalTolerance, Units } from '../types/firestore.js';
-export declare const convertMicrometers: (micrometers: number | null | undefined, unit: Units, fractionalTolerance: FractionalTolerance, decimalTolerance: DecimalTolerance) => {
+export declare const convertMicrometers: (micrometers: number, unit: Units, fractionalTolerance: FractionalTolerance, decimalTolerance: DecimalTolerance) => {
     value: string;
-    unit: string;
+    unit: string | null;
 };

package/dist/utils/micrometersToUnit.js

@@ -2,84 +2,75 @@ import { Units, convertUnitsToReadable, } from '../types/firestore.js';
 import { create, all } from 'mathjs';
 const math = create(all);
 export const convertMicrometers = (micrometers, unit, fractionalTolerance, decimalTolerance) => {
-    if (micrometers == null || isNaN(micrometers)) {
-        return { value: 'NaN', unit: '' };
-    }
-    try {
-        const converted = math.unit(micrometers, 'um');
-        let value = 0;
-        let displayUnit = '';
-        switch (unit) {
-            case Units.Inches:
-            case Units.FractionalInches: {
-                const inches = converted.toNumber('in');
-                displayUnit = 'in';
-                if (unit === Units.FractionalInches) {
-                    const denominator = parseInt(fractionalTolerance, 10);
-                    const whole = Math.floor(inches);
-                    const fractional = inches - whole;
-                    const numerator = Math.round(fractional * denominator);
-                    if (numerator === denominator) {
-                        value = `${whole + 1}`;
-                    }
-                    else {
-                        value =
-                            numerator === 0
-                                ? `${whole}`
-                                : `${whole} ${numerator}/${denominator}`;
-                    }
+    const converted = math.unit(micrometers, 'um');
+    let value = 0;
+    let displayUnit = '';
+    switch (unit) {
+        case Units.Inches:
+        case Units.FractionalInches: {
+            const inches = converted.toNumber('in');
+            displayUnit = 'in';
+            if (unit === Units.FractionalInches) {
+                const denominator = parseInt(fractionalTolerance, 10);
+                const whole = Math.floor(inches);
+                const fractional = inches - whole;
+                const numerator = Math.round(fractional * denominator);
+                if (numerator === denominator) {
+                    value = `${whole + 1}`;
                 }
                 else {
-                    value = inches.toFixed(decimalTolerance.length - 2);
+                    value =
+                        numerator === 0
+                            ? `${whole}`
+                            : `${whole} ${numerator}/${denominator}`;
                 }
-                break;
             }
-            case Units.Feet:
-            case Units.FeetInchesFractional:
-            case Units.FeetInchesDecimal: {
-                const feet = converted.toNumber('ft');
-                const wholeFeet = Math.floor(feet);
-                const fractionalFeet = feet - wholeFeet;
-                displayUnit = 'ft';
-                if (unit === Units.FeetInchesFractional) {
-                    const inches = fractionalFeet * 12;
-                    const wholeInches = Math.floor(inches);
-                    const fractional = inches - wholeInches;
-                    const denominator = parseInt(fractionalTolerance, 10);
-                    const numerator = Math.round(fractional * denominator);
-                    if (numerator === denominator) {
-                        value = `${wholeFeet}' ${wholeInches + 1}"`;
-                    }
-                    else {
-                        value =
-                            numerator === 0
-                                ? `${wholeFeet}' ${wholeInches}"`
-                                : `${wholeFeet}' ${wholeInches} ${numerator}/${denominator}"`;
-                    }
-                }
-                else if (unit === Units.FeetInchesDecimal) {
-                    const inches = (fractionalFeet * 12).toFixed(decimalTolerance.length - 2);
-                    value = `${wholeFeet}' ${inches}"`;
+            else {
+                value = inches.toFixed(decimalTolerance.length - 2); // Match decimal places to tolerance
+            }
+            break;
+        }
+        case Units.Feet:
+        case Units.FeetInchesFractional:
+        case Units.FeetInchesDecimal: {
+            const feet = converted.toNumber('ft');
+            const wholeFeet = Math.floor(feet);
+            const fractionalFeet = feet - wholeFeet;
+            displayUnit = 'ft';
+            if (unit === Units.FeetInchesFractional) {
+                const inches = fractionalFeet * 12;
+                const wholeInches = Math.floor(inches);
+                const fractional = inches - wholeInches;
+                const denominator = parseInt(fractionalTolerance, 10);
+                const numerator = Math.round(fractional * denominator);
+                if (numerator === denominator) {
+                    value = `${wholeFeet}' ${wholeInches + 1}"`;
                 }
                 else {
-                    value = feet.toFixed(decimalTolerance.length - 2);
+                    value =
+                        numerator === 0
+                            ? `${wholeFeet}' ${wholeInches}"`
+                            : `${wholeFeet}' ${wholeInches} ${numerator}/${denominator}"`;
                 }
-                break;
             }
-            case Units.Meters:
-            case Units.Centimeters:
-            case Units.Millimeters: {
-                displayUnit = convertUnitsToReadable(unit) ?? '';
-                value = converted.toNumber(unit).toFixed(decimalTolerance.length - 2);
-                break;
+            else if (unit === Units.FeetInchesDecimal) {
+                const inches = (fractionalFeet * 12).toFixed(decimalTolerance.length - 2);
+                value = `${wholeFeet}' ${inches}"`;
             }
-            default:
-                throw new Error('Unsupported unit');
+            else {
+                value = feet.toFixed(decimalTolerance.length - 2);
+            }
+            break;
         }
-        return { value, unit: displayUnit };
-    }
-    catch (err) {
-        console.warn('Error converting micrometers:', err);
-        return { value: 'NaN', unit: '' };
+        case Units.Meters:
+        case Units.Centimeters:
+        case Units.Millimeters: {
+            displayUnit = convertUnitsToReadable(unit);
+            value = converted.toNumber(unit).toFixed(decimalTolerance.length - 2);
+            break;
+        }
+        default:
+            throw new Error('Unsupported unit');
     }
+    return { value, unit: displayUnit };
 };

package/package.json

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

package/dist/formulas/calculateFormula.d.ts

@@ -1,2 +0,0 @@
-import { ColumnConfig, DecimalTolerance, FractionalTolerance, Formula, Measurement, Units } from '../types/firestore.js';
-export declare const calculateFormula: (formula: Formula, formulas: Formula[], columns: Record<string, string>, tableConfig: ColumnConfig[], measurements: Measurement[], unit: Units, fractionalTolerance: FractionalTolerance, decimalTolerance: DecimalTolerance) => string | number | null;

package/dist/formulas/calculateFormula.js

@@ -1,114 +0,0 @@
-import { ColumnType, } from '../types/firestore.js';
-import { evaluateFormula } from './evaluateFormula.js';
-import { convertMicrometers } from '../utils/micrometersToUnit.js';
-function parseMixedNumber(str) {
-    const parts = str.trim().split(' ');
-    let whole = 0;
-    let fraction = 0;
-    if (parts.length === 2) {
-        whole = parseFloat(parts[0]);
-        const [num, den] = parts[1].split('/').map(Number);
-        fraction = num / den;
-    }
-    else if (parts[0].includes('/')) {
-        const [num, den] = parts[0].split('/').map(Number);
-        fraction = num / den;
-    }
-    else {
-        whole = parseFloat(parts[0]);
-    }
-    return whole + fraction;
-}
-export const calculateFormula = (formula, formulas, columns, tableConfig, measurements, unit, fractionalTolerance, decimalTolerance) => {
-    // Convert Firestore Map to plain object if necessary
-    let variableToColumnMap = {};
-    if (formula.variableToColumnMap) {
-        if (formula.variableToColumnMap instanceof Map) {
-            // Convert Firestore Map to plain object
-            variableToColumnMap = Object.fromEntries(formula.variableToColumnMap);
-        }
-        else if (typeof formula.variableToColumnMap === 'object') {
-            // Already a plain object
-            variableToColumnMap = formula.variableToColumnMap;
-        }
-    }
-    if (Object.keys(variableToColumnMap).length === 0) {
-        return null;
-    }
-    // Build valueMap from group.columns and measurementMap
-    const valueMap = {};
-    for (const [columnId, measurementId] of Object.entries(columns)) {
-        const column = tableConfig.find((c) => c.id === columnId);
-        if (!column)
-            continue;
-        if (column.type === ColumnType.Measurement) {
-            const measurement = measurements.find((m) => m.id === measurementId);
-            if (!measurement)
-                continue;
-            const { value, unit: displayUnit } = convertMicrometers(measurement.value, unit, fractionalTolerance, decimalTolerance);
-            valueMap[columnId] = parseMixedNumber(value);
-        }
-        else if (column.type === ColumnType.Angle) {
-            const measurement = measurements.find((m) => m.id === measurementId);
-            if (!measurement)
-                continue;
-            valueMap[columnId] = measurement.value;
-        }
-        else if (column.type === ColumnType.ConversionTable) {
-            const value = measurementId.split(':')[1];
-            valueMap[columnId] = parseFloat(value);
-        }
-        else if (column.type === ColumnType.Number) {
-            valueMap[columnId] = parseFloat(measurementId);
-        }
-    }
-    console.log('valueMap', valueMap);
-    // Convert formulas to the expected FormulaDefinition format
-    const formulaDefinitions = formulas
-        .filter((f) => f.variableToColumnMap) // Only include formulas with new schema
-        .map((f) => {
-        const mappings = {};
-        // Convert Firestore Map to plain object if necessary
-        let fVariableToColumnMap = {};
-        if (f.variableToColumnMap instanceof Map) {
-            fVariableToColumnMap = Object.fromEntries(f.variableToColumnMap);
-        }
-        else if (typeof f.variableToColumnMap === 'object') {
-            fVariableToColumnMap = f.variableToColumnMap;
-        }
-        for (const [variable, mapping] of Object.entries(fVariableToColumnMap)) {
-            if (typeof mapping === 'string') {
-                // Handle transition period - old format in new structure
-                mappings[variable] = { id: mapping, type: 'column' };
-            }
-            else {
-                // New format: { id: string; type: 'column' | 'formula' }
-                mappings[variable] = mapping;
-            }
-        }
-        return {
-            id: f.id,
-            name: f.name,
-            expression: f.expression,
-            variableToColumnMap: mappings,
-        };
-    });
-    // Convert the current formula's mappings
-    const currentMappings = {};
-    for (const [variable, mapping] of Object.entries(variableToColumnMap)) {
-        if (typeof mapping === 'string') {
-            currentMappings[variable] = { id: mapping, type: 'column' };
-        }
-        else {
-            currentMappings[variable] = mapping;
-        }
-    }
-    const result = evaluateFormula({
-        expression: formula.expression,
-        mappings: currentMappings,
-        valueMap: valueMap,
-        unit: unit,
-        formulas: formulaDefinitions,
-    });
-    return result;
-};