@reekon-tools/boldr-utils 1.16.0 → 1.17.1

package/dist/data/hooks/useAnnotationCanvasDoc.js

@@ -0,0 +1,314 @@
+import { useCallback, useEffect, useMemo, useRef, useState } from 'react';
+import { applyPatch, createEmptyCanvasState, } from '../../types/annotation.js';
+import { FileUploadType } from '../../types/firestore.js';
+import { useAnnotationDoc } from './useAnnotationDoc.js';
+import { useAnnotationMutations } from './useAnnotationMutations.js';
+import { hydrateCanvasState } from '../canvasPersistence.js';
+// Stable placeholder so useAnnotationMutations (which requires a non-null
+// scope) can be called unconditionally. Never used to write — flushes are
+// guarded on a real scope.
+const EMPTY_SCOPE = {
+    orgId: '',
+    projectId: '',
+    jobId: '',
+    groupId: '',
+};
+// Build the persisted fileData, omitting `isLabel` when undefined so the write
+// contains no undefined values (Firestore rejects them on RN).
+const buildFileData = (fileType, isLabel, canvas) => ({
+    fileType,
+    ...(isLabel !== undefined ? { isLabel } : {}),
+    canvas,
+});
+// Orchestrates load + auto-save for the annotation canvas. Hydrates the working
+// state from the persisted doc, applies commits optimistically, and persists
+// (debounced) through the data provider — creating the file on first save when
+// no `fileId` was supplied. Composes the existing low-level hooks so it stays
+// decoupled from any specific Firebase SDK.
+export const useAnnotationCanvasDoc = (options) => {
+    const { scope, fileId, fallbackViewport, debounceMs = 800, createSeed, onFileCreated, onSaveError, captureThumbnail, debugLogging = false, } = options;
+    const { data, loading, error } = useAnnotationDoc(scope, fileId);
+    const { create, update, uploadImage, deleteImage } = useAnnotationMutations(scope ?? EMPTY_SCOPE);
+    const [working, setWorking] = useState(null);
+    const [saveStatus, setSaveStatus] = useState('idle');
+    // Refs let the debounced/unmount flush read the latest values without
+    // re-creating timers on every keystroke.
+    const workingRef = useRef(null);
+    const dataRef = useRef(data);
+    const statusRef = useRef('idle');
+    const timerRef = useRef(null);
+    const createRef = useRef(create);
+    const updateRef = useRef(update);
+    const fileIdRef = useRef(fileId);
+    // Id of a file this hook created on first save (when opened with no fileId).
+    // Used for subsequent updates and to recognize the caller echoing it back
+    // into `fileId`.
+    const createdIdRef = useRef(null);
+    const createSeedRef = useRef(createSeed);
+    const onFileCreatedRef = useRef(onFileCreated);
+    const onSaveErrorRef = useRef(onSaveError);
+    const captureThumbnailRef = useRef(captureThumbnail);
+    const uploadImageRef = useRef(uploadImage);
+    // Guards against overlapping thumbnail captures (each save fires one).
+    const thumbnailSavingRef = useRef(false);
+    const debugRef = useRef(debugLogging);
+    // JSON of the canvas we last wrote, to recognize (and ignore) the snapshot
+    // echo of our own write when reconciling incoming remote changes.
+    const lastSavedJsonRef = useRef(null);
+    // Guards against two creates racing if flushes overlap.
+    const creatingRef = useRef(false);
+    workingRef.current = working;
+    dataRef.current = data;
+    statusRef.current = saveStatus;
+    createRef.current = create;
+    updateRef.current = update;
+    createSeedRef.current = createSeed;
+    onFileCreatedRef.current = onFileCreated;
+    onSaveErrorRef.current = onSaveError;
+    captureThumbnailRef.current = captureThumbnail;
+    uploadImageRef.current = uploadImage;
+    debugRef.current = debugLogging;
+    const setStatus = useCallback((next) => {
+        statusRef.current = next;
+        setSaveStatus(next);
+    }, []);
+    // Fire-and-forget thumbnail capture + upload, run after each successful save.
+    // Stable identity (reads refs) so it doesn't churn `flush`'s deps. Skips when
+    // no capturer is supplied or a capture is already in flight.
+    const saveThumbnail = useCallback(async (fileId) => {
+        const capture = captureThumbnailRef.current;
+        if (!capture || thumbnailSavingRef.current)
+            return;
+        thumbnailSavingRef.current = true;
+        try {
+            const blob = await capture();
+            if (blob)
+                await uploadImageRef.current(fileId, 'thumbnail', blob);
+        }
+        catch (e) {
+            console.warn('[useAnnotationCanvasDoc] thumbnail save failed', e);
+        }
+        finally {
+            thumbnailSavingRef.current = false;
+        }
+    }, []);
+    // Reset working state when the target document changes so the next snapshot
+    // hydrates the new file rather than leaking the previous one. Skip the reset
+    // when the new fileId is one we just created (the caller echoing it back) —
+    // our working state is already correct and must not be wiped.
+    useEffect(() => {
+        if (fileIdRef.current === fileId)
+            return;
+        fileIdRef.current = fileId;
+        if (fileId !== null && fileId === createdIdRef.current)
+            return;
+        if (timerRef.current) {
+            clearTimeout(timerRef.current);
+            timerRef.current = null;
+        }
+        createdIdRef.current = null;
+        lastSavedJsonRef.current = null;
+        setWorking(null);
+        setStatus('idle');
+    }, [fileId, setStatus]);
+    // Hydrate / reconcile from the persisted doc.
+    useEffect(() => {
+        // First load — always hydrate.
+        if (workingRef.current === null) {
+            setWorking(hydrateCanvasState(data, fallbackViewport));
+            lastSavedJsonRef.current = data?.fileData.canvas
+                ? JSON.stringify(data.fileData.canvas)
+                : null;
+            return;
+        }
+        // A write of ours is queued or in flight — ignore the snapshot; it is
+        // either the echo of our write or about to be superseded by it.
+        if (statusRef.current === 'saving' || timerRef.current !== null)
+            return;
+        // Clean locally: accept a genuine remote change, but ignore the echo of
+        // our own last write (same content).
+        const incoming = data?.fileData.canvas;
+        if (!incoming)
+            return;
+        const incomingJson = JSON.stringify(incoming);
+        if (incomingJson === lastSavedJsonRef.current)
+            return;
+        lastSavedJsonRef.current = incomingJson;
+        setWorking(hydrateCanvasState(data, fallbackViewport));
+        // eslint-disable-next-line react-hooks/exhaustive-deps
+    }, [data]);
+    const flush = useCallback(async () => {
+        if (timerRef.current) {
+            clearTimeout(timerRef.current);
+            timerRef.current = null;
+        }
+        const canvas = workingRef.current;
+        // Nothing to persist, or no real target scope yet.
+        if (!canvas || !scope)
+            return;
+        if (creatingRef.current)
+            return;
+        const json = JSON.stringify(canvas);
+        const id = fileIdRef.current ?? createdIdRef.current;
+        const mode = id ? 'update' : 'create';
+        const debug = debugRef.current;
+        if (debug) {
+            console.log('[useAnnotationCanvasDoc] save attempt', {
+                mode,
+                fileId: id,
+                scope,
+                bytes: json.length,
+                strokes: canvas.strokes.length,
+                shapes: canvas.shapes.length,
+                measurements: canvas.placedMeasurements.length,
+            });
+        }
+        // Round-trip through JSON to drop `undefined` keys (e.g. an empty canvas's
+        // viewport.backgroundImage/backgroundFit). Firestore — RN in particular —
+        // rejects undefined field values unless ignoreUndefinedProperties is set.
+        const canvasPayload = JSON.parse(json);
+        setStatus('saving');
+        try {
+            if (!id) {
+                // First save with no file — create the doc seeded with the canvas.
+                creatingRef.current = true;
+                const seed = createSeedRef.current;
+                const newId = await createRef.current({
+                    type: FileUploadType.Canvas,
+                    ...(seed?.name !== undefined ? { name: seed.name } : {}),
+                    fileData: buildFileData(seed?.fileType ?? 'sketch', seed?.isLabel, canvasPayload),
+                });
+                creatingRef.current = false;
+                createdIdRef.current = newId;
+                if (debug) {
+                    console.log('[useAnnotationCanvasDoc] created file', newId);
+                }
+                onFileCreatedRef.current?.(newId);
+            }
+            else {
+                const doc = dataRef.current;
+                await updateRef.current(id, {
+                    fileData: buildFileData(doc?.fileData.fileType ??
+                        createSeedRef.current?.fileType ??
+                        'sketch', doc?.fileData.isLabel ?? createSeedRef.current?.isLabel, canvasPayload),
+                });
+                if (debug) {
+                    console.log('[useAnnotationCanvasDoc] updated file', id);
+                }
+            }
+            lastSavedJsonRef.current = json;
+            // Refresh the file's thumbnail to match what was just saved (fire and
+            // forget — never blocks or fails the save).
+            const savedId = fileIdRef.current ?? createdIdRef.current;
+            if (savedId)
+                void saveThumbnail(savedId);
+            // If new edits landed mid-flight, stay dirty and let the next debounce
+            // (or unmount) flush them.
+            const latest = workingRef.current;
+            if (latest && JSON.stringify(latest) !== json) {
+                setStatus('dirty');
+            }
+            else {
+                setStatus('saved');
+            }
+        }
+        catch (e) {
+            creatingRef.current = false;
+            // Always log save failures with context — these are otherwise invisible
+            // (the canvas keeps working from local state).
+            console.error(`[useAnnotationCanvasDoc] ${mode} failed`, { fileId: id, scope, bytes: json.length }, e);
+            onSaveErrorRef.current?.(e);
+            setStatus('error');
+        }
+    }, [scope, setStatus, saveThumbnail]);
+    const onCommit = useCallback((patch) => {
+        setWorking((prev) => (prev ? applyPatch(prev, patch) : prev));
+        setStatus('dirty');
+        if (timerRef.current)
+            clearTimeout(timerRef.current);
+        timerRef.current = setTimeout(() => {
+            timerRef.current = null;
+            void flush();
+        }, debounceMs);
+    }, [debounceMs, flush, setStatus]);
+    const ensureFileId = useCallback(async () => {
+        const existing = fileIdRef.current ?? createdIdRef.current;
+        if (existing)
+            return existing;
+        // No file yet — seed an empty canvas if nothing has hydrated, then flush
+        // so the existing create branch mints the doc.
+        if (!workingRef.current) {
+            const seeded = createEmptyCanvasState(fallbackViewport);
+            workingRef.current = seeded;
+            setWorking(seeded);
+        }
+        await flush();
+        const id = fileIdRef.current ?? createdIdRef.current;
+        if (!id) {
+            throw new Error('Unable to create annotation file before background upload');
+        }
+        return id;
+    }, [flush, fallbackViewport]);
+    const setBackgroundImage = useCallback(async (blob, dims, fit = 'contain') => {
+        const id = await ensureFileId();
+        const ref = await uploadImage(id, 'background', blob);
+        onCommit({
+            ops: [
+                {
+                    op: 'setViewport',
+                    patch: {
+                        backgroundImage: {
+                            storagePath: ref.storagePath,
+                            downloadUrl: ref.downloadUrl,
+                            widthPx: dims.width,
+                            heightPx: dims.height,
+                        },
+                        backgroundFit: fit,
+                    },
+                },
+            ],
+        });
+    }, [ensureFileId, uploadImage, onCommit]);
+    const clearBackgroundImage = useCallback(async () => {
+        const bg = workingRef.current?.viewport.backgroundImage;
+        const id = fileIdRef.current ?? createdIdRef.current;
+        if (bg && id) {
+            try {
+                await deleteImage(id, bg.storagePath);
+            }
+            catch (e) {
+                // Non-fatal: still clear the viewport reference even if the storage
+                // object is already gone.
+                console.warn('[useAnnotationCanvasDoc] failed to delete background image', e);
+            }
+        }
+        onCommit({
+            ops: [
+                {
+                    op: 'setViewport',
+                    patch: { backgroundImage: undefined, backgroundFit: undefined },
+                },
+            ],
+        });
+    }, [deleteImage, onCommit]);
+    // Flush any pending edits on unmount.
+    useEffect(() => () => {
+        if (timerRef.current) {
+            clearTimeout(timerRef.current);
+            timerRef.current = null;
+            void flush();
+        }
+    }, [flush]);
+    const canvas = useMemo(() => working ?? createEmptyCanvasState(fallbackViewport), [working, fallbackViewport]);
+    return {
+        canvas,
+        onCommit,
+        loading,
+        error,
+        saveStatus,
+        save: flush,
+        ensureFileId,
+        setBackgroundImage,
+        clearBackgroundImage,
+    };
+};

package/dist/data/hooks/useAnnotationDoc.d.ts

@@ -0,0 +1,7 @@
+import type { AnnotationFile, JobGroupScope } from '../AnnotationDataProvider.js';
+export interface UseAnnotationDocResult {
+    data: AnnotationFile | null;
+    loading: boolean;
+    error: Error | null;
+}
+export declare const useAnnotationDoc: (scope: JobGroupScope | null, fileId: string | null) => UseAnnotationDocResult;

package/dist/data/hooks/useAnnotationDoc.js

@@ -0,0 +1,33 @@
+import { useEffect, useState } from 'react';
+import { useAnnotationData } from '../AnnotationDataContext.js';
+export const useAnnotationDoc = (scope, fileId) => {
+    const provider = useAnnotationData();
+    const [data, setData] = useState(null);
+    const [loading, setLoading] = useState(true);
+    const [error, setError] = useState(null);
+    useEffect(() => {
+        if (!scope || !fileId) {
+            setData(null);
+            setLoading(false);
+            return;
+        }
+        setLoading(true);
+        setError(null);
+        const unsubscribe = provider.subscribe(scope, fileId, (doc) => {
+            setData(doc);
+            setLoading(false);
+        }, (err) => {
+            setError(err);
+            setLoading(false);
+        });
+        return unsubscribe;
+    }, [
+        provider,
+        scope?.orgId,
+        scope?.projectId,
+        scope?.jobId,
+        scope?.groupId,
+        fileId,
+    ]);
+    return { data, loading, error };
+};

package/dist/data/hooks/useAnnotationList.d.ts

@@ -0,0 +1,7 @@
+import type { AnnotationFileSummary, JobGroupScope } from '../AnnotationDataProvider.js';
+export interface UseAnnotationListResult {
+    files: AnnotationFileSummary[];
+    loading: boolean;
+    error: Error | null;
+}
+export declare const useAnnotationList: (scope: JobGroupScope | null) => UseAnnotationListResult;

package/dist/data/hooks/useAnnotationList.js

@@ -0,0 +1,26 @@
+import { useEffect, useState } from 'react';
+import { useAnnotationData } from '../AnnotationDataContext.js';
+export const useAnnotationList = (scope) => {
+    const provider = useAnnotationData();
+    const [files, setFiles] = useState([]);
+    const [loading, setLoading] = useState(true);
+    const [error, setError] = useState(null);
+    useEffect(() => {
+        if (!scope) {
+            setFiles([]);
+            setLoading(false);
+            return;
+        }
+        setLoading(true);
+        setError(null);
+        const unsubscribe = provider.list(scope, (next) => {
+            setFiles(next);
+            setLoading(false);
+        }, (err) => {
+            setError(err);
+            setLoading(false);
+        });
+        return unsubscribe;
+    }, [provider, scope?.orgId, scope?.projectId, scope?.jobId, scope?.groupId]);
+    return { files, loading, error };
+};

package/dist/data/hooks/useAnnotationMutations.d.ts

@@ -0,0 +1,9 @@
+import type { AnnotationFile, ImageBlob, JobGroupScope, Patch, UploadedImageRef } from '../AnnotationDataProvider.js';
+export interface AnnotationMutations {
+    create(seed: Partial<AnnotationFile>): Promise<string>;
+    update(fileId: string, patch: Patch<AnnotationFile>): Promise<void>;
+    remove(fileId: string): Promise<void>;
+    uploadImage(fileId: string, role: 'background' | 'thumbnail', blob: ImageBlob): Promise<UploadedImageRef>;
+    deleteImage(fileId: string, storagePath: string): Promise<void>;
+}
+export declare const useAnnotationMutations: (scope: JobGroupScope) => AnnotationMutations;

package/dist/data/hooks/useAnnotationMutations.js

@@ -0,0 +1,11 @@
+import { useCallback, useMemo } from 'react';
+import { useAnnotationData } from '../AnnotationDataContext.js';
+export const useAnnotationMutations = (scope) => {
+    const provider = useAnnotationData();
+    const create = useCallback((seed) => provider.create(scope, seed), [provider, scope.orgId, scope.projectId, scope.jobId, scope.groupId]);
+    const update = useCallback((fileId, patch) => provider.update(scope, fileId, patch), [provider, scope.orgId, scope.projectId, scope.jobId, scope.groupId]);
+    const remove = useCallback((fileId) => provider.delete(scope, fileId), [provider, scope.orgId, scope.projectId, scope.jobId, scope.groupId]);
+    const uploadImage = useCallback((fileId, role, blob) => provider.uploadImage(scope, fileId, role, blob), [provider, scope.orgId, scope.projectId, scope.jobId, scope.groupId]);
+    const deleteImage = useCallback((fileId, storagePath) => provider.deleteImage(scope, fileId, storagePath), [provider, scope.orgId, scope.projectId, scope.jobId, scope.groupId]);
+    return useMemo(() => ({ create, update, remove, uploadImage, deleteImage }), [create, update, remove, uploadImage, deleteImage]);
+};

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

@@ -2,7 +2,7 @@ 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 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 = {

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/hooks/useParseMeasurement.d.ts

@@ -0,0 +1,4 @@
+export declare const useParseMeasurement: () => {
+    parseMeasurementInput: (input: string, defaultUnit?: string) => number | null;
+    error: string | null;
+};

package/dist/hooks/useParseMeasurement.js

@@ -0,0 +1,14 @@
+import { useState } from 'react';
+import { parseMeasurement } from '../utils/parseMeasurement.js';
+export const useParseMeasurement = () => {
+    const [error, setError] = useState(null);
+    const parseMeasurementInput = (input, defaultUnit = 'mm') => {
+        setError(null);
+        const result = parseMeasurement(input, defaultUnit);
+        if (result === null) {
+            setError('Invalid measurement. Please provide a valid number and unit.');
+        }
+        return result;
+    };
+    return { parseMeasurementInput, error };
+};