@reekon-tools/boldr-utils 1.4.10 → 1.4.12

package/dist/formulas/calculateFormula.d.ts

@@ -1,2 +1,2 @@
-import { Formula, Measurement, Units } from '../types/firestore.js';
-export declare const calculateFormula: (formula: Formula, formulas: Formula[], columns: Record<string, any>, measurements: Measurement[], unit: Units) => string | number | null;
+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,5 +1,25 @@
+import { ColumnType, } from '../types/firestore.js';
 import { evaluateFormula } from './evaluateFormula.js';
-export const calculateFormula = (formula, formulas, columns, measurements, unit) => {
+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) {
@@ -17,19 +37,32 @@ export const calculateFormula = (formula, formulas, columns, measurements, unit)
     }
     // Build valueMap from group.columns and measurementMap
     const valueMap = {};
-    // Map column IDs to their actual measurement values
     for (const [columnId, measurementId] of Object.entries(columns)) {
-        const measurement = measurements.find((m) => m.id === measurementId);
-        if (measurement?.value !== undefined) {
+        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 {
-            const numericValue = typeof measurementId === 'number'
-                ? measurementId
-                : parseFloat(measurementId || '0');
-            valueMap[columnId] = isNaN(numericValue) ? 0 : numericValue;
+        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
@@ -73,7 +106,7 @@ export const calculateFormula = (formula, formulas, columns, measurements, unit)
     const result = evaluateFormula({
         expression: formula.expression,
         mappings: currentMappings,
-        valueMap,
+        valueMap: valueMap,
         unit: unit,
         formulas: formulaDefinitions,
     });

package/dist/formulas/evaluateFormula.js

@@ -84,7 +84,7 @@ export function evaluateFormula({ expression, mappings, valueMap, unit, formulas
                     if (micrometers === 0) {
                         console.warn(`⚠️ Zero or missing value for mapping ID "${mapping.id}"`);
                     }
-                    const valueInUnit = mathUnit(micrometers, 'um').toNumber(normalizedUnit);
+                    const valueInUnit = micrometers;
                     scope[variable] = valueInUnit;
                 }
                 else if (mapping.type === 'formula') {
@@ -128,25 +128,20 @@ 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;
-        // Convert using math.js directly
-        const valueInUnit = mathUnit(micrometers, 'um').toNumber(normalizedUnit);
-        scope[variable] = valueInUnit;
+        scope[variable] = micrometers;
     }
     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;
-            const valueInUnit = mathUnit(micrometers, 'um').toNumber(normalizedUnit);
-            scope[variable] = valueInUnit;
+            scope[variable] = micrometers;
         }
         else if (mapping.type === 'formula') {
             // Find and evaluate the referenced formula
@@ -160,8 +155,7 @@ export function createEnhancedFormulaScope({ mappings, valueMap, unit, formulas
                     formulas,
                 });
                 if (typeof result === 'number') {
-                    const valueInUnit = mathUnit(result, 'um').toNumber(normalizedUnit);
-                    scope[variable] = valueInUnit;
+                    scope[variable] = result;
                 }
                 else {
                     scope[variable] = 0; // Error case

package/dist/utils/micrometersToUnit.d.ts

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

package/dist/utils/micrometersToUnit.js

@@ -2,75 +2,84 @@ import { Units, convertUnitsToReadable, } from '../types/firestore.js';
 import { create, all } from 'mathjs';
 const math = create(all);
 export const convertMicrometers = (micrometers, unit, fractionalTolerance, decimalTolerance) => {
-    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}`;
+    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}`;
+                    }
                 }
                 else {
-                    value =
-                        numerator === 0
-                            ? `${whole}`
-                            : `${whole} ${numerator}/${denominator}`;
+                    value = inches.toFixed(decimalTolerance.length - 2);
                 }
+                break;
             }
-            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}"`;
+            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 =
-                        numerator === 0
-                            ? `${wholeFeet}' ${wholeInches}"`
-                            : `${wholeFeet}' ${wholeInches} ${numerator}/${denominator}"`;
+                    value = feet.toFixed(decimalTolerance.length - 2);
                 }
+                break;
             }
-            else if (unit === Units.FeetInchesDecimal) {
-                const inches = (fractionalFeet * 12).toFixed(decimalTolerance.length - 2);
-                value = `${wholeFeet}' ${inches}"`;
+            case Units.Meters:
+            case Units.Centimeters:
+            case Units.Millimeters: {
+                displayUnit = convertUnitsToReadable(unit) ?? '';
+                value = converted.toNumber(unit).toFixed(decimalTolerance.length - 2);
+                break;
             }
-            else {
-                value = feet.toFixed(decimalTolerance.length - 2);
-            }
-            break;
-        }
-        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');
         }
-        default:
-            throw new Error('Unsupported unit');
+        return { value, unit: displayUnit };
+    }
+    catch (err) {
+        console.warn('Error converting micrometers:', err);
+        return { value: 'NaN', unit: '' };
     }
-    return { value, unit: displayUnit };
 };

package/package.json

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