@reekon-tools/boldr-utils 1.6.13 → 1.6.15

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

@@ -0,0 +1,133 @@
+import { DEFAULT_LAYER_ID } from '../../../types/annotation.js';
+import { DEFAULT_LINE_POS, recomputeAnchor, rectCenter, } from '../measurementGeometry.js';
+let counter = 0;
+const makeId = () => `annotation-${Date.now().toString(36)}-${(counter++).toString(36)}`;
+const firstLayerId = (doc) => doc.layers[0]?.id ?? DEFAULT_LAYER_ID;
+// Build the blank measurement annotation for a drag a→b (or a single point for
+// the bare stamp). The payload mirrors useAnnotationCanvasState's
+// placeAnnotationAtCenter so a drawn annotation is identical to a (legacy)
+// center-placed one once committed.
+const buildMeasurement = (opts) => {
+    const { id, layerId, placement, linePos, a, b } = opts;
+    const base = {
+        id,
+        layerId,
+        showLabel: true,
+        showValue: true,
+        createdAt: Date.now(),
+    };
+    if (placement === 'rectangle') {
+        const rect = { a, b };
+        return { ...base, placement: 'rectangle', rect, anchor: rectCenter(rect) };
+    }
+    if (placement === 'none') {
+        // Bare value tile at the tap point — no line/rect geometry.
+        return { ...base, placement: 'none', anchor: b };
+    }
+    const line = { a, b };
+    return {
+        ...base,
+        placement: 'line',
+        line,
+        linePos,
+        // Tile anchored along the line at linePos; recomputeAnchor keeps it in
+        // sync on later edits.
+        anchor: recomputeAnchor(line, 'line', linePos, {
+            x: (a.x + b.x) / 2,
+            y: (a.y + b.y) / 2,
+        }),
+    };
+};
+// Draw-to-add measurement tool. For 'line'/'rectangle' a press-drag rubber-bands
+// the annotation (a line/rect with a blank value tile) and release commits it;
+// for 'none' a tap drops a bare value tile. Mirrors createShapeTool's
+// interaction so measurements are placed the same way as shapes. The annotation
+// stays blank (no measurement associated) until the user fills it via the tile
+// / keypad. Skia-free; renders its live preview through ctx.preview, so it works
+// on web and (via the generic tool-pan dispatch) on native.
+export const createMeasurementTool = (options = {}) => {
+    const placement = options.placement ?? 'line';
+    const linePos = options.linePos ?? DEFAULT_LINE_POS;
+    const minDragPx = options.minDragPx ?? 4;
+    const autoSwitchToSelect = options.autoSwitchToSelect ?? true;
+    const selectToolId = options.selectToolId ?? 'select';
+    const place = (ctx, measurement) => {
+        ctx.commit({ ops: [{ op: 'addMeasurement', measurement }] });
+        ctx.setSelection({ ids: [measurement.id] });
+        options.onPlaced?.(measurement);
+        if (autoSwitchToSelect)
+            options.onAutoSwitch?.(selectToolId);
+    };
+    // Bare stamp: tap-to-place, no rubber-band.
+    if (placement === 'none') {
+        return {
+            id: options.id ?? 'measure-bare',
+            label: options.label ?? 'Measurement stamp',
+            cursor: 'copy',
+            onPointerUp(event, ctx) {
+                place(ctx, buildMeasurement({
+                    id: makeId(),
+                    layerId: firstLayerId(ctx.document),
+                    placement: 'none',
+                    linePos,
+                    a: event.world,
+                    b: event.world,
+                }));
+            },
+        };
+    }
+    const defaultId = placement === 'rectangle' ? 'measure-rect' : 'measure-line';
+    const defaultLabel = placement === 'rectangle' ? 'Measurement rectangle' : 'Measurement line';
+    return {
+        id: options.id ?? defaultId,
+        label: options.label ?? defaultLabel,
+        cursor: 'crosshair',
+        onPointerDown(event) {
+            return {
+                kind: 'measurement-drawing',
+                id: makeId(),
+                startWorld: event.world,
+                startScreen: event.screen,
+                moved: false,
+            };
+        },
+        onPointerMove(event, ctx, state) {
+            const s = state;
+            if (s?.kind !== 'measurement-drawing')
+                return s;
+            const measurement = buildMeasurement({
+                id: s.id,
+                layerId: firstLayerId(ctx.document),
+                placement,
+                linePos,
+                a: s.startWorld,
+                b: event.world,
+            });
+            ctx.preview({ ops: [{ op: 'addMeasurement', measurement }] });
+            return { ...s, moved: true };
+        },
+        onPointerUp(event, ctx, state) {
+            const s = state;
+            if (s?.kind !== 'measurement-drawing')
+                return;
+            const dx = event.screen.x - s.startScreen.x;
+            const dy = event.screen.y - s.startScreen.y;
+            if (!s.moved || dx * dx + dy * dy < minDragPx * minDragPx) {
+                // Accidental tap — discard the rubber-band, commit nothing.
+                ctx.preview({ ops: [] });
+                return;
+            }
+            place(ctx, buildMeasurement({
+                id: s.id,
+                layerId: firstLayerId(ctx.document),
+                placement,
+                linePos,
+                a: s.startWorld,
+                b: event.world,
+            }));
+        },
+        onCancel(_state, ctx) {
+            ctx.preview({ ops: [] });
+        },
+    };
+};

package/dist/annotation/canvas/tools/panTool.d.ts

@@ -1,5 +1,6 @@
 import type { Tool } from '../Tool.js';
 export interface PanToolOptions {
     cursor?: string;
+    selectMeasurementsOnTap?: boolean;
 }
 export declare const createPanTool: (options?: PanToolOptions) => Tool;

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

@@ -1,3 +1,8 @@
+import { hitPlacedMeasurement } from '../measurementGeometry.js';
+// Screen-px movement beyond which a gesture counts as a pan, not a tap. The
+// native canvas never dispatches pans to JS handlers (they run on the UI
+// thread), so this only guards web's down→jitter→up clicks.
+const TAP_SLOP_PX = 6;
 // Built-in "Hand" tool. When active, any drag pans the viewport. Tools that
 // want one-off pan triggers (middle-mouse, space-drag) get those via the
 // AnnotationCanvas `gestures` prop without needing to switch tools.
@@ -6,10 +11,16 @@ export const createPanTool = (options = {}) => ({
     label: 'Hand',
     cursor: options.cursor ?? 'grab',
     // Native pans the viewport on the UI thread (see Tool.panViewport). The
-    // onPointer* handlers below remain the web/parity implementation.
+    // onPointer* handlers below remain the web/parity implementation; taps
+    // still reach them on native via the synthesized down+up dispatch.
     panViewport: true,
     onPointerDown(event, _ctx, _state) {
-        return { kind: 'panning', lastScreen: event.screen };
+        return {
+            kind: 'panning',
+            startScreen: event.screen,
+            lastScreen: event.screen,
+            moved: false,
+        };
     },
     onPointerMove(event, ctx, state) {
         const s = state;
@@ -20,9 +31,31 @@ export const createPanTool = (options = {}) => ({
             y: event.screen.y - s.lastScreen.y,
         };
         ctx.applyPan(delta);
-        return { kind: 'panning', lastScreen: event.screen };
+        const dx = event.screen.x - s.startScreen.x;
+        const dy = event.screen.y - s.startScreen.y;
+        return {
+            ...s,
+            lastScreen: event.screen,
+            moved: s.moved || dx * dx + dy * dy > TAP_SLOP_PX * TAP_SLOP_PX,
+        };
     },
-    onPointerUp(_event, _ctx, _state) {
-        // No commit — viewport state is canvas-internal, not persisted.
+    onPointerUp(event, ctx, state) {
+        // No commit — viewport state is canvas-internal, not persisted. A clean
+        // tap optionally selects the measurement under it (see options).
+        const s = state;
+        if (!options.selectMeasurementsOnTap)
+            return;
+        if (s?.kind === 'panning' && s.moved)
+            return;
+        const zoom = ctx.viewport.state.zoom;
+        const measurements = ctx.document.placedMeasurements;
+        for (let i = measurements.length - 1; i >= 0; i--) {
+            const m = measurements[i];
+            if (hitPlacedMeasurement(m, event.world, zoom)) {
+                ctx.setSelection({ ids: [m.id] });
+                return;
+            }
+        }
+        ctx.setSelection(null);
     },
 });

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

@@ -20,7 +20,11 @@ export const createPenTool = (options = {}) => {
     const dotCap = cap === 'butt' || cap === 'arrow' ? 'round' : cap;
     return {
         id: variant,
-        label: variant === 'pen' ? 'Pen' : variant === 'marker' ? 'Marker' : 'Highlighter',
+        label: variant === 'pen'
+            ? 'Pen'
+            : variant === 'marker'
+                ? 'Marker'
+                : 'Highlighter',
         cursor: 'crosshair',
         // Drives UI-thread drawing on native (see FreehandConfig). The
         // onPointerDown/Move/Up below remain the web/parity implementation.

package/dist/annotation/canvas/tools/polygonTool.d.ts

@@ -0,0 +1,11 @@
+import type { AnnotationShape } from '../../../types/annotation.js';
+import type { Tool } from '../Tool.js';
+export interface PolygonToolOptions {
+    id?: string;
+    label?: string;
+    color?: string;
+    width?: number;
+    dash?: boolean;
+    onPlaced?: (shape: AnnotationShape) => void;
+}
+export declare const createPolygonTool: (options?: PolygonToolOptions) => Tool;

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

@@ -0,0 +1,162 @@
+import { DEFAULT_LAYER_ID } from '../../../types/annotation.js';
+// Screen-px radius for "tapped an existing vertex": the first vertex closes
+// the polygon, the last vertex finishes it open. Converted to doc space via
+// the live zoom so the target is a constant on-screen size.
+const VERTEX_TAP_PX = 18;
+// Screen-px radius of the placed-vertex dots drawn while building (the first
+// vertex grows once the polygon is closable, to advertise the close target).
+const VERTEX_DOT_PX = 5;
+const CLOSE_TARGET_DOT_PX = 8;
+let counter = 0;
+const makeId = () => `polygon-${Date.now().toString(36)}-${(counter++).toString(36)}`;
+const firstLayerId = (doc) => doc.layers[0]?.id ?? DEFAULT_LAYER_ID;
+const distSq = (a, b) => {
+    const dx = a.x - b.x;
+    const dy = a.y - b.y;
+    return dx * dx + dy * dy;
+};
+// Tap-to-place polygon tool. Each tap (or drag-release) adds a vertex;
+// tapping the FIRST vertex closes the ring and commits; tapping the LAST
+// vertex again (a double-tap, in practice) commits it as an open polyline.
+// Switching tools mid-build commits the open polyline too (work is never
+// silently discarded) via onDeactivate. In-progress geometry renders through
+// preview patches — the polyline plus a dot per placed vertex — so it needs
+// no platform-specific preview plumbing. Skia-free, like every tool factory.
+export const createPolygonTool = (options = {}) => {
+    const color = options.color ?? '#111827';
+    const width = options.width ?? 2;
+    const dash = options.dash ?? false;
+    // In-progress polygon (spans gestures — see PolygonGestureState).
+    let vertices = [];
+    let shapeId = null;
+    const buildShape = (doc, points, closed) => ({
+        id: shapeId ?? makeId(),
+        layerId: firstLayerId(doc),
+        kind: 'polygon',
+        // Snapshot the array: `points` is usually the live `vertices` buffer, and
+        // downstream memoization (ShapeElement keys its Skia path on
+        // geometry.points IDENTITY) must see a new array per emit — handing out
+        // the shared reference froze the preview polyline at its first segment.
+        geometry: { points: [...points], ...(closed ? {} : { closed: false }) },
+        style: { stroke: color, strokeWidth: width, ...(dash && { dash: true }) },
+        createdAt: Date.now(),
+    });
+    // Preview = the open polyline so far (+ the in-drag rubber point) plus a
+    // dot per placed vertex. Dots are preview-only ellipse shapes — they ride
+    // the same patch and never get committed. Sized in doc units from the live
+    // zoom at emit time (close enough; the preview re-emits on every event).
+    const previewOps = (doc, zoom, rubber) => {
+        if (vertices.length === 0)
+            return [];
+        const pts = rubber ? [...vertices, rubber] : vertices;
+        const ops = [];
+        if (pts.length >= 2) {
+            ops.push({
+                op: 'addShape',
+                shape: { ...buildShape(doc, pts, false), id: `${shapeId}-draft` },
+            });
+        }
+        const closable = vertices.length >= 3;
+        vertices.forEach((v, i) => {
+            const px = i === 0 && closable ? CLOSE_TARGET_DOT_PX : VERTEX_DOT_PX;
+            const r = px / zoom;
+            ops.push({
+                op: 'addShape',
+                shape: {
+                    id: `${shapeId}-v${i}`,
+                    layerId: firstLayerId(doc),
+                    kind: 'ellipse',
+                    geometry: {
+                        points: [
+                            { x: v.x - r, y: v.y - r },
+                            { x: v.x + r, y: v.y + r },
+                        ],
+                    },
+                    style: { fill: color, stroke: '#FFFFFF', strokeWidth: r / 3 },
+                    createdAt: 0,
+                },
+            });
+        });
+        return ops;
+    };
+    const reset = () => {
+        vertices = [];
+        shapeId = null;
+    };
+    const commit = (ctx, closed) => {
+        const shape = buildShape(ctx.document, vertices, closed);
+        ctx.commit({ ops: [{ op: 'addShape', shape }] });
+        reset();
+        options.onPlaced?.(shape);
+    };
+    return {
+        id: options.id ?? 'polygon',
+        label: options.label ?? 'Polygon',
+        cursor: 'crosshair',
+        onPointerDown() {
+            return { kind: 'polygon-pointing' };
+        },
+        onPointerMove(event, ctx, state) {
+            const s = state;
+            if (s?.kind !== 'polygon-pointing')
+                return s;
+            if (vertices.length === 0)
+                return s;
+            ctx.preview({
+                ops: previewOps(ctx.document, ctx.viewport.state.zoom, event.world),
+            });
+            return s;
+        },
+        onPointerUp(event, ctx, state) {
+            const s = state;
+            if (s?.kind !== 'polygon-pointing')
+                return;
+            const zoom = ctx.viewport.state.zoom;
+            const tol = VERTEX_TAP_PX / zoom;
+            const tolSq = tol * tol;
+            const p = event.world;
+            // Tap on the first vertex → close the ring and commit.
+            if (vertices.length >= 3 && distSq(p, vertices[0]) <= tolSq) {
+                commit(ctx, true);
+                return;
+            }
+            // Tap on the last vertex (tap-again / double-tap) → finish open.
+            if (vertices.length >= 1 &&
+                distSq(p, vertices[vertices.length - 1]) <= tolSq) {
+                if (vertices.length >= 2) {
+                    commit(ctx, false);
+                }
+                else {
+                    // Re-tapped the only vertex — treat as "never mind".
+                    reset();
+                    ctx.preview({ ops: [] });
+                }
+                return;
+            }
+            if (!shapeId)
+                shapeId = makeId();
+            // Immutable append (defense in depth alongside buildShape's snapshot):
+            // nothing downstream can ever observe this buffer mutating.
+            vertices = [...vertices, { x: p.x, y: p.y }];
+            ctx.preview({ ops: previewOps(ctx.document, zoom) });
+        },
+        // Gesture interrupted (e.g. a second finger landed and the viewport pan
+        // took over). Keep the placed vertices and re-establish the preview — the
+        // canvas clears the preview patch before calling this.
+        onCancel(_state, ctx) {
+            if (vertices.length === 0)
+                return;
+            ctx.preview({ ops: previewOps(ctx.document, ctx.viewport.state.zoom) });
+        },
+        // Switching tools mid-build: commit what exists as an open polyline (two
+        // or more vertices make a real shape; a lone vertex is discarded).
+        onDeactivate(ctx) {
+            if (vertices.length >= 2) {
+                commit(ctx, false);
+            }
+            else {
+                reset();
+            }
+        },
+    };
+};

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

@@ -1,5 +1,6 @@
-import { STAMP_TILE_SIZE } from '../stampLayout.js';
-import { placementOf, linePosOf, snapLinePos, lerp, recomputeAnchor, normalizeRect, rectCenter, rectCornerPoint, oppositeRectCorner, } from '../measurementGeometry.js';
+import { stampTileSize } from '../stampLayout.js';
+import { placementOf, linePosOf, snapLinePos, lerp, recomputeAnchor, rectCenter, rectCornerPoint, oppositeRectCorner, hitPlacedMeasurement, } from '../measurementGeometry.js';
+import { hitShapeOutline } from '../shapeGeometry.js';
 import { DEFAULT_TEXT_FONT_SIZE, resizeScaleFromDrag, textResizeGeometry, textShapeBounds, } from '../textGeometry.js';
 const HIT_PADDING = 6;
 // Hit-test in doc-space. Crude but fast — good enough for v1; tools can
@@ -14,9 +15,9 @@ const hitStroke = (stroke, p) => {
     }
     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-space grab tolerance (px) added around a geometric shape's outline
+// (line/arrow/rect/ellipse/polygon), converted to doc space via zoom.
+const SHAPE_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.
@@ -24,39 +25,6 @@ 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;
-        }
-    }
-    // Rectangle annotation: grab anywhere along the border (the interior stays
-    // transparent to hits so elements behind the rect remain selectable).
-    if (m.rect && placementOf(m) === 'rectangle') {
-        const n = normalizeRect(m.rect);
-        const r2 = (LINE_GRAB_PX / zoom) ** 2;
-        if (segmentDistanceSq(p.x, p.y, n.minX, n.minY, n.maxX, n.minY) <= r2 ||
-            segmentDistanceSq(p.x, p.y, n.maxX, n.minY, n.maxX, n.maxY) <= r2 ||
-            segmentDistanceSq(p.x, p.y, n.maxX, n.maxY, n.minX, n.maxY) <= r2 ||
-            segmentDistanceSq(p.x, p.y, n.minX, n.maxY, n.minX, n.minY) <= r2) {
-            return true;
-        }
-    }
-    return false;
-};
 const segmentDistanceSq = (px, py, ax, ay, bx, by) => {
     const abx = bx - ax;
     const aby = by - ay;
@@ -73,48 +41,32 @@ 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))
+        if (hitPlacedMeasurement(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.
-        // Text shapes store only their top-left anchor, so their box comes from
-        // the estimated text bounds instead.
         const s = doc.shapes[i];
-        let minX;
-        let maxX;
-        let minY;
-        let maxY;
         if (s.kind === 'text') {
+            // Text shapes store only their top-left anchor, so their hit box comes
+            // from the estimated text bounds.
             const b = textShapeBounds(s);
             if (!b)
                 continue;
-            ({ minX, maxX, minY, maxY } = b);
-        }
-        else {
-            const pts = s.geometry.points;
-            if (pts.length === 0)
-                continue;
-            minX = pts[0].x;
-            maxX = pts[0].x;
-            minY = pts[0].y;
-            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 >= b.minX - HIT_PADDING &&
+                world.x <= b.maxX + HIT_PADDING &&
+                world.y >= b.minY - HIT_PADDING &&
+                world.y <= b.maxY + HIT_PADDING) {
+                return { id: s.id, kind: 'shape' };
             }
+            continue;
         }
-        if (world.x >= minX - HIT_PADDING &&
-            world.x <= maxX + HIT_PADDING &&
-            world.y >= minY - HIT_PADDING &&
-            world.y <= maxY + HIT_PADDING) {
+        // Geometric shapes hit on their painted outline, not their bounding box —
+        // a long diagonal line's box would swallow taps nowhere near the ink, and
+        // a shape's interior stays transparent to hits so elements inside remain
+        // selectable. Grab radius = half the stroke + a screen-constant pad.
+        const tol = (s.style.strokeWidth ?? 2) / 2 + SHAPE_GRAB_PX / zoom;
+        if (hitShapeOutline(s, world, tol)) {
             return { id: s.id, kind: 'shape' };
         }
     }
@@ -180,8 +132,8 @@ 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;
+    // Same footprint the tile is drawn at (smaller for unassociated inputs, #6).
+    const half = (stampTileSize(m) / 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';
@@ -203,7 +155,9 @@ const slidePatch = (doc, id, delta, zoom) => {
     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 } }] };
+    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.
@@ -271,7 +225,11 @@ const rectCornerPatch = (doc, id, corner, delta) => {
     };
     return {
         ops: [
-            { op: 'updateMeasurement', id, patch: { rect, anchor: rectCenter(rect) } },
+            {
+                op: 'updateMeasurement',
+                id,
+                patch: { rect, anchor: rectCenter(rect) },
+            },
         ],
     };
 };
@@ -417,7 +375,10 @@ export const createSelectTool = () => ({
         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 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);
@@ -438,7 +399,7 @@ export const createSelectTool = () => ({
     },
     hitTest(element, p) {
         if (element.kind === 'measurement')
-            return hitMeasurement(element, p);
+            return hitPlacedMeasurement(element, p);
         if (element.kind === 'stroke')
             return hitStroke(element, p);
         return false;

package/dist/annotation/canvas/tools/shapeTool.d.ts

@@ -0,0 +1,25 @@
+import type { AnnotationShape, StrokeCap, Vec2 } from '../../../types/annotation.js';
+import { type ShapeToolKind } from '../shapeGeometry.js';
+import type { Tool } from '../Tool.js';
+export interface ShapeToolOptions {
+    kind?: ShapeToolKind;
+    id?: string;
+    label?: string;
+    color?: string;
+    width?: number;
+    cap?: StrokeCap;
+    dash?: boolean;
+    minDragPx?: number;
+}
+export declare const buildShapeFromDrag: (opts: {
+    kind: ShapeToolKind;
+    a: Vec2;
+    b: Vec2;
+    color: string;
+    width: number;
+    cap?: StrokeCap;
+    dash?: boolean;
+    layerId: string;
+    id?: string;
+}) => AnnotationShape;
+export declare const createShapeTool: (options?: ShapeToolOptions) => Tool;