@reekon-tools/boldr-utils 1.4.8 → 1.4.10

package/dist/formulas/evaluateFormula.js

@@ -29,22 +29,16 @@ 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);
@@ -68,9 +62,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,36 +69,26 @@ 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}`);
                     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}`);
@@ -116,25 +97,17 @@ 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;
@@ -145,7 +118,6 @@ 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) {

package/dist/types/firestore.d.ts

@@ -92,7 +92,7 @@ export interface Template extends Timestamps {
     orgName: string;
     parentFolderId?: string | null;
 }
-export interface SelectedTemplate {
+export interface SelectedTemplate extends FirestoreDoc {
     count: number;
     isPublic: boolean;
     name: string;
@@ -152,6 +152,8 @@ export interface Job extends FirestoreDoc, Timestamps {
     };
     areaMapFileId?: string;
     type?: JobType;
+    address?: string;
+    description?: string;
 }
 export interface Section extends Timestamps {
     id: string;
@@ -187,6 +189,7 @@ export interface Group extends FirestoreDoc, Timestamps {
         finish: string;
         finishDate: string;
     };
+    path?: string;
 }
 export declare enum ColumnType {
     Text = "text",
@@ -214,6 +217,7 @@ export interface ColumnConfig {
     withTolerance?: boolean;
     options?: string[];
     conversions?: Conversion[];
+    size?: number;
 }
 export interface Conversion {
     label: string;

package/package.json

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