@reekon-tools/boldr-utils 1.6.11 → 1.6.13

package/dist/{canvas → annotation/canvas}/useAnnotationCanvasState.js

@@ -1,11 +1,12 @@
 import { useCallback, useEffect, useMemo, useRef, useState } from 'react';
-import { applyPatch, invertPatch, DEFAULT_LAYER_ID, } from '../types/annotation.js';
+import { applyPatch, invertPatch, DEFAULT_LAYER_ID, } from '../../types/annotation.js';
 import { createViewportApi, panBy, zoomAt, DEFAULT_VIEWPORT, } from './viewport.js';
+import { recomputeAnchor, rectCenter, DEFAULT_LINE_POS, } from './measurementGeometry.js';
 // Platform-agnostic state machine for the annotation canvas. Web and native
 // inners share this hook; each wraps it with platform-specific event
 // capture and JSX (div + DOM events vs. GestureDetector + RN Views).
 export const useAnnotationCanvasState = (props) => {
-    const { canvas, onCommit, tools, activeToolId, selection, onSelectionChange, measurements, pickMeasurement, width, height, initialViewport, imperativeRef, } = props;
+    const { canvas, onCommit, tools, activeToolId, selection, onSelectionChange, measurements, pickMeasurement, requestTextInput, width, height, initialViewport, imperativeRef, } = props;
     const [viewport, setViewport] = useState(initialViewport ?? DEFAULT_VIEWPORT);
     const [toolState, setToolState] = useState(undefined);
     const [previewPatch, setPreviewPatch] = useState(null);
@@ -40,6 +41,9 @@ export const useAnnotationCanvasState = (props) => {
         requestPickMeasurement() {
             return pickMeasurement ? pickMeasurement() : Promise.resolve(null);
         },
+        requestTextInput(options) {
+            return requestTextInput ? requestTextInput(options) : Promise.resolve(null);
+        },
         applyPan(deltaScreen) {
             setViewport((v) => panBy(v, deltaScreen));
         },
@@ -53,6 +57,7 @@ export const useAnnotationCanvasState = (props) => {
         onCommit,
         onSelectionChange,
         pickMeasurement,
+        requestTextInput,
     ]);
     // Live ctx for imperative handle methods (which are created in an effect and
     // would otherwise capture a stale ctx/viewport).
@@ -164,6 +169,140 @@ export const useAnnotationCanvasState = (props) => {
                 // responsible for switching to its move/select tool).
                 c.setSelection({ ids: [placed.id] });
             },
+            placeAnnotationAtCenter(opts) {
+                const c = ctxRef.current;
+                const center = c.viewport.screenToWorld({
+                    x: width / 2,
+                    y: height / 2,
+                });
+                // Default line length: a quarter of the doc width, clamped to a sane
+                // range so it's a grabbable size at any canvas scale.
+                const len = opts?.defaultLengthDoc ??
+                    Math.min(400, Math.max(120, canvas.viewport.width * 0.25));
+                const line = {
+                    a: { x: center.x - len / 2, y: center.y },
+                    b: { x: center.x + len / 2, y: center.y },
+                };
+                const placed = {
+                    id: `annotation-${Date.now().toString(36)}-${Math.floor(Math.random() * 1e9).toString(36)}`,
+                    layerId: c.document.layers[0]?.id ?? DEFAULT_LAYER_ID,
+                    placement: 'line',
+                    line,
+                    linePos: DEFAULT_LINE_POS,
+                    // Center of the line; recomputeAnchor keeps this in sync on edits.
+                    anchor: recomputeAnchor(line, 'line', DEFAULT_LINE_POS, center),
+                    showLabel: true,
+                    showValue: true,
+                    createdAt: Date.now(),
+                };
+                c.commit({ ops: [{ op: 'addMeasurement', measurement: placed }] });
+                c.setSelection({ ids: [placed.id] });
+            },
+            setAnnotationType(id, type) {
+                const c = ctxRef.current;
+                const m = c.document.placedMeasurements.find((x) => x.id === id);
+                if (!m)
+                    return;
+                if (type === 'rectangle') {
+                    // Reuse the existing rect if the annotation had one; otherwise
+                    // synthesize a square centered on the anchor (same size clamp as
+                    // the default line) so the tile doesn't jump.
+                    const side = Math.min(400, Math.max(120, canvas.viewport.width * 0.25));
+                    const rect = m.rect ?? {
+                        a: { x: m.anchor.x - side / 2, y: m.anchor.y - side / 2 },
+                        b: { x: m.anchor.x + side / 2, y: m.anchor.y + side / 2 },
+                    };
+                    c.commit({
+                        ops: [
+                            {
+                                op: 'updateMeasurement',
+                                id,
+                                patch: {
+                                    placement: 'rectangle',
+                                    rect,
+                                    anchor: rectCenter(rect),
+                                },
+                            },
+                        ],
+                    });
+                    return;
+                }
+                if (type === 'line') {
+                    let line = m.line;
+                    if (!line) {
+                        const len = Math.min(400, Math.max(120, canvas.viewport.width * 0.25));
+                        line = {
+                            a: { x: m.anchor.x - len / 2, y: m.anchor.y },
+                            b: { x: m.anchor.x + len / 2, y: m.anchor.y },
+                        };
+                    }
+                    const linePos = m.linePos ?? DEFAULT_LINE_POS;
+                    c.commit({
+                        ops: [
+                            {
+                                op: 'updateMeasurement',
+                                id,
+                                patch: {
+                                    placement: 'line',
+                                    line,
+                                    linePos,
+                                    anchor: recomputeAnchor(line, 'line', linePos, m.anchor),
+                                },
+                            },
+                        ],
+                    });
+                    return;
+                }
+                // 'none' — bare stamp. Keep the anchor (and the line data, which simply
+                // stops rendering); switching back to 'line' restores it.
+                c.commit({
+                    ops: [{ op: 'updateMeasurement', id, patch: { placement: 'none' } }],
+                });
+            },
+            associateMeasurement(id, ref) {
+                const c = ctxRef.current;
+                c.commit({
+                    ops: [
+                        {
+                            op: 'updateMeasurement',
+                            id,
+                            patch: {
+                                measurementId: ref.measurementId,
+                                measurementPath: ref.measurementPath,
+                                groupId: ref.groupId,
+                                labelOverride: ref.label,
+                                unitOverride: ref.unit,
+                            },
+                        },
+                    ],
+                });
+            },
+            deleteSelected() {
+                const c = ctxRef.current;
+                const ids = c.selection?.ids;
+                if (!ids || ids.length === 0)
+                    return;
+                const idSet = new Set(ids);
+                const doc = c.document;
+                // Build one remove op per selected element, dispatched by which
+                // collection owns the id. A single multi-op commit makes the whole
+                // deletion one undo step (inverse re-adds each element).
+                const ops = [
+                    ...doc.strokes
+                        .filter((s) => idSet.has(s.id))
+                        .map((s) => ({ op: 'removeStroke', id: s.id })),
+                    ...doc.shapes
+                        .filter((s) => idSet.has(s.id))
+                        .map((s) => ({ op: 'removeShape', id: s.id })),
+                    ...doc.placedMeasurements
+                        .filter((m) => idSet.has(m.id))
+                        .map((m) => ({ op: 'removeMeasurement', id: m.id })),
+                ];
+                if (ops.length === 0)
+                    return;
+                c.commit({ ops });
+                c.setSelection(null);
+            },
         };
         return () => {
             if (imperativeRef)
@@ -206,5 +345,6 @@ export const useAnnotationCanvasState = (props) => {
         dispatchPointerCancel,
         pan,
         zoom,
+        setViewport,
     };
 };

package/dist/{canvas → annotation/canvas}/viewport.d.ts

@@ -1,4 +1,4 @@
-import type { Vec2 } from '../types/annotation.js';
+import type { Vec2 } from '../../types/annotation.js';
 export interface ViewportState {
     zoom: number;
     pan: Vec2;

package/dist/{data → annotation/data}/AnnotationDataProvider.d.ts

@@ -1,4 +1,4 @@
-import type { FileUpload, FileUploadType, Measurement } from '../types/firestore.js';
+import type { FileUpload, FileUploadType, Measurement } from '../../types/firestore.js';
 export interface JobScope {
     orgId: string;
     projectId: string;

package/dist/{data → annotation/data}/InMemoryAnnotationProvider.d.ts

@@ -1,4 +1,4 @@
-import { type Measurement } from '../types/firestore.js';
+import { type Measurement } from '../../types/firestore.js';
 import { type AnnotationDataProvider, type AnnotationFile, type AnnotationFileSummary, type ImageBlob, type JobGroupScope, type JobScope, type Patch, type Unsubscribe, type UploadedImageRef } from './AnnotationDataProvider.js';
 export declare class InMemoryAnnotationProvider implements AnnotationDataProvider {
     private docs;

package/dist/{data → annotation/data}/InMemoryAnnotationProvider.js

@@ -1,4 +1,4 @@
-import { FileUploadType } from '../types/firestore.js';
+import { FileUploadType } from '../../types/firestore.js';
 import { isFieldOp, } from './AnnotationDataProvider.js';
 const scopeKey = (s) => `${s.orgId}/${s.projectId}/${s.jobId}/${s.groupId}`;
 const jobKey = (s) => `${s.orgId}/${s.projectId}/${s.jobId}`;

package/dist/{data → annotation/data}/canvasPersistence.d.ts

@@ -1,3 +1,3 @@
-import { type AnnotationCanvasState, type AnnotationViewport } from '../types/annotation.js';
+import { type AnnotationCanvasState, type AnnotationViewport } from '../../types/annotation.js';
 import type { AnnotationFile } from './AnnotationDataProvider.js';
 export declare const hydrateCanvasState: (file: AnnotationFile | null, fallbackViewport?: Partial<AnnotationViewport>) => AnnotationCanvasState;

package/dist/{data → annotation/data}/canvasPersistence.js

@@ -1,4 +1,4 @@
-import { createEmptyCanvasState, } from '../types/annotation.js';
+import { createEmptyCanvasState, } from '../../types/annotation.js';
 // Bring a persisted canvas forward to the current schema. Keyed on
 // `schemaVersion` so each client migrates identically and the provider can
 // stay a dumb transport. Identity for v1 today; add a `case 1: return

package/dist/annotation/data/coalescedRunner.d.ts

@@ -0,0 +1 @@
+export declare const createCoalescedRunner: (task: () => Promise<void>) => (() => Promise<void>);

package/dist/annotation/data/coalescedRunner.js

@@ -0,0 +1,48 @@
+// A single-flight async runner with trailing coalescing.
+//
+// Wraps an async `task` so that overlapping callers don't run it concurrently
+// and don't drop work:
+//   • While a run is in flight, every additional call returns that same
+//     in-flight promise (single-flight) instead of starting a second run.
+//   • If any call arrives during a run, exactly ONE trailing run is scheduled
+//     after the current one finishes — so work that arrived mid-run is never
+//     lost. The trailing run re-invokes `task`, which is expected to re-read the
+//     latest state each time (it takes no arguments by design).
+//   • The returned promise resolves only once the chain is fully drained, so an
+//     `await`-ing caller can rely on all queued work having completed.
+//   • A task rejection is propagated to the awaiting callers of that run but
+//     does NOT wedge the runner: `inFlight` is always cleared, and a pending
+//     trailing run still fires, so the runner self-heals after a transient
+//     failure.
+//
+// This is the concurrency primitive behind the annotation autosave/flush: it
+// guarantees a create-on-first-save can't race a concurrent flush (the old
+// boolean-guard approach silently dropped the second writer).
+export const createCoalescedRunner = (task) => {
+    let inFlight = null;
+    let pending = false;
+    const run = () => {
+        if (inFlight) {
+            // A run is already underway — remember that more work arrived and join
+            // the in-flight promise rather than starting a second concurrent run.
+            pending = true;
+            return inFlight;
+        }
+        inFlight = (async () => {
+            try {
+                await task();
+            }
+            finally {
+                inFlight = null;
+                if (pending) {
+                    // Work arrived mid-run: drain it with a single trailing run, which
+                    // re-reads the latest state. Recurses until quiescent.
+                    pending = false;
+                    await run();
+                }
+            }
+        })();
+        return inFlight;
+    };
+    return run;
+};

package/dist/{data → annotation/data}/hooks/useAnnotationCanvasDoc.d.ts

@@ -1,4 +1,4 @@
-import { type AnnotationCanvasState, type AnnotationDocumentPatch, type AnnotationViewport, type BackgroundFit } from '../../types/annotation.js';
+import { type AnnotationCanvasState, type AnnotationDocumentPatch, type AnnotationViewport, type BackgroundFit } from '../../../types/annotation.js';
 import type { ImageBlob, JobGroupScope } from '../AnnotationDataProvider.js';
 export type SaveStatus = 'idle' | 'dirty' | 'saving' | 'saved' | 'error';
 export interface UseAnnotationCanvasDocOptions {

package/dist/{data → annotation/data}/hooks/useAnnotationCanvasDoc.js

@@ -1,8 +1,9 @@
 import { useCallback, useEffect, useMemo, useRef, useState } from 'react';
-import { applyPatch, createEmptyCanvasState, } from '../../types/annotation.js';
-import { FileUploadType } from '../../types/firestore.js';
+import { applyPatch, createEmptyCanvasState, } from '../../../types/annotation.js';
+import { FileUploadType } from '../../../types/firestore.js';
 import { useAnnotationDoc } from './useAnnotationDoc.js';
 import { useAnnotationMutations } from './useAnnotationMutations.js';
+import { createCoalescedRunner } from '../coalescedRunner.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
@@ -55,8 +56,6 @@ export const useAnnotationCanvasDoc = (options) => {
     // 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;
@@ -137,17 +136,17 @@ export const useAnnotationCanvasDoc = (options) => {
         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;
-        }
+    // One pass of the persist logic: snapshots the latest working state and
+    // creates-or-updates the doc. NOT called directly — it runs through the
+    // single-flight `flush` below, which guarantees two passes never overlap (so
+    // a create-on-first-save can't race a concurrent flush) and re-invokes this
+    // to drain any work that arrived mid-pass. Because it re-reads `workingRef`
+    // each call, a trailing pass always persists the newest canvas.
+    const runFlush = useCallback(async () => {
         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';
@@ -171,14 +170,12 @@ export const useAnnotationCanvasDoc = (options) => {
         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);
@@ -213,14 +210,34 @@ export const useAnnotationCanvasDoc = (options) => {
             }
         }
         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');
+            // Swallowed (not re-thrown): autosave/unmount call this fire-and-forget,
+            // and the canvas keeps working from local state. Callers that need to know
+            // a create succeeded (ensureFileId) detect it via the absence of an id
+            // after the flush drains, not via a rejection.
         }
     }, [scope, setStatus, saveThumbnail]);
+    // Stable indirection so the coalesced runner (created once) always calls the
+    // latest `runFlush` without being re-created when its deps change.
+    const runFlushRef = useRef(runFlush);
+    runFlushRef.current = runFlush;
+    // Single-flight runner: concurrent callers join the in-flight pass; work that
+    // arrives mid-pass triggers exactly one trailing pass. Created once.
+    const flushRunner = useMemo(() => createCoalescedRunner(() => runFlushRef.current()), []);
+    // Public flush: cancel any pending debounce, then run (or join) a persist
+    // pass. Resolves once the chain is fully drained, so `await flush()` is safe
+    // for create-before-upload and explicit Save.
+    const flush = useCallback(() => {
+        if (timerRef.current) {
+            clearTimeout(timerRef.current);
+            timerRef.current = null;
+        }
+        return flushRunner();
+    }, [flushRunner]);
     const onCommit = useCallback((patch) => {
         setWorking((prev) => (prev ? applyPatch(prev, patch) : prev));
         setStatus('dirty');
@@ -235,8 +252,12 @@ export const useAnnotationCanvasDoc = (options) => {
         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.
+        // No file yet — seed an empty canvas if nothing has hydrated, then flush so
+        // the create branch mints the doc. `flush` is single-flight: if the
+        // debounced autosave is already creating, this call JOINS that create and
+        // waits for it to drain (rather than racing it and dropping the upload, the
+        // old bug). After the drain, the id is present unless the create truly
+        // failed — so the throw below is now a genuine error, not a race.
         if (!workingRef.current) {
             const seeded = createEmptyCanvasState(fallbackViewport);
             workingRef.current = seeded;

package/dist/exports.d.ts

@@ -2,27 +2,31 @@ export { evaluateFormula, createFormulaScope, createEnhancedFormulaScope, clearF
 export { calculateFormula } from './formulas/calculateFormula.js';
 export { convertMicrometers } from './utils/micrometersToUnit.js';
 export { parseMeasurement } from './utils/parseMeasurement.js';
-export { useParseMeasurement } from './hooks/useParseMeasurement.js';
+export { useParseMeasurement } from './utils/useParseMeasurement.js';
 export * from './types/firestore.js';
 export * from './types/layout.js';
 export * from './types/annotation.js';
 export { getToleranceColor, calculateDeviationPercentage, isWithinTolerance, generateToleranceGradient, createDefaultToleranceThresholds, DEFAULT_TOLERANCE_COLORS, type ToleranceThreshold, type ToleranceConfig, } from './utils/tolerance.js';
 export { DEFAULT_GROUP_INDEX, isDefaultGroup, findDefaultGroup, } from './utils/groups.js';
-export { isFieldOp, type AnnotationDataProvider, type AnnotationFile, type AnnotationFileSummary, type FieldOp, type ImageBlob, type JobGroupScope, type JobScope, type Patch, type Unsubscribe, type UploadedImageRef, } from './data/AnnotationDataProvider.js';
-export { AnnotationDataProviderContext, useAnnotationData, type AnnotationDataProviderProps, } from './data/AnnotationDataContext.js';
-export { useAnnotationDoc, type UseAnnotationDocResult, } from './data/hooks/useAnnotationDoc.js';
-export { useAnnotationList, type UseAnnotationListResult, } from './data/hooks/useAnnotationList.js';
-export { useAnnotationMutations, type AnnotationMutations, } from './data/hooks/useAnnotationMutations.js';
-export { useAnnotationCanvasDoc, type SaveStatus, type UseAnnotationCanvasDocOptions, type UseAnnotationCanvasDocResult, } from './data/hooks/useAnnotationCanvasDoc.js';
-export { hydrateCanvasState } from './data/canvasPersistence.js';
-export { InMemoryAnnotationProvider } from './data/InMemoryAnnotationProvider.js';
-export type { AnnotationCanvasHandle } from './canvas/useAnnotationCanvasState.js';
-export type { GestureConfig, PanTrigger, AnnotationCanvasInnerProps, } from './canvas/AnnotationCanvasInner.js';
-export type { CanvasPointerEvent, Tool, ToolContext, ToolState, } from './canvas/Tool.js';
-export type { MeasurementRef, PickMeasurement, } from './canvas/measurementPicker.js';
-export type { MeasurementStampRenderArgs, RenderMeasurementStamp, } from './canvas/measurementStampOverlay.js';
-export { createViewportApi, fitToScreen, panBy, zoomAt, DEFAULT_VIEWPORT, type ViewportApi, type ViewportState, } from './canvas/viewport.js';
-export { createPenTool, type PenToolOptions } from './canvas/tools/penTool.js';
-export { createSelectTool } from './canvas/tools/selectTool.js';
-export { createMeasurementStampTool, type MeasurementStampToolOptions, } from './canvas/tools/measurementStampTool.js';
-export { createPanTool, type PanToolOptions } from './canvas/tools/panTool.js';
+export { isFieldOp, type AnnotationDataProvider, type AnnotationFile, type AnnotationFileSummary, type FieldOp, type ImageBlob, type JobGroupScope, type JobScope, type Patch, type Unsubscribe, type UploadedImageRef, } from './annotation/data/AnnotationDataProvider.js';
+export { AnnotationDataProviderContext, useAnnotationData, type AnnotationDataProviderProps, } from './annotation/data/AnnotationDataContext.js';
+export { useAnnotationDoc, type UseAnnotationDocResult, } from './annotation/data/hooks/useAnnotationDoc.js';
+export { useAnnotationList, type UseAnnotationListResult, } from './annotation/data/hooks/useAnnotationList.js';
+export { useAnnotationMutations, type AnnotationMutations, } from './annotation/data/hooks/useAnnotationMutations.js';
+export { useAnnotationCanvasDoc, type SaveStatus, type UseAnnotationCanvasDocOptions, type UseAnnotationCanvasDocResult, } from './annotation/data/hooks/useAnnotationCanvasDoc.js';
+export { hydrateCanvasState } from './annotation/data/canvasPersistence.js';
+export { InMemoryAnnotationProvider } from './annotation/data/InMemoryAnnotationProvider.js';
+export type { AnnotationCanvasHandle } from './annotation/canvas/useAnnotationCanvasState.js';
+export type { GestureConfig, PanTrigger, AnnotationCanvasInnerProps, } from './annotation/canvas/AnnotationCanvasInner.js';
+export type { CanvasPointerEvent, RequestTextInput, Tool, ToolContext, ToolState, } from './annotation/canvas/Tool.js';
+export type { MeasurementRef, PickMeasurement, } from './annotation/canvas/measurementPicker.js';
+export type { MeasurementStampRenderArgs, RenderMeasurementStamp, } from './annotation/canvas/measurementStampOverlay.js';
+export { createViewportApi, fitToScreen, panBy, zoomAt, DEFAULT_VIEWPORT, type ViewportApi, type ViewportState, } from './annotation/canvas/viewport.js';
+export { createPenTool, type PenToolOptions } from './annotation/canvas/tools/penTool.js';
+export { createSelectTool } from './annotation/canvas/tools/selectTool.js';
+export { createMeasurementStampTool, type MeasurementStampToolOptions, } from './annotation/canvas/tools/measurementStampTool.js';
+export { createPanTool, type PanToolOptions } from './annotation/canvas/tools/panTool.js';
+export { createTextTool, type TextToolOptions, } from './annotation/canvas/tools/textTool.js';
+export { DEFAULT_TEXT_FONT_SIZE, MIN_TEXT_FONT_SIZE, MAX_TEXT_FONT_SIZE, textShapeBounds, textResizeGeometry, type ResizeGeometry, type TextBounds, } from './annotation/canvas/textGeometry.js';
+export { recomputeAnchor, projectToLinePos, snapLinePos, lerp, lineLength, placementOf, linePosOf, normalizeRect, rectCenter, rectCornerPoint, oppositeRectCorner, DEFAULT_LINE_POS, type NormalizedRect, type RectCorner, } from './annotation/canvas/measurementGeometry.js';
+export { toSkiaStrokeCap, arrowheadTriangle, arrowheadLength, } from './annotation/canvas/strokeGeometry.js';

package/dist/exports.js

@@ -6,23 +6,27 @@ export { evaluateFormula, createFormulaScope, createEnhancedFormulaScope, clearF
 export { calculateFormula } from './formulas/calculateFormula.js';
 export { convertMicrometers } from './utils/micrometersToUnit.js';
 export { parseMeasurement } from './utils/parseMeasurement.js';
-export { useParseMeasurement } from './hooks/useParseMeasurement.js';
+export { useParseMeasurement } from './utils/useParseMeasurement.js';
 export * from './types/firestore.js';
 export * from './types/layout.js';
 export * from './types/annotation.js';
 export { getToleranceColor, calculateDeviationPercentage, isWithinTolerance, generateToleranceGradient, createDefaultToleranceThresholds, DEFAULT_TOLERANCE_COLORS, } from './utils/tolerance.js';
 export { DEFAULT_GROUP_INDEX, isDefaultGroup, findDefaultGroup, } from './utils/groups.js';
 // Annotation data layer (SDK-neutral; apps provide their own provider).
-export { isFieldOp, } from './data/AnnotationDataProvider.js';
-export { AnnotationDataProviderContext, useAnnotationData, } from './data/AnnotationDataContext.js';
-export { useAnnotationDoc, } from './data/hooks/useAnnotationDoc.js';
-export { useAnnotationList, } from './data/hooks/useAnnotationList.js';
-export { useAnnotationMutations, } from './data/hooks/useAnnotationMutations.js';
-export { useAnnotationCanvasDoc, } from './data/hooks/useAnnotationCanvasDoc.js';
-export { hydrateCanvasState } from './data/canvasPersistence.js';
-export { InMemoryAnnotationProvider } from './data/InMemoryAnnotationProvider.js';
-export { createViewportApi, fitToScreen, panBy, zoomAt, DEFAULT_VIEWPORT, } from './canvas/viewport.js';
-export { createPenTool } from './canvas/tools/penTool.js';
-export { createSelectTool } from './canvas/tools/selectTool.js';
-export { createMeasurementStampTool, } from './canvas/tools/measurementStampTool.js';
-export { createPanTool } from './canvas/tools/panTool.js';
+export { isFieldOp, } from './annotation/data/AnnotationDataProvider.js';
+export { AnnotationDataProviderContext, useAnnotationData, } from './annotation/data/AnnotationDataContext.js';
+export { useAnnotationDoc, } from './annotation/data/hooks/useAnnotationDoc.js';
+export { useAnnotationList, } from './annotation/data/hooks/useAnnotationList.js';
+export { useAnnotationMutations, } from './annotation/data/hooks/useAnnotationMutations.js';
+export { useAnnotationCanvasDoc, } from './annotation/data/hooks/useAnnotationCanvasDoc.js';
+export { hydrateCanvasState } from './annotation/data/canvasPersistence.js';
+export { InMemoryAnnotationProvider } from './annotation/data/InMemoryAnnotationProvider.js';
+export { createViewportApi, fitToScreen, panBy, zoomAt, DEFAULT_VIEWPORT, } from './annotation/canvas/viewport.js';
+export { createPenTool } from './annotation/canvas/tools/penTool.js';
+export { createSelectTool } from './annotation/canvas/tools/selectTool.js';
+export { createMeasurementStampTool, } from './annotation/canvas/tools/measurementStampTool.js';
+export { createPanTool } from './annotation/canvas/tools/panTool.js';
+export { createTextTool, } from './annotation/canvas/tools/textTool.js';
+export { DEFAULT_TEXT_FONT_SIZE, MIN_TEXT_FONT_SIZE, MAX_TEXT_FONT_SIZE, textShapeBounds, textResizeGeometry, } from './annotation/canvas/textGeometry.js';
+export { recomputeAnchor, projectToLinePos, snapLinePos, lerp, lineLength, placementOf, linePosOf, normalizeRect, rectCenter, rectCornerPoint, oppositeRectCorner, DEFAULT_LINE_POS, } from './annotation/canvas/measurementGeometry.js';
+export { toSkiaStrokeCap, arrowheadTriangle, arrowheadLength, } from './annotation/canvas/strokeGeometry.js';

package/dist/index.d.ts

@@ -3,8 +3,8 @@ export { evaluateFormula, createFormulaScope, createEnhancedFormulaScope, clearF
 export { calculateFormula } from './formulas/calculateFormula.js';
 export { convertMicrometers } from './utils/micrometersToUnit.js';
 export { parseMeasurement } from './utils/parseMeasurement.js';
-export { useParseMeasurement } from './hooks/useParseMeasurement.js';
+export { useParseMeasurement } from './utils/useParseMeasurement.js';
 export * from './types/firestore.js';
 export * from './types/layout.js';
 export { getToleranceColor, getToleranceSecondaryColor, calculateDeviationPercentage, isWithinTolerance, generateToleranceGradient, createDefaultToleranceThresholds, DEFAULT_TOLERANCE_COLORS, DEFAULT_TOLERANCE_SECONDARY_COLORS, type ToleranceThreshold, type ToleranceConfig, } from './utils/tolerance.js';
-export { AnnotationCanvas, type AnnotationCanvasProps, type CanvasKitOpts, } from './canvas/AnnotationCanvas.js';
+export { AnnotationCanvas, type AnnotationCanvasProps, type CanvasKitOpts, } from './annotation/canvas/AnnotationCanvas.js';

package/dist/index.js

@@ -7,8 +7,8 @@ export { evaluateFormula, createFormulaScope, createEnhancedFormulaScope, clearF
 export { calculateFormula } from './formulas/calculateFormula.js';
 export { convertMicrometers } from './utils/micrometersToUnit.js';
 export { parseMeasurement } from './utils/parseMeasurement.js';
-export { useParseMeasurement } from './hooks/useParseMeasurement.js';
+export { useParseMeasurement } from './utils/useParseMeasurement.js';
 export * from './types/firestore.js';
 export * from './types/layout.js';
 export { getToleranceColor, getToleranceSecondaryColor, calculateDeviationPercentage, isWithinTolerance, generateToleranceGradient, createDefaultToleranceThresholds, DEFAULT_TOLERANCE_COLORS, DEFAULT_TOLERANCE_SECONDARY_COLORS, } from './utils/tolerance.js';
-export { AnnotationCanvas, } from './canvas/AnnotationCanvas.js';
+export { AnnotationCanvas, } from './annotation/canvas/AnnotationCanvas.js';

package/dist/index.native.d.ts

@@ -1,5 +1,5 @@
 export * from './exports.js';
-export { AnnotationCanvas, type AnnotationCanvasProps, } from './canvas/AnnotationCanvas.native.js';
+export { AnnotationCanvas, type AnnotationCanvasProps, } from './annotation/canvas/AnnotationCanvas.native.js';
 export interface CanvasKitOpts {
     locateFile?: (file: string) => string;
 }

package/dist/index.native.js

@@ -3,4 +3,4 @@
 // WithSkiaWeb / canvaskit-wasm), avoiding the `fs` import that Metro
 // chokes on.
 export * from './exports.js';
-export { AnnotationCanvas, } from './canvas/AnnotationCanvas.native.js';
+export { AnnotationCanvas, } from './annotation/canvas/AnnotationCanvas.native.js';

package/dist/types/annotation.d.ts

@@ -5,12 +5,15 @@ export interface Vec2 {
     x: number;
     y: number;
 }
+export type StrokeCap = 'butt' | 'round' | 'square' | 'arrow';
 export interface AnnotationStroke {
     id: AnnotationElementId;
     layerId: AnnotationLayerId;
     tool: 'pen' | 'marker' | 'highlighter';
     color: string;
     width: number;
+    cap?: StrokeCap;
+    dash?: boolean;
     points: number[];
     pressure?: number[];
     createdAt: number;
@@ -22,6 +25,7 @@ export interface AnnotationShapeStyle {
     strokeWidth?: number;
     fontSize?: number;
     fontFamily?: string;
+    dash?: boolean;
 }
 export interface AnnotationShape {
     id: AnnotationElementId;
@@ -35,13 +39,28 @@ export interface AnnotationShape {
     text?: string;
     createdAt: number;
 }
+export type MeasurementPlacement = 'none' | 'line' | 'rectangle';
 export interface PlacedMeasurementRef {
     id: AnnotationElementId;
     layerId: AnnotationLayerId;
-    measurementPath: string;
-    measurementId: string;
-    groupId: string;
+    measurementPath?: string;
+    measurementId?: string;
+    groupId?: string;
     anchor: Vec2;
+    placement?: MeasurementPlacement;
+    line?: {
+        a: Vec2;
+        b: Vec2;
+    };
+    linePos?: number;
+    rect?: {
+        a: Vec2;
+        b: Vec2;
+    };
+    lineColor?: string;
+    lineWidth?: number;
+    lineCap?: StrokeCap;
+    lineDash?: boolean;
     leader?: {
         from: Vec2;
         to: Vec2;

package/dist/types/firestore.d.ts

@@ -220,7 +220,6 @@ export interface Section extends Timestamps {
     tableConfig: ColumnConfig[];
     measurements: string[];
     isTemplate?: boolean;
-    viewMode?: 'rows' | 'columns' | 'transposed';
 }
 export interface Group extends FirestoreDoc, Timestamps {
     sectionId: string;

package/dist/{hooks → utils}/useParseMeasurement.js

@@ -1,5 +1,5 @@
 import { useState } from 'react';
-import { parseMeasurement } from '../utils/parseMeasurement.js';
+import { parseMeasurement } from './parseMeasurement.js';
 export const useParseMeasurement = () => {
     const [error, setError] = useState(null);
     const parseMeasurementInput = (input, defaultUnit = 'mm') => {

package/package.json

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