@reekon-tools/boldr-utils 1.17.0 → 1.17.2

package/dist/annotation/canvas/elements/BackgroundSvg.js

@@ -78,7 +78,11 @@ const useBackgroundSkSvg = (url) => {
                     next = Skia.SVG.MakeFromData(data, fontMgr);
                     data.dispose();
                 }
-                if (!cancelled)
+                // A load that lands after unmount (or after the url changed) owns a
+                // C++ handle nothing will ever draw. Free it here or it leaks outright.
+                if (cancelled)
+                    next?.dispose?.();
+                else
                     setSvg(next);
             }
             catch (e) {
@@ -89,6 +93,27 @@ const useBackgroundSkSvg = (url) => {
             cancelled = true;
         };
     }, [url]);
+    // An SkSVG is a handle on a C++ SVG DOM; dropping the JS reference does NOT
+    // free it. The browser path below already disposes its replaced bitmaps —
+    // this is the same discipline for the native path, which had none: every
+    // diagram open allocated an SkSVG and left it to the native heap forever.
+    //
+    // Timing matters. Disposing in the loader's own cleanup would free the SVG
+    // that ImageSVG is still drawing (state has not changed yet) — a native
+    // use-after-free. So release the REPLACED one from an effect keyed on the
+    // committed value, which runs after the render that stopped drawing it, and
+    // the live one on unmount.
+    const prevRef = useRef(null);
+    useEffect(() => {
+        const prev = prevRef.current;
+        if (prev && prev !== svg)
+            prev.dispose?.();
+        prevRef.current = svg;
+    }, [svg]);
+    useEffect(() => () => {
+        prevRef.current?.dispose?.();
+        prevRef.current = null;
+    }, []);
     return svg;
 };
 const SkSvgBackground = ({ image, resolveUrl }) => {

package/dist/export/buildJobCsv.js

@@ -2,18 +2,42 @@ import { ColumnType, GroupType, } from '../types/firestore.js';
 import { calculateFormula } from '../formulas/calculateFormula.js';
 import { formatSelectedValues } from '../utils/selectValues.js';
 import { isDefaultGroup, isFormGroupCompleted } from '../utils/groups.js';
+import { sortMeasurementsByCompleted } from '../utils/measurementSort.js';
+import { isScalarMeasurement, scalarValueSuffix, } from '../utils/measurementKind.js';
 export const escapeCSVField = (field) => `"${field.replace(/"/g, '""')}"`;
 // Spreadsheet-formula hyperlink cell. Two escaping layers: quotes inside the
 // formula's string literals are doubled (Excel/Sheets escaping), then the
 // whole formula is CSV-escaped.
 export const hyperlinkCell = (url, label) => escapeCSVField(`=HYPERLINK("${url.replace(/"/g, '""')}","${label.replace(/"/g, '""')}")`);
 const objectCell = (obj) => obj.url ? hyperlinkCell(obj.url, obj.name) : escapeCSVField(obj.name);
+// The shared model types timestamps as Date, but both apps deliver Firestore
+// Timestamps at runtime; accept either (and null/absent on legacy docs).
+const toExportDate = (value) => {
+    if (value instanceof Date)
+        return value;
+    if (value &&
+        typeof value.toDate === 'function') {
+        return value.toDate();
+    }
+    return null;
+};
+const pad2 = (n) => String(n).padStart(2, '0');
+// Fixed local-time format (no locale dependence) so the two platforms emit
+// identical files and spreadsheets sort it lexically.
+const dateCell = (value) => {
+    const d = toExportDate(value);
+    return d
+        ? `${d.getFullYear()}-${pad2(d.getMonth() + 1)}-${pad2(d.getDate())} ${pad2(d.getHours())}:${pad2(d.getMinutes())}`
+        : '';
+};
+const userCell = (user) => (user ? [user.firstName, user.lastName].filter(Boolean).join(' ') : '');
 // Pure CSV assembly for the job export, shared by rock-pro-app and
 // rock-desktop so the two platforms emit identical files. With no objects
-// selected and all measurement-data columns on, the measurement sections are
-// identical to the legacy exportCSV output; objects add a trailing "Objects"
-// column (list groups) or extend the form row (form groups), one skipped
-// column after the existing cells.
+// selected and the legacy measurement/label/notes columns on, the
+// measurement sections are identical to the legacy exportCSV output; the
+// completion/creation fields add columns after those, and objects add a
+// trailing "Objects" column (list groups) or extend the form row (form
+// groups), one skipped column after the existing cells.
 export function buildJobCsv(input) {
     const { scope, activeGroupId, config, groups, sections, formulas, measurementsByGroup, objectsByGroup, formatMeasurementValue, unitPrefs, } = input;
     const csvRows = [];
@@ -48,12 +72,19 @@ export function buildJobCsv(input) {
                 ...(includeField('measurement') ? ['Measurement'] : []),
                 ...(includeField('label') ? ['Label'] : []),
                 ...(includeField('notes') ? ['Notes'] : []),
+                ...(includeField('isComplete') ? ['Complete'] : []),
+                ...(includeField('completedBy') ? ['Completed By'] : []),
+                ...(includeField('completedAt') ? ['Completed At'] : []),
+                ...(includeField('createdAt') ? ['Created At'] : []),
+                ...(includeField('createdBy') ? ['Created By'] : []),
             ].map(escapeCSVField);
             if (objects.length > 0) {
                 headerCells.push(escapeCSVField(''), escapeCSVField('Objects'));
             }
             csvRows.push(headerCells.join(','));
-            const measurements = (measurementsByGroup.get(group.id) ?? []).filter(measurementPassesFilter);
+            // Export rows in the card/table display order (incomplete first, then
+            // capture time), regardless of the order the caller fetched them in.
+            const measurements = sortMeasurementsByCompleted(measurementsByGroup.get(group.id) ?? []).filter(measurementPassesFilter);
             // Objects fill a parallel column, one per row from the top; extra rows
             // are emitted when a group has more objects than measurements.
             const rowCount = Math.max(measurements.length, objects.length);
@@ -61,8 +92,13 @@ export function buildJobCsv(input) {
                 const measurement = measurements[i];
                 const row = [escapeCSVField('')];
                 if (includeField('measurement')) {
+                    // Angles and unitless numbers store their value as entered, not as
+                    // micrometers — running them through the length formatter would
+                    // render 45° as ~0. Emit them as-is with their own suffix.
                     row.push(escapeCSVField(measurement
-                        ? formatMeasurementValue(measurement.value, measurement.device)
+                        ? isScalarMeasurement(measurement.type)
+                            ? `${measurement.value}${scalarValueSuffix(measurement.type)}`
+                            : formatMeasurementValue(measurement.value, measurement.device)
                         : ''));
                 }
                 if (includeField('label')) {
@@ -71,6 +107,21 @@ export function buildJobCsv(input) {
                 if (includeField('notes')) {
                     row.push(escapeCSVField(measurement?.note || ''));
                 }
+                if (includeField('isComplete')) {
+                    row.push(escapeCSVField(measurement ? (measurement.isCompleted ? 'Yes' : 'No') : ''));
+                }
+                if (includeField('completedBy')) {
+                    row.push(escapeCSVField(userCell(measurement?.completedBy)));
+                }
+                if (includeField('completedAt')) {
+                    row.push(escapeCSVField(dateCell(measurement?.completedAt)));
+                }
+                if (includeField('createdAt')) {
+                    row.push(escapeCSVField(dateCell(measurement?.createdAt)));
+                }
+                if (includeField('createdBy')) {
+                    row.push(escapeCSVField(userCell(measurement?.createdBy)));
+                }
                 const obj = objects[i];
                 if (obj) {
                     row.push(escapeCSVField(''), objectCell(obj));
@@ -94,13 +145,24 @@ export function buildJobCsv(input) {
                 return;
             csvRows.push(`Section: ${section.name}`);
             csvRows.push('');
+            // Measurement-backed columns grow companion columns (Notes / Created
+            // At / Created By) as gated by the config; completion fields stay
+            // list-only — form completion is a whole-row concept.
+            const hasCompanions = (column) => column.type === ColumnType.Measurement ||
+                column.type === ColumnType.Angle;
             const columnHeaders = [];
             section.tableConfig.forEach((column) => {
                 columnHeaders.push(column.name);
-                if (includeField('notes') &&
-                    (column.type === ColumnType.Measurement ||
-                        column.type === ColumnType.Angle)) {
-                    columnHeaders.push(`${column.name} Notes`);
+                if (hasCompanions(column)) {
+                    if (includeField('notes')) {
+                        columnHeaders.push(`${column.name} Notes`);
+                    }
+                    if (includeField('createdAt')) {
+                        columnHeaders.push(`${column.name} Created At`);
+                    }
+                    if (includeField('createdBy')) {
+                        columnHeaders.push(`${column.name} Created By`);
+                    }
                 }
             });
             csvRows.push(['Form Name', ...columnHeaders].map(escapeCSVField).join(','));
@@ -165,14 +227,26 @@ export function buildJobCsv(input) {
                     else {
                         row.push('');
                     }
-                    if (includeField('notes') &&
-                        (column.type === ColumnType.Measurement ||
-                            column.type === ColumnType.Angle)) {
-                        if (group.descriptions && group.descriptions[column.id]) {
-                            row.push(escapeCSVField(group.descriptions[column.id]));
+                    if (hasCompanions(column)) {
+                        if (includeField('notes')) {
+                            if (group.descriptions && group.descriptions[column.id]) {
+                                row.push(escapeCSVField(group.descriptions[column.id]));
+                            }
+                            else {
+                                // Raw '' (unquoted) for byte-parity with legacy exportCSV.
+                                row.push('');
+                            }
                         }
-                        else {
-                            row.push('');
+                        if (includeField('createdAt') || includeField('createdBy')) {
+                            const columnMeasurement = measurementsByGroup
+                                .get(group.id)
+                                ?.find((m) => m.id === group.columns[column.id]);
+                            if (includeField('createdAt')) {
+                                row.push(escapeCSVField(dateCell(columnMeasurement?.createdAt)));
+                            }
+                            if (includeField('createdBy')) {
+                                row.push(escapeCSVField(userCell(columnMeasurement?.createdBy)));
+                            }
                         }
                     }
                 });

package/dist/export/config.d.ts

@@ -1,8 +1,8 @@
 export type ExportCategory = 'defaultGroup' | 'groups' | 'forms';
 export type ExportObjectType = 'calculators' | 'files' | 'photos' | 'cad' | 'labels' | 'notes';
 export type ExportMeasurementFilter = 'all' | 'complete' | 'incomplete';
-export type ExportImageFormat = 'hyperlink' | 'none';
-export type ExportMeasurementDataField = 'measurement' | 'label' | 'notes';
+export type ExportImageFormat = 'hyperlink' | 'embedded' | 'none';
+export type ExportMeasurementDataField = 'measurement' | 'label' | 'notes' | 'isComplete' | 'completedBy' | 'completedAt' | 'createdAt' | 'createdBy';
 export type ExportConfig = {
     categories: ExportCategory[];
     objects: ExportObjectType[];

package/dist/export/config.js

@@ -15,7 +15,16 @@ export const ALL_EXPORT_OBJECT_TYPES = [
     'labels',
     'notes',
 ];
-export const ALL_EXPORT_MEASUREMENT_DATA_FIELDS = ['measurement', 'label', 'notes'];
+export const ALL_EXPORT_MEASUREMENT_DATA_FIELDS = [
+    'measurement',
+    'label',
+    'notes',
+    'isComplete',
+    'completedBy',
+    'completedAt',
+    'createdAt',
+    'createdBy',
+];
 // Objects are opt-in: nothing ticked and images excluded until the user
 // configures otherwise, so a default export is measurements-only.
 export const DEFAULT_EXPORT_CONFIG = {
@@ -37,7 +46,7 @@ export const EXPORT_EVERYTHING_CONFIG = {
 const isCategory = (v) => typeof v === 'string' && ALL_EXPORT_CATEGORIES.includes(v);
 const isObjectType = (v) => typeof v === 'string' && ALL_EXPORT_OBJECT_TYPES.includes(v);
 const isMeasurementFilter = (v) => v === 'all' || v === 'complete' || v === 'incomplete';
-const isImageFormat = (v) => v === 'hyperlink' || v === 'none';
+const isImageFormat = (v) => v === 'hyperlink' || v === 'embedded' || v === 'none';
 const isMeasurementDataField = (v) => typeof v === 'string' &&
     ALL_EXPORT_MEASUREMENT_DATA_FIELDS.includes(v);
 // Tolerant reader for the raw user-doc field. Missing/invalid fields fall

package/dist/exports.d.ts

@@ -14,6 +14,8 @@ export { classifyFileForExport } from './export/objectKinds.js';
 export { buildJobCsv, escapeCSVField, hyperlinkCell, type BuildJobCsvInput, type ExportObjectRow, type ExportScope, } from './export/buildJobCsv.js';
 export { desktopBaseUrlForFirebaseProject, desktopFileEditorUrl, type DesktopLinkContext, } from './export/desktopLinks.js';
 export { numberToLetterIndex, formGroupInputLabel, listGroupMeasurementLabel, } from './utils/indexLabels.js';
+export { sortMeasurementsByCompleted } from './utils/measurementSort.js';
+export { isLengthMeasurement, isScalarMeasurement, scalarValueSuffix, } from './utils/measurementKind.js';
 export { toSelectedValues, formatSelectedValues, toStoredValue, } from './utils/selectValues.js';
 export * from './calculator/index.js';
 export { annotationScopeKey, isFieldOp, isTemplateScope, isCalculatorScope, type AnnotationDataProvider, type AnnotationFile, type AnnotationFilePatch, type AnnotationFileSummary, type AnnotationScope, type CalculatorScope, type FieldOp, type ImageBlob, type JobGroupScope, type JobScope, type Patch, type TemplateScope, type Unsubscribe, type UploadedImageRef, } from './annotation/data/AnnotationDataProvider.js';

package/dist/exports.js

@@ -21,6 +21,8 @@ export { classifyFileForExport } from './export/objectKinds.js';
 export { buildJobCsv, escapeCSVField, hyperlinkCell, } from './export/buildJobCsv.js';
 export { desktopBaseUrlForFirebaseProject, desktopFileEditorUrl, } from './export/desktopLinks.js';
 export { numberToLetterIndex, formGroupInputLabel, listGroupMeasurementLabel, } from './utils/indexLabels.js';
+export { sortMeasurementsByCompleted } from './utils/measurementSort.js';
+export { isLengthMeasurement, isScalarMeasurement, scalarValueSuffix, } from './utils/measurementKind.js';
 export { toSelectedValues, formatSelectedValues, toStoredValue, } from './utils/selectValues.js';
 // Construction Calculator shared module (schema, units, evaluator, solver,
 // validation).

package/dist/utils/measurementKind.d.ts

@@ -0,0 +1,22 @@
+import { MeasurementType } from '../types/firestore.js';
+/**
+ * Angle and Number are BARE SCALARS: `value` is stored exactly as entered
+ * (signed degrees / a unitless decimal) and must never go through the
+ * micrometer parser or formatter. Only Length is micrometers — including a
+ * legacy doc with no `type` at all, which predates the field.
+ *
+ * These exist because the shorthand for "is this a length" was
+ * `type !== MeasurementType.Angle`. That read correctly while the enum had two
+ * members and became wrong the moment it gained a third: a unitless `25` fell
+ * into the length branch and rendered as `0 in`. Prefer these over an inline
+ * comparison so the next member added is a one-file change.
+ */
+export declare const isLengthMeasurement: (type?: MeasurementType) => boolean;
+/** Angle or Number — a value shown as-is, with no unit conversion. */
+export declare const isScalarMeasurement: (type?: MeasurementType) => boolean;
+/**
+ * The unit mark shown alongside a scalar value. Numbers are unitless by
+ * definition, so this is empty for them — callers must not substitute the
+ * user's selected unit.
+ */
+export declare const scalarValueSuffix: (type?: MeasurementType) => string;

package/dist/utils/measurementKind.js

@@ -0,0 +1,22 @@
+import { MeasurementType } from '../types/firestore.js';
+/**
+ * Angle and Number are BARE SCALARS: `value` is stored exactly as entered
+ * (signed degrees / a unitless decimal) and must never go through the
+ * micrometer parser or formatter. Only Length is micrometers — including a
+ * legacy doc with no `type` at all, which predates the field.
+ *
+ * These exist because the shorthand for "is this a length" was
+ * `type !== MeasurementType.Angle`. That read correctly while the enum had two
+ * members and became wrong the moment it gained a third: a unitless `25` fell
+ * into the length branch and rendered as `0 in`. Prefer these over an inline
+ * comparison so the next member added is a one-file change.
+ */
+export const isLengthMeasurement = (type) => (type ?? MeasurementType.Length) === MeasurementType.Length;
+/** Angle or Number — a value shown as-is, with no unit conversion. */
+export const isScalarMeasurement = (type) => !isLengthMeasurement(type);
+/**
+ * The unit mark shown alongside a scalar value. Numbers are unitless by
+ * definition, so this is empty for them — callers must not substitute the
+ * user's selected unit.
+ */
+export const scalarValueSuffix = (type) => type === MeasurementType.Angle ? '°' : '';

package/dist/utils/measurementSort.d.ts

@@ -0,0 +1,2 @@
+import type { Measurement } from '../types/firestore.js';
+export declare const sortMeasurementsByCompleted: (groupMeasurements: Measurement[]) => Measurement[];

package/dist/utils/measurementSort.js

@@ -0,0 +1,45 @@
+// Firestore Timestamp doesn't support relational comparison operators, which
+// silently degrades sort comparators to insertion order. The shared model
+// types createdAt as Date, but both apps deliver Timestamps at runtime — read
+// via the methods Timestamps actually expose.
+const createdAtMillis = (createdAt) => {
+    if (createdAt == null)
+        return 0;
+    if (createdAt instanceof Date)
+        return createdAt.getTime();
+    const ts = createdAt;
+    if (typeof ts.toMillis === 'function')
+        return ts.toMillis();
+    if (typeof ts.seconds === 'number') {
+        return ts.seconds * 1000 + Math.floor((ts.nanoseconds ?? 0) / 1e6);
+    }
+    return 0;
+};
+// Canonical display order for a LIST group's measurements, shared by
+// rock-desktop and rock-pro-app so cards, tables and exports all agree:
+// incomplete first, then by capture time. Callers that hide completed
+// measurements filter at render time — completed entries sort to the tail, so
+// the visible positional indexes are unaffected either way.
+export const sortMeasurementsByCompleted = (groupMeasurements) => {
+    return [...groupMeasurements].sort((a, b) => {
+        const isCompletedA = a.isCompleted === true;
+        const isCompletedB = b.isCompleted === true;
+        if (isCompletedA !== isCompletedB)
+            return isCompletedA ? 1 : -1;
+        const ms = createdAtMillis(a.createdAt) - createdAtMillis(b.createdAt);
+        if (ms !== 0)
+            return ms;
+        // Synced floods collapse createdAt into a millisecond-wide window and
+        // legacy data has identical timestamps for whole batches. Device capture
+        // sequence is the right tiebreaker — it's monotonic per device session.
+        const aNum = a.deviceMeasurementNumber;
+        const bNum = b.deviceMeasurementNumber;
+        if (aNum != null && bNum != null)
+            return aNum - bNum;
+        if (aNum != null)
+            return -1;
+        if (bNum != null)
+            return 1;
+        return 0;
+    });
+};

package/package.json

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