@reekon-tools/boldr-utils 1.4.14 → 1.4.16

package/dist/formulas/calculateFormula.d.ts

@@ -0,0 +1,2 @@
+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

@@ -0,0 +1,131 @@
+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);
+        }
+    }
+    // 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;
+        }
+    }
+    // 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,
+        valueMap: valueMap,
+        unit: unit,
+        formulas: formulaDefinitions,
+    });
+    return result;
+};

package/dist/formulas/evaluateFormula.js

@@ -1,5 +1,21 @@
 import { Units } from '../types/firestore.js';
-import { compile, unit as mathUnit } from 'mathjs';
+import { create, all } from 'mathjs';
+// Create a custom mathjs instance with degree-based trigonometric functions
+const math = create(all);
+// Helper to convert degrees to radians
+const degToRad = (degrees) => (degrees * Math.PI) / 180;
+// Import degree-based trigonometric functions
+math.import({
+    sin: (x) => Math.sin(degToRad(x)),
+    cos: (x) => Math.cos(degToRad(x)),
+    tan: (x) => Math.tan(degToRad(x)),
+    asin: (x) => (Math.asin(x) * 180) / Math.PI,
+    acos: (x) => (Math.acos(x) * 180) / Math.PI,
+    atan: (x) => (Math.atan(x) * 180) / Math.PI,
+    atan2: (y, x) => (Math.atan2(y, x) * 180) / Math.PI,
+}, { override: true });
+const compile = math.compile.bind(math);
+const mathUnit = math.unit.bind(math);
 // Cache for evaluated formulas to improve performance
 const formulaCache = new Map();
 function normalizeUnitForMathJS(unit) {
@@ -29,31 +45,72 @@ 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);
-            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);
@@ -68,9 +125,6 @@ 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}`);
@@ -78,103 +132,128 @@ 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 = mathUnit(micrometers, 'um').toNumber(normalizedUnit);
-                    console.log(`🔢 Converted to ${normalizedUnit}: ${valueInUnit}`);
+                    const valueInUnit = micrometers;
                     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}`);
+                    // 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;
-                    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());
+            // 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'));
-            console.log(`🎯 Final result: ${finalResult} micrometers`);
+            // 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);
         }
     }
     try {
         const result = evaluateNestedFormula('root', expression, mappings);
-        console.log(`🎉 Formula evaluation completed successfully: ${result}`);
         return result;
     }
     catch (err) {
-        console.error('❌ Formula evaluation failed:', err);
+        console.warn('❌ 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);
     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
@@ -188,8 +267,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/index.d.ts

@@ -1,4 +1,5 @@
 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,4 +1,5 @@
 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,9 +5,11 @@ interface Timestamps {
     createdAt: Date;
 }
 interface CreatedBy {
-    firstName: string;
-    lastName: string;
-    userId: string;
+    createdBy: {
+        firstName: string;
+        lastName: string;
+        userId: string;
+    };
 }
 export interface Organization extends FirestoreDoc, Timestamps {
     name: string;
@@ -62,13 +64,20 @@ 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 {
+export interface Template extends Timestamps {
     id: string;
     name: string;
     description: string;
     diagramFileId: string | null;
     diagramUrl: string;
+    type?: TemplateType;
     tableConfig: ColumnConfig[];
     tolerances?: {
         [key: string]: {
@@ -78,17 +87,49 @@ export interface Template {
             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"
+    Job = "job",
+    Template = "template"
 }
-export interface Folder extends FirestoreDoc {
+export interface ProjectFolder extends FirestoreDoc, Timestamps {
+    name: string;
+    parentFolderId: string | null;
+    projectId: string;
+}
+export interface Folder extends FirestoreDoc, Timestamps {
     name: string;
     index: number;
     parentFolderId?: string | null;
     projectId: string | null;
     type: FolderType;
+    isPublic?: boolean;
 }
 export declare enum JobType {
     DEFAULT = "default",
@@ -99,7 +140,8 @@ export interface Job extends FirestoreDoc, Timestamps {
     folderId: string;
     progress: number;
     projectId: string;
-    totalTasks: string;
+    totalTasks: number;
+    lastAccessed: Date;
     toleranceConfig?: {
         thresholds: {
             id: string;
@@ -110,8 +152,10 @@ export interface Job extends FirestoreDoc, Timestamps {
     };
     areaMapFileId?: string;
     type?: JobType;
+    address?: string;
+    description?: string;
 }
-export interface Section {
+export interface Section extends Timestamps {
     id: string;
     name: string;
     tableConfig: ColumnConfig[];
@@ -140,6 +184,12 @@ 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",
@@ -155,7 +205,8 @@ export declare enum ColumnType {
 export interface Formula extends FirestoreDoc, Timestamps {
     expression: string;
     name: string;
-    varaibles: string[];
+    variables: string[];
+    variableToColumnMap: Record<string, any>;
 }
 export interface ColumnConfig {
     id: string;
@@ -166,6 +217,7 @@ export interface ColumnConfig {
     withTolerance?: boolean;
     options?: string[];
     conversions?: Conversion[];
+    size?: number;
 }
 export interface Conversion {
     label: string;
@@ -207,6 +259,7 @@ 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,10 +10,21 @@ 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) {
@@ -70,6 +81,28 @@ 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/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.14",
+  "version": "1.4.16",
   "description": "Shared utilities for formulas and measurement conversion used in Reekon apps",
   "author": "REEKON Tools",
   "license": "MIT",