@reekon-tools/boldr-utils 1.6.11 → 1.6.12

package/dist/annotation/canvas/tools/selectTool.js

@@ -0,0 +1,310 @@
+import { STAMP_TILE_SIZE } from '../stampLayout.js';
+import { placementOf, linePosOf, snapLinePos, lerp, recomputeAnchor, } from '../measurementGeometry.js';
+const HIT_PADDING = 6;
+// Hit-test in doc-space. Crude but fast — good enough for v1; tools can
+// override via `hitTest` for more precision later.
+const hitStroke = (stroke, p) => {
+    const r = stroke.width / 2 + HIT_PADDING;
+    const r2 = r * r;
+    for (let i = 0; i < stroke.points.length - 2; i += 2) {
+        if (segmentDistanceSq(p.x, p.y, stroke.points[i], stroke.points[i + 1], stroke.points[i + 2], stroke.points[i + 3]) <= r2) {
+            return true;
+        }
+    }
+    return false;
+};
+// Screen-space grab tolerance (px) for a measurement-annotation line, converted
+// to doc space via zoom (the line itself is a thin world-space stroke).
+const LINE_GRAB_PX = 12;
+// Screen-px radius of the center snap detent when sliding a tile along its line.
+// Converted to t-space per line via (SNAP_PX / zoom) / lineLength. The native
+// slide worklet inlines the same value — keep them in sync.
+const SLIDE_SNAP_PX = 12;
+// Screen-px grab radius for a line-annotation endpoint handle (converted to doc
+// space via zoom). A bit larger than the drawn handle so it's easy to grab.
+const HANDLE_GRAB_PX = 22;
+const hitMeasurement = (m, p, zoom = 1) => {
+    // The stamp renders as a constant *screen*-size square centered on the
+    // anchor, so its doc-space footprint shrinks as you zoom in. Convert the
+    // screen-space half-extent (+ padding) back to doc space via the zoom so
+    // the hit box always matches what's drawn.
+    const scale = m.scale ?? 1;
+    const half = ((STAMP_TILE_SIZE * scale) / 2 + HIT_PADDING) / zoom;
+    const dx = Math.abs(p.x - m.anchor.x);
+    const dy = Math.abs(p.y - m.anchor.y);
+    if (dx <= half && dy <= half)
+        return true;
+    // Measurement annotation: also grab anywhere along the line body.
+    if (m.line) {
+        const r = LINE_GRAB_PX / zoom;
+        if (segmentDistanceSq(p.x, p.y, m.line.a.x, m.line.a.y, m.line.b.x, m.line.b.y) <=
+            r * r) {
+            return true;
+        }
+    }
+    return false;
+};
+const segmentDistanceSq = (px, py, ax, ay, bx, by) => {
+    const abx = bx - ax;
+    const aby = by - ay;
+    const lenSq = abx * abx + aby * aby;
+    let t = lenSq === 0 ? 0 : ((px - ax) * abx + (py - ay) * aby) / lenSq;
+    t = Math.max(0, Math.min(1, t));
+    const cx = ax + t * abx;
+    const cy = ay + t * aby;
+    const dx = px - cx;
+    const dy = py - cy;
+    return dx * dx + dy * dy;
+};
+const findHit = (doc, world, zoom) => {
+    // Hit-test in z-order (top first): measurements > shapes > strokes.
+    for (let i = doc.placedMeasurements.length - 1; i >= 0; i--) {
+        const m = doc.placedMeasurements[i];
+        if (hitMeasurement(m, world, zoom))
+            return { id: m.id, kind: 'measurement' };
+    }
+    for (let i = doc.shapes.length - 1; i >= 0; i--) {
+        // Default shape hit test: bounding box of the shape's points + padding.
+        const s = doc.shapes[i];
+        const pts = s.geometry.points;
+        if (pts.length === 0)
+            continue;
+        let minX = pts[0].x;
+        let maxX = pts[0].x;
+        let minY = pts[0].y;
+        let maxY = pts[0].y;
+        for (let j = 1; j < pts.length; j++) {
+            const p = pts[j];
+            if (p.x < minX)
+                minX = p.x;
+            if (p.x > maxX)
+                maxX = p.x;
+            if (p.y < minY)
+                minY = p.y;
+            if (p.y > maxY)
+                maxY = p.y;
+        }
+        if (world.x >= minX - HIT_PADDING &&
+            world.x <= maxX + HIT_PADDING &&
+            world.y >= minY - HIT_PADDING &&
+            world.y <= maxY + HIT_PADDING) {
+            return { id: s.id, kind: 'shape' };
+        }
+    }
+    for (let i = doc.strokes.length - 1; i >= 0; i--) {
+        const s = doc.strokes[i];
+        if (hitStroke(s, world))
+            return { id: s.id, kind: 'stroke' };
+    }
+    return null;
+};
+const translatePatch = (elementKind, id, doc, delta) => {
+    if (elementKind === 'measurement') {
+        const m = doc.placedMeasurements.find((x) => x.id === id);
+        if (!m)
+            return null;
+        // Group move: translate the whole annotation uniformly. `anchor` stays
+        // consistent with the line (lerp is affine, so translating both endpoints
+        // translates the anchor by the same delta). Only emit keys that exist so
+        // the patch never carries `undefined` (Firestore rejects undefined values).
+        const tx = (p) => ({ x: p.x + delta.x, y: p.y + delta.y });
+        const patch = { anchor: tx(m.anchor) };
+        if (m.line)
+            patch.line = { a: tx(m.line.a), b: tx(m.line.b) };
+        if (m.leader)
+            patch.leader = { from: tx(m.leader.from), to: tx(m.leader.to) };
+        return { op: 'updateMeasurement', id, patch };
+    }
+    if (elementKind === 'shape') {
+        const s = doc.shapes.find((x) => x.id === id);
+        if (!s)
+            return null;
+        return {
+            op: 'updateShape',
+            id,
+            patch: {
+                geometry: {
+                    ...s.geometry,
+                    points: s.geometry.points.map((p) => ({
+                        x: p.x + delta.x,
+                        y: p.y + delta.y,
+                    })),
+                },
+            },
+        };
+    }
+    const stroke = doc.strokes.find((x) => x.id === id);
+    if (!stroke)
+        return null;
+    const points = stroke.points.slice();
+    for (let i = 0; i < points.length; i += 2) {
+        points[i] = points[i] + delta.x;
+        points[i + 1] = points[i + 1] + delta.y;
+    }
+    return { op: 'updateStroke', id, patch: { points } };
+};
+// --- Measurement-annotation grab logic (shared by the native UI-thread drag
+// via DragSelectionConfig AND the web pointer handlers — one source of truth) ---
+// Grabbing the tile of a line annotation slides it along the line; everything
+// else (bare stamps, grabs on the line body) is a group move.
+const classifyGrab = (doc, id, world, zoom) => {
+    const m = doc.placedMeasurements.find((x) => x.id === id);
+    if (!m)
+        return 'move';
+    const scale = m.scale ?? 1;
+    const half = ((STAMP_TILE_SIZE * scale) / 2 + HIT_PADDING) / zoom;
+    const onTile = Math.abs(world.x - m.anchor.x) <= half &&
+        Math.abs(world.y - m.anchor.y) <= half;
+    return onTile && placementOf(m) === 'line' && m.line ? 'slide' : 'move';
+};
+// Slide the tile along its line by a world-space drag delta (relative to
+// grab-start), clamped to [0,1] with a center snap, and rewrite anchor. The
+// native slide worklet in AnnotationCanvasInner.native.tsx mirrors this math.
+const slidePatch = (doc, id, delta, zoom) => {
+    const m = doc.placedMeasurements.find((x) => x.id === id);
+    if (!m || !m.line || placementOf(m) !== 'line')
+        return null;
+    const abx = m.line.b.x - m.line.a.x;
+    const aby = m.line.b.y - m.line.a.y;
+    const lenSq = abx * abx + aby * aby;
+    if (lenSq === 0)
+        return null;
+    let t = linePosOf(m) + (delta.x * abx + delta.y * aby) / lenSq;
+    t = t < 0 ? 0 : t > 1 ? 1 : t;
+    const snapT = SLIDE_SNAP_PX / zoom / Math.sqrt(lenSq);
+    t = snapLinePos(t, snapT);
+    const anchor = lerp(m.line.a, m.line.b, t);
+    return { ops: [{ op: 'updateMeasurement', id, patch: { linePos: t, anchor } }] };
+};
+// Which endpoint handle of a (selected) line annotation is under `world`.
+// Prefers the nearer endpoint when both are within range.
+const findHandleHit = (doc, id, world, zoom) => {
+    const m = doc.placedMeasurements.find((x) => x.id === id);
+    if (!m || !m.line || placementOf(m) !== 'line')
+        return null;
+    const r2 = (HANDLE_GRAB_PX / zoom) ** 2;
+    const da = (world.x - m.line.a.x) ** 2 + (world.y - m.line.a.y) ** 2;
+    const db = (world.x - m.line.b.x) ** 2 + (world.y - m.line.b.y) ** 2;
+    if (da <= r2 && da <= db)
+        return 'a';
+    if (db <= r2)
+        return 'b';
+    return null;
+};
+// Move one endpoint by a world delta (resize/rotate); keep the tile at its
+// linePos by rewriting anchor.
+const endpointPatch = (doc, id, handle, delta) => {
+    const m = doc.placedMeasurements.find((x) => x.id === id);
+    if (!m || !m.line || placementOf(m) !== 'line')
+        return null;
+    const a = handle === 'a'
+        ? { x: m.line.a.x + delta.x, y: m.line.a.y + delta.y }
+        : m.line.a;
+    const b = handle === 'b'
+        ? { x: m.line.b.x + delta.x, y: m.line.b.y + delta.y }
+        : m.line.b;
+    const line = { a, b };
+    const anchor = recomputeAnchor(line, 'line', linePosOf(m), m.anchor);
+    return { ops: [{ op: 'updateMeasurement', id, patch: { line, anchor } }] };
+};
+// Patch for the current drag mode (web pointer path), from a world-space delta.
+const dragPatch = (s, doc, delta, zoom) => {
+    if (s.mode === 'endpoint' && s.handle) {
+        return endpointPatch(doc, s.id, s.handle, delta);
+    }
+    if (s.mode === 'slide')
+        return slidePatch(doc, s.id, delta, zoom);
+    const op = translatePatch(s.elementKind, s.id, doc, delta);
+    return op ? { ops: [op] } : null;
+};
+export const createSelectTool = () => ({
+    id: 'select',
+    label: 'Select',
+    cursor: 'default',
+    // Native drags the hit element on the UI thread (see DragSelectionConfig),
+    // reusing the same hit-test and translate logic the pointer handlers below
+    // use for web — one source of truth.
+    dragSelection: {
+        hitTest: (doc, world, zoom) => findHit(doc, world, zoom),
+        buildTranslatePatch: (doc, id, kind, delta) => {
+            const op = translatePatch(kind, id, doc, delta);
+            return op ? { ops: [op] } : null;
+        },
+        classifyMeasurementGrab: classifyGrab,
+        buildSlidePatch: slidePatch,
+        hitTestHandle: findHandleHit,
+        buildEndpointPatch: endpointPatch,
+    },
+    // Web pointer path. Mirrors the native UI-thread drag using the same shared
+    // helpers: an endpoint handle on the selected annotation resizes the line;
+    // grabbing a line-annotation tile slides it; everything else group-moves.
+    onPointerDown(event, ctx) {
+        const { world } = event;
+        const zoom = ctx.viewport.state.zoom;
+        // Endpoint handles show only on the selected annotation — check first.
+        const selId = ctx.selection?.ids[0];
+        if (selId) {
+            const handle = findHandleHit(ctx.document, selId, world, zoom);
+            if (handle) {
+                ctx.setSelection({ ids: [selId] });
+                return {
+                    kind: 'dragging',
+                    id: selId,
+                    elementKind: 'measurement',
+                    mode: 'endpoint',
+                    handle,
+                    start: world,
+                    delta: { x: 0, y: 0 },
+                };
+            }
+        }
+        const hit = findHit(ctx.document, world, zoom);
+        if (!hit) {
+            ctx.setSelection(null);
+            return { kind: 'idle' };
+        }
+        ctx.setSelection({ ids: [hit.id] });
+        const mode = hit.kind === 'measurement' &&
+            classifyGrab(ctx.document, hit.id, world, zoom) === 'slide'
+            ? 'slide'
+            : 'move';
+        return {
+            kind: 'dragging',
+            id: hit.id,
+            elementKind: hit.kind,
+            mode,
+            start: world,
+            delta: { x: 0, y: 0 },
+        };
+    },
+    onPointerMove(event, ctx, state) {
+        const s = state;
+        if (s?.kind !== 'dragging')
+            return s;
+        const delta = { x: event.world.x - s.start.x, y: event.world.y - s.start.y };
+        const patch = dragPatch(s, ctx.document, delta, ctx.viewport.state.zoom);
+        if (patch)
+            ctx.preview(patch);
+        return { ...s, delta };
+    },
+    onPointerUp(_event, ctx, state) {
+        const s = state;
+        if (s?.kind !== 'dragging')
+            return;
+        if (s.delta.x === 0 && s.delta.y === 0)
+            return;
+        const patch = dragPatch(s, ctx.document, s.delta, ctx.viewport.state.zoom);
+        if (patch)
+            ctx.commit(patch);
+    },
+    onCancel(_state, ctx) {
+        ctx.preview({ ops: [] });
+    },
+    hitTest(element, p) {
+        if (element.kind === 'measurement')
+            return hitMeasurement(element, p);
+        if (element.kind === 'stroke')
+            return hitStroke(element, p);
+        return false;
+    },
+});

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

@@ -1,5 +1,5 @@
-import type { Measurement } from '../types/firestore.js';
-import { type AnnotationCanvasState, type AnnotationDocumentPatch, type AnnotationStroke, type Selection, type Vec2 } from '../types/annotation.js';
+import type { Measurement } from '../../types/firestore.js';
+import { type AnnotationCanvasState, type AnnotationDocumentPatch, type AnnotationElementId, type AnnotationStroke, type MeasurementPlacement, type Selection, type Vec2 } from '../../types/annotation.js';
 import type { MeasurementRef } from './measurementPicker.js';
 import type { CanvasPointerEvent, Tool, ToolContext, ToolState } from './Tool.js';
 import { type ViewportState } from './viewport.js';
@@ -11,6 +11,12 @@ export interface AnnotationCanvasHandle {
     zoomToFit(): void;
     resetView(): void;
     placeMeasurementAtCenter(ref: MeasurementRef): void;
+    placeAnnotationAtCenter(opts?: {
+        defaultLengthDoc?: number;
+    }): void;
+    setAnnotationType(id: AnnotationElementId, type: MeasurementPlacement): void;
+    associateMeasurement(id: AnnotationElementId, ref: MeasurementRef): void;
+    deleteSelected(): void;
 }
 export interface UseAnnotationCanvasStateProps {
     canvas: AnnotationCanvasState;
@@ -50,5 +56,6 @@ export interface AnnotationCanvasStateApi {
     dispatchPointerCancel(): void;
     pan(deltaScreen: Vec2): void;
     zoom(focalScreen: Vec2, nextZoom: number): void;
+    setViewport(next: ViewportState): void;
 }
 export declare const useAnnotationCanvasState: (props: UseAnnotationCanvasStateProps) => AnnotationCanvasStateApi;

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

@@ -1,6 +1,7 @@
 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, 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).
@@ -164,6 +165,118 @@ 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')
+                    return; // not supported in v1
+                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 +319,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/{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,6 +1,6 @@
 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 { hydrateCanvasState } from '../canvasPersistence.js';

package/dist/exports.d.ts

@@ -2,27 +2,29 @@ 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, 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 { recomputeAnchor, projectToLinePos, snapLinePos, lerp, lineLength, placementOf, linePosOf, DEFAULT_LINE_POS, } from './annotation/canvas/measurementGeometry.js';
+export { toSkiaStrokeCap, arrowheadTriangle, arrowheadLength, } from './annotation/canvas/strokeGeometry.js';

package/dist/exports.js

@@ -6,23 +6,25 @@ 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 { recomputeAnchor, projectToLinePos, snapLinePos, lerp, lineLength, placementOf, linePosOf, 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';