@reekon-tools/boldr-utils 1.6.19 → 1.6.20

package/dist/annotation/canvas/AnnotationCanvasInner.js

@@ -12,6 +12,13 @@ const HANDLE_PX = 7;
 // Screen-px stroke width of the handle's colored ring (matches native
 // HANDLE_RING_PX); the white-disc + ring keeps the knob legible on any line.
 const HANDLE_RING_PX = 2;
+// Press-and-hold timing/tolerance. The DOM has no native long-press, so it's
+// derived from a hold timer: pressing without moving past the slop for this
+// long fires the tool's onLongPress; movement or an early release cancels it.
+// 500ms / RN's default delayLongPress so web matches native + the stamp
+// overlay's press target below.
+const LONG_PRESS_MS = 500;
+const LONG_PRESS_SLOP_PX = 10;
 const DEFAULT_PAN_TRIGGERS = ['middleMouse', 'space'];
 export const AnnotationCanvasInner = (props) => {
     const { resolveImageUrl, stampFontSource, stampValueFontSize = 14, gestures, width, height, style, activeToolId, tools, } = props;
@@ -39,7 +46,19 @@ export const AnnotationCanvasInner = (props) => {
     const containerRef = useRef(null);
     const panGestureRef = useRef(null);
     const spaceDownRef = useRef(false);
+    // Armed hold timer + its origin, for the derived long-press (see handlers).
+    const longPressTimerRef = useRef(null);
+    const longPressRef = useRef(null);
     const activeTool = tools.find((t) => t.id === activeToolId) ?? null;
+    const clearLongPress = useCallback(() => {
+        if (longPressTimerRef.current != null) {
+            clearTimeout(longPressTimerRef.current);
+            longPressTimerRef.current = null;
+        }
+        longPressRef.current = null;
+    }, []);
+    // Drop any armed hold timer if the canvas unmounts mid-press.
+    useEffect(() => clearLongPress, [clearLongPress]);
     const toCanvasPointer = useCallback((event) => {
         const rect = containerRef.current?.getBoundingClientRect();
         const screen = {
@@ -82,8 +101,31 @@ export const AnnotationCanvasInner = (props) => {
             return;
         }
         event.currentTarget.setPointerCapture(event.pointerId);
-        state.dispatchPointerDown(toCanvasPointer(event));
-    }, [state, toCanvasPointer, isPanTriggerDown]);
+        const canvasEvent = toCanvasPointer(event);
+        state.dispatchPointerDown(canvasEvent);
+        // Arm the hold timer only when the active tool acts on a long-press (the
+        // select tool, to re-open the text editor). The pointer keeps driving the
+        // tool underneath; if the hold fires before any movement past the slop,
+        // dispatchLongPress runs with the (unmoved) down point. Movement or
+        // pointer up/cancel clears it below.
+        if (activeTool?.onLongPress && event.button === 0) {
+            clearLongPress();
+            const { screen, pointerId } = canvasEvent;
+            longPressRef.current = { pointerId, start: screen };
+            longPressTimerRef.current = setTimeout(() => {
+                longPressTimerRef.current = null;
+                const lp = longPressRef.current;
+                if (!lp)
+                    return;
+                longPressRef.current = null;
+                state.dispatchLongPress({
+                    pointerId: lp.pointerId,
+                    screen: lp.start,
+                    world: state.ctx.viewport.screenToWorld(lp.start),
+                });
+            }, LONG_PRESS_MS);
+        }
+    }, [state, toCanvasPointer, isPanTriggerDown, activeTool, clearLongPress]);
     const handlePointerMove = useCallback((event) => {
         const pan = panGestureRef.current;
         if (pan && event.pointerId === pan.pointerId) {
@@ -102,20 +144,33 @@ export const AnnotationCanvasInner = (props) => {
             };
             return;
         }
+        // Moving past the slop turns the press into a drag — cancel the hold so a
+        // drag never also fires a long-press.
+        const lp = longPressRef.current;
+        if (lp && event.pointerId === lp.pointerId) {
+            const rect = containerRef.current?.getBoundingClientRect();
+            const dx = event.clientX - (rect?.left ?? 0) - lp.start.x;
+            const dy = event.clientY - (rect?.top ?? 0) - lp.start.y;
+            if (dx * dx + dy * dy > LONG_PRESS_SLOP_PX * LONG_PRESS_SLOP_PX) {
+                clearLongPress();
+            }
+        }
         state.dispatchPointerMove(toCanvasPointer(event));
-    }, [state, toCanvasPointer]);
+    }, [state, toCanvasPointer, clearLongPress]);
     const handlePointerUp = useCallback((event) => {
+        clearLongPress();
         const pan = panGestureRef.current;
         if (pan && event.pointerId === pan.pointerId) {
             panGestureRef.current = null;
             return;
         }
         state.dispatchPointerUp(toCanvasPointer(event));
-    }, [state, toCanvasPointer]);
+    }, [state, toCanvasPointer, clearLongPress]);
     const handlePointerCancel = useCallback(() => {
+        clearLongPress();
         panGestureRef.current = null;
         state.dispatchPointerCancel();
-    }, [state]);
+    }, [state, clearLongPress]);
     const handleWheel = useCallback((event) => {
         const rect = containerRef.current?.getBoundingClientRect();
         const focal = {
@@ -225,6 +280,9 @@ export const AnnotationCanvasInner = (props) => {
                     const measurement = placed.measurementId
                         ? (state.measurementsById.get(placed.measurementId) ?? null)
                         : null;
+                    // Corner-pinned, tile-proportional remove target (see the style
+                    // comment below) so it can't blanket a small tile and eat its grab.
+                    const removeSize = Math.min(40, size * 0.4);
                     return (_jsxs("div", { style: {
                             position: 'absolute',
                             left: 0,
@@ -247,11 +305,15 @@ export const AnnotationCanvasInner = (props) => {
                                     if (!keepSelection)
                                         state.ctx.setSelection(null);
                                 }, style: {
+                                    // Sized as a fraction of the tile and corner-pinned so it
+                                    // never covers the center. A fixed 40px target blanketed
+                                    // small tiles (the tile-scale slider shrinks them), eating
+                                    // the center grab so a selected tile couldn't be dragged.
                                     position: 'absolute',
-                                    top: -10,
-                                    right: -10,
-                                    width: 40,
-                                    height: 40,
+                                    top: 0,
+                                    right: 0,
+                                    width: removeSize,
+                                    height: removeSize,
                                     cursor: 'pointer',
                                     pointerEvents: 'auto',
                                 } }))] }, placed.id));
@@ -261,8 +323,7 @@ export const AnnotationCanvasInner = (props) => {
 // long-press, so it's derived: pointerdown arms a timer; if it fires before
 // the pointer lifts (or leaves/cancels), the long-press callback runs and the
 // trailing click is swallowed. Mirrors the native overlay's TouchableOpacity
-// onPress/onLongPress semantics (500ms, RN's default delayLongPress).
-const LONG_PRESS_MS = 500;
+// onPress/onLongPress semantics (LONG_PRESS_MS, RN's default delayLongPress).
 const StampPressTarget = ({ onPress, onLongPress, }) => {
     const timerRef = useRef(null);
     const longPressFiredRef = useRef(false);

package/dist/annotation/canvas/AnnotationCanvasInner.native.js

@@ -12,6 +12,12 @@ import { buildShapeFromDrag } from './tools/shapeTool.js';
 import { useAnnotationCanvasState, } from './useAnnotationCanvasState.js';
 let strokeCounter = 0;
 const makeStrokeId = () => `stroke-${Date.now().toString(36)}-${(strokeCounter++).toString(36)}`;
+// Press-and-hold timing/tolerance for the long-press gesture (matches the
+// measurement-stamp overlay's TouchableOpacity feel — 500ms / RN default).
+// Holding still this long without moving past the slop fires onLongPress;
+// moving first lets the drag win instead.
+const LONG_PRESS_MS = 500;
+const LONG_PRESS_SLOP_PX = 10;
 // Screen-px radius of a measurement-annotation endpoint handle dot. Divided by
 // the live zoom so the handle is a constant on-screen size.
 const HANDLE_RADIUS_PX = 7;
@@ -155,6 +161,7 @@ export const AnnotationCanvasInner = (props) => {
     const shapeDraw = state.activeTool?.shapeDraw ?? null;
     const panViewport = !!state.activeTool?.panViewport;
     const dragSelection = state.activeTool?.dragSelection ?? null;
+    const longPressEnabled = !!state.activeTool?.onLongPress;
     // In-flight shape rubber-band (line/arrow/rect/triangle/circle tools),
     // owned by the UI thread — the shape twin of `livePoints`. The drag worklet
     // tracks the start/current world points; derived paths below render the
@@ -479,6 +486,20 @@ export const AnnotationCanvasInner = (props) => {
                 inFlightRef.current = null;
             }
         });
+        // Press-and-hold (one finger, no movement) → dispatch a long-press to the
+        // active tool (the select tool re-opens the text editor for a placed text
+        // shape). Races against the one-finger drag: holding still activates this
+        // at LONG_PRESS_MS, moving first activates the drag/pan instead (this one's
+        // maxDistance cancels it). A quick tap is shorter than the hold, so the tap
+        // gesture still owns selection.
+        const longPress = Gesture.LongPress()
+            .minDuration(LONG_PRESS_MS)
+            .maxDistance(LONG_PRESS_SLOP_PX)
+            .runOnJS(true)
+            .onStart((e) => {
+            const id = pointerIdRef.current++;
+            stateRef.current.dispatchLongPress(buildEvent(id, { x: e.x, y: e.y }));
+        });
         const tap = Gesture.Tap()
             .maxDuration(250)
             .runOnJS(true)
@@ -752,9 +773,13 @@ export const AnnotationCanvasInner = (props) => {
                 const world = st.ctx.viewport.screenToWorld(screen);
                 const zoomNow = st.ctx.viewport.state.zoom;
                 // Endpoint handles show only on the selected annotation, so check the
-                // current selection's handles before the general hit-test.
+                // current selection's handles before the general hit-test — UNLESS the
+                // grab is on that element's tile, which must stay draggable (the tile
+                // is the move/slide affordance and wins over a handle sitting under it,
+                // so a selected tile isn't stuck until you deselect it).
                 const selId = st.ctx.selection?.ids[0];
-                if (selId) {
+                if (selId &&
+                    !cfg.isSelectedTileGrab?.(st.ctx.document, selId, world, zoomNow, st.ctx.tileViewportScale)) {
                     const handle = cfg.hitTestHandle?.(st.ctx.document, selId, world, zoomNow);
                     if (handle) {
                         const m = st.ctx.document.placedMeasurements.find((x) => x.id === selId);
@@ -996,7 +1021,9 @@ export const AnnotationCanvasInner = (props) => {
                     : dragSelection
                         ? buildSelectDragPan(dragSelection)
                         : toolPan;
-        return Gesture.Race(tap, Gesture.Simultaneous(viewportPan, pinch), oneFinger);
+        // Long-press only joins the race when the active tool acts on it, so it
+        // never pre-empts a one-finger drag/draw on tools that ignore holds.
+        return Gesture.Race(tap, ...(longPressEnabled ? [longPress] : []), Gesture.Simultaneous(viewportPan, pinch), oneFinger);
     }, [
         zoom,
         panX,
@@ -1011,6 +1038,7 @@ export const AnnotationCanvasInner = (props) => {
         shapeDraw,
         panViewport,
         dragSelection,
+        longPressEnabled,
         dragX,
         dragY,
         dragEnded,
@@ -1099,6 +1127,12 @@ export const AnnotationCanvasInner = (props) => {
 const MeasurementStampOverlayItem = ({ placed, measurement, selected, dragging, sliding, endpointDragging, rectResizing, zoomSnapshot, zoom, panX, panY, dragX, dragY, slideCtx, epCtx, rectCtx, renderMeasurementStamp, tileScaleFactor, tileViewportScale, onStampPress, onStampLongPress, onRemove, }) => {
     const size = stampTileSize(placed, tileScaleFactor, tileViewportScale);
     const half = size / 2;
+    // Remove-"X" touch target, sized as a fraction of the tile and corner-pinned
+    // so it never reaches the center. A FIXED 36px+hitSlop target blanketed small
+    // tiles (the tile-scale slider can shrink them to ~38px), swallowing the
+    // center grab and making a selected tile impossible to drag (it had to be
+    // deselected first). Capped so it doesn't grow past the old size on big tiles.
+    const removeSize = Math.min(36, size * 0.4);
     const anchorX = placed.anchor.x;
     const anchorY = placed.anchor.y;
     // doc → screen each frame, on the UI thread. Position is a translate
@@ -1166,11 +1200,11 @@ const MeasurementStampOverlayItem = ({ placed, measurement, selected, dragging,
                     selected,
                     size,
                     zoom: zoomSnapshot,
-                }) }), onStampPress && (_jsx(TouchableOpacity, { accessibilityRole: "button", accessibilityLabel: "Open measurement", onPress: () => onStampPress(placed), onLongPress: onStampLongPress ? () => onStampLongPress(placed) : undefined, style: StyleSheet.absoluteFill })), selected && measurement && (_jsx(TouchableOpacity, { accessibilityRole: "button", accessibilityLabel: "Remove measurement", hitSlop: 10, onPress: onRemove, style: {
+                }) }), onStampPress && (_jsx(TouchableOpacity, { accessibilityRole: "button", accessibilityLabel: "Open measurement", onPress: () => onStampPress(placed), onLongPress: onStampLongPress ? () => onStampLongPress(placed) : undefined, style: StyleSheet.absoluteFill })), selected && measurement && (_jsx(TouchableOpacity, { accessibilityRole: "button", accessibilityLabel: "Remove measurement", onPress: onRemove, style: {
                     position: 'absolute',
-                    top: -8,
-                    right: -8,
-                    width: 36,
-                    height: 36,
+                    top: 0,
+                    right: 0,
+                    width: removeSize,
+                    height: removeSize,
                 } }))] }));
 };

package/dist/annotation/canvas/Tool.d.ts

@@ -68,6 +68,7 @@ export interface DragSelectionConfig {
         fixed: Vec2;
     } | null;
     buildRectCornerPatch?(doc: AnnotationCanvasState, id: AnnotationElementId, corner: RectCorner, delta: Vec2): AnnotationDocumentPatch | null;
+    isSelectedTileGrab?(doc: AnnotationCanvasState, id: AnnotationElementId, world: Vec2, zoom: number, viewportTileScale?: number): boolean;
     hitTestResizeHandle?(doc: AnnotationCanvasState, id: AnnotationElementId, world: Vec2, zoom: number): ResizeGeometry | null;
     buildResizePatch?(doc: AnnotationCanvasState, id: AnnotationElementId, delta: Vec2): AnnotationDocumentPatch | null;
 }
@@ -83,6 +84,7 @@ export interface Tool {
     onPointerDown?(event: CanvasPointerEvent, ctx: ToolContext, state: ToolState): ToolState | void;
     onPointerMove?(event: CanvasPointerEvent, ctx: ToolContext, state: ToolState): ToolState | void;
     onPointerUp?(event: CanvasPointerEvent, ctx: ToolContext, state: ToolState): ToolState | void;
+    onLongPress?(event: CanvasPointerEvent, ctx: ToolContext): void;
     onCancel?(state: ToolState, ctx: ToolContext): void;
     onDeactivate?(ctx: ToolContext): void;
     renderPreview?(state: ToolState, ctx: ToolContext): ReactNode;

package/dist/annotation/canvas/measurementGeometry.js

@@ -92,9 +92,10 @@ export const oppositeRectCorner = (corner) => {
 const STAMP_HIT_PADDING = 6;
 // Screen-space grab tolerance (px) for a measurement-annotation line or rect
 // border, converted to doc space via zoom (the body is a thin world-space
-// stroke). Matches the select tool's drag-grab tolerance so tap-select and
-// drag-grab agree on what counts as "on the measurement".
-const LINE_GRAB_PX = 12;
+// stroke). Deliberately wider than a fingertip so a thin line isn't fiddly to
+// grab on touch, and kept in sync with the select tool's SHAPE_GRAB_PX so
+// tap-select and drag-grab agree on what counts as "on the measurement".
+const LINE_GRAB_PX = 32;
 const segmentDistSq = (p, a, b) => {
     const abx = b.x - a.x;
     const aby = b.y - a.y;

package/dist/annotation/canvas/stampLayout.d.ts

@@ -1,6 +1,6 @@
 import type { PlacedMeasurementRef } from '../../types/annotation.js';
 export declare const STAMP_TILE_SIZE = 96;
-export declare const STAMP_INPUT_TILE_SIZE = 56;
+export declare const STAMP_INPUT_TILE_SIZE = 44;
 export declare const DEFAULT_TILE_SCALE = 1;
 export declare const TILE_SCALE_MIN = 0.4;
 export declare const TILE_SCALE_MAX = 2;

package/dist/annotation/canvas/stampLayout.js

@@ -11,10 +11,12 @@
 export const STAMP_TILE_SIZE = 96;
 // Edge length for an UNASSOCIATED stamp — a measurement annotation with no
 // measurement picked yet, which renders as a compact "+" input placeholder
-// rather than a full readable tile. Smaller than STAMP_TILE_SIZE so empty
-// inputs read as lightweight tap targets; associated tiles keep STAMP_TILE_SIZE
-// so existing saved annotations are visually unchanged. The single knob for #6.
-export const STAMP_INPUT_TILE_SIZE = 56;
+// rather than a full readable tile. Kept noticeably smaller than
+// STAMP_TILE_SIZE so empty inputs read as lightweight tap targets that don't
+// crowd the drawing; associated tiles keep STAMP_TILE_SIZE so existing saved
+// annotations are visually unchanged. Still comfortably tappable once the
+// viewport/tile-scale multipliers (min 1) are folded in. The single knob for #6.
+export const STAMP_INPUT_TILE_SIZE = 44;
 // Document-wide tile scale factor (AnnotationCanvasState.tileScaleFactor): one
 // knob that shrinks/grows EVERY measurement tile on the canvas at once, on top
 // of each tile's own `scale`. Lets a user pull tiles down on a dense drawing

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

@@ -53,10 +53,16 @@ export const createMeasurementTool = (options = {}) => {
     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)
+        // Selecting the new annotation and handing back to select only makes sense
+        // when we actually switch tools. With autoSwitchToSelect off the tool stays
+        // active and behaves like the shape tools — commit and keep drawing, with
+        // nothing selected — so placing an empty input doesn't kick you out of
+        // drawing mode (and the keypad/pill doesn't pop for the blank tile).
+        if (autoSwitchToSelect) {
+            ctx.setSelection({ ids: [measurement.id] });
             options.onAutoSwitch?.(selectToolId);
+        }
     };
     // Bare stamp: tap-to-place, no rubber-band.
     if (placement === 'none') {

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

@@ -2,6 +2,7 @@ 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';
+import { editTextShape, findTextShapeAt } from './textEditing.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.
@@ -16,8 +17,14 @@ const hitStroke = (stroke, p) => {
     return false;
 };
 // 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;
+// (line/arrow/rect/ellipse/polygon), converted to doc space via zoom. A thin
+// line gives almost nothing to aim at, so the grab corridor is deliberately
+// wider than a fingertip — landing anywhere near the ink grabs it. Kept in sync
+// with measurementGeometry's LINE_GRAB_PX so tap-select and drag-grab agree on
+// what counts as "on the line". (The endpoint-resize handles use their own,
+// tighter HANDLE_GRAB_PX and are checked first on the selected element, so a
+// wider body grab never swallows them.)
+const SHAPE_GRAB_PX = 32;
 // 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.
@@ -124,6 +131,23 @@ const translatePatch = (elementKind, id, doc, delta) => {
     }
     return { op: 'updateStroke', id, patch: { points } };
 };
+// Whether a world point lands on a measurement's tile (its screen-constant
+// anchor box, converted back to doc space via zoom — the same footprint
+// classifyGrab uses). The tile is the move/slide affordance, so a grab here
+// must win over the endpoint/corner/resize handles that appear once an element
+// is selected; without this, a handle sitting under the tile (a rectangle
+// tile at the rect center, a line tile slid onto an endpoint) hijacks the grab
+// and the tile becomes unmovable until deselected.
+const isOnMeasurementTile = (doc, id, world, zoom, viewportTileScale = 1) => {
+    const m = doc.placedMeasurements.find((x) => x.id === id);
+    if (!m)
+        return false;
+    const half = (stampTileSize(m, doc.tileScaleFactor, viewportTileScale) / 2 +
+        HIT_PADDING) /
+        zoom;
+    return (Math.abs(world.x - m.anchor.x) <= half &&
+        Math.abs(world.y - m.anchor.y) <= half);
+};
 // --- 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
@@ -348,6 +372,7 @@ export const createSelectTool = () => ({
             return op ? { ops: [op] } : null;
         },
         classifyMeasurementGrab: classifyGrab,
+        isSelectedTileGrab: isOnMeasurementTile,
         buildSlidePatch: slidePatch,
         hitTestHandle: findHandleHit,
         buildEndpointPatch: endpointPatch,
@@ -364,9 +389,13 @@ export const createSelectTool = () => ({
     onPointerDown(event, ctx) {
         const { world } = event;
         const zoom = ctx.viewport.state.zoom;
-        // Endpoint/resize handles show only on the selected element — check first.
+        // Endpoint/resize handles show only on the selected element — check first,
+        // UNLESS the grab is on that element's tile: the tile is the move/slide
+        // affordance and must win over a handle sitting under it, so a selected
+        // tile stays draggable (otherwise it can only be moved after deselecting).
         const selId = ctx.selection?.ids[0];
-        if (selId) {
+        if (selId &&
+            !isOnMeasurementTile(ctx.document, selId, world, zoom, ctx.tileViewportScale)) {
             const handle = findHandleHit(ctx.document, selId, world, zoom);
             if (handle) {
                 ctx.setSelection({ ids: [selId] });
@@ -463,6 +492,14 @@ export const createSelectTool = () => ({
     onCancel(_state, ctx) {
         ctx.preview({ ops: [] });
     },
+    // Long-pressing a placed text shape re-opens the editor (the same edit flow
+    // as tapping it with the text tool, via the shared editTextShape). A hold on
+    // any other element — or empty canvas — is ignored.
+    onLongPress(event, ctx) {
+        const shape = findTextShapeAt(ctx.document, event.world);
+        if (shape)
+            editTextShape(ctx, shape);
+    },
     hitTest(element, p) {
         if (element.kind === 'measurement')
             return hitPlacedMeasurement(element, p);

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

@@ -0,0 +1,4 @@
+import type { AnnotationCanvasState, AnnotationShape, Vec2 } from '../../../types/annotation.js';
+import type { ToolContext } from '../Tool.js';
+export declare const findTextShapeAt: (doc: AnnotationCanvasState, world: Vec2) => AnnotationShape | null;
+export declare const editTextShape: (ctx: ToolContext, shape: AnnotationShape, onDone?: () => void) => void;

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

@@ -0,0 +1,36 @@
+import { hitTestTextShape } from '../textGeometry.js';
+// Topmost text shape under a world point (z-order, top first), or null. Shared
+// by the text tool (tap-to-edit) and the select tool (long-press-to-edit) so a
+// press resolves to the same element from either tool.
+export const findTextShapeAt = (doc, world) => {
+    for (let i = doc.shapes.length - 1; i >= 0; i--) {
+        const s = doc.shapes[i];
+        if (s.kind === 'text' && hitTestTextShape(s, world))
+            return s;
+    }
+    return null;
+};
+// Re-open the consumer's text input pre-filled with an existing text shape's
+// content and commit the edit: cancelling (null) leaves it untouched, clearing
+// the text deletes the shape, and changed text updates it. The shape is left
+// selected (cleared on delete). `onDone` runs only after a non-cancel,
+// non-delete resolution — the text tool uses it to switch back to select.
+// One source of truth for editing placed text from either tool.
+export const editTextShape = (ctx, shape, onDone) => {
+    void ctx.requestTextInput({ initialText: shape.text }).then((text) => {
+        if (text === null)
+            return;
+        if (text === '') {
+            ctx.commit({ ops: [{ op: 'removeShape', id: shape.id }] });
+            ctx.setSelection(null);
+            return;
+        }
+        if (text !== shape.text) {
+            ctx.commit({
+                ops: [{ op: 'updateShape', id: shape.id, patch: { text } }],
+            });
+        }
+        ctx.setSelection({ ids: [shape.id] });
+        onDone?.();
+    });
+};

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

@@ -1,5 +1,6 @@
 import { DEFAULT_LAYER_ID } from '../../../types/annotation.js';
-import { DEFAULT_TEXT_FONT_SIZE, hitTestTextShape } from '../textGeometry.js';
+import { DEFAULT_TEXT_FONT_SIZE } from '../textGeometry.js';
+import { editTextShape, findTextShapeAt } from './textEditing.js';
 let counter = 0;
 const makeId = () => `text-${Date.now().toString(36)}-${(counter++).toString(36)}`;
 // Screen-px a press may travel and still count as a tap. Beyond this the
@@ -7,15 +8,6 @@ const makeId = () => `text-${Date.now().toString(36)}-${(counter++).toString(36)
 // NOT open the text sheet — the cause of the stray "weird popup" on screen.
 const TAP_SLOP_PX = 10;
 const firstLayerId = (doc) => doc.layers[0]?.id ?? DEFAULT_LAYER_ID;
-// Topmost text shape under a world point, for tap-to-edit.
-const findTextShapeAt = (doc, world) => {
-    for (let i = doc.shapes.length - 1; i >= 0; i--) {
-        const s = doc.shapes[i];
-        if (s.kind === 'text' && hitTestTextShape(s, world))
-            return s;
-    }
-    return null;
-};
 // Tap-to-type. Tapping empty canvas opens the consumer's text input and
 // commits a new text shape at the tap point (top-left anchored); tapping an
 // existing text shape re-opens the input pre-filled to edit it (clearing the
@@ -51,22 +43,7 @@ export const createTextTool = (options = {}) => {
             }
             const existing = findTextShapeAt(ctx.document, event.world);
             if (existing) {
-                void ctx
-                    .requestTextInput({ initialText: existing.text })
-                    .then((text) => {
-                    if (text === null)
-                        return;
-                    if (text === '') {
-                        ctx.commit({ ops: [{ op: 'removeShape', id: existing.id }] });
-                        ctx.setSelection(null);
-                        return;
-                    }
-                    if (text !== existing.text) {
-                        ctx.commit({
-                            ops: [{ op: 'updateShape', id: existing.id, patch: { text } }],
-                        });
-                    }
-                    ctx.setSelection({ ids: [existing.id] });
+                editTextShape(ctx, existing, () => {
                     if (autoSwitchToSelect)
                         options.onAutoSwitch?.(selectToolId);
                 });

package/dist/annotation/canvas/useAnnotationCanvasState.d.ts

@@ -56,6 +56,7 @@ export interface AnnotationCanvasStateApi {
     dispatchPointerMove(event: CanvasPointerEvent): void;
     dispatchPointerUp(event: CanvasPointerEvent): void;
     dispatchPointerCancel(): void;
+    dispatchLongPress(event: CanvasPointerEvent): void;
     pan(deltaScreen: Vec2): void;
     zoom(focalScreen: Vec2, nextZoom: number): void;
     setViewport(next: ViewportState): void;

package/dist/annotation/canvas/useAnnotationCanvasState.js

@@ -121,6 +121,14 @@ export const useAnnotationCanvasState = (props) => {
         activePointerIdRef.current = null;
         setToolState(undefined);
     }, [activeTool, ctx, toolState]);
+    const dispatchLongPress = useCallback((event) => {
+        if (!activeTool)
+            return;
+        // Fire-and-forget: onLongPress is a discrete action (it opens the text
+        // editor), so it neither reads nor writes the gesture's tool state — the
+        // in-flight drag/select state on web stays intact underneath it.
+        activeTool.onLongPress?.(event, ctx);
+    }, [activeTool, ctx]);
     const dispatchPointerCancel = useCallback(() => {
         // Clear FIRST, then let the tool react: state updates batch, so a tool
         // whose onCancel re-emits a preview (the polygon tool keeps its placed
@@ -376,6 +384,7 @@ export const useAnnotationCanvasState = (props) => {
         dispatchPointerMove,
         dispatchPointerUp,
         dispatchPointerCancel,
+        dispatchLongPress,
         pan,
         zoom,
         setViewport,

package/package.json

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