@reekon-tools/boldr-utils 1.6.20 → 1.6.24

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

@@ -24,6 +24,9 @@ export interface AnnotationCanvasInnerProps {
     renderMeasurementStamp?: RenderMeasurementStamp;
     onMeasurementStampPress?: (placed: PlacedMeasurementRef) => void;
     onMeasurementStampLongPress?: (placed: PlacedMeasurementRef) => void;
+    onMeasurementStampDoubleTap?: (placed: PlacedMeasurementRef) => void;
+    resolveStampMeasurement?: (placed: PlacedMeasurementRef) => Measurement | null;
+    onMeasurementStampRemove?: (placed: PlacedMeasurementRef, defaultRemove: () => void) => void;
     stampFontSource?: unknown;
     stampValueFontSize?: number;
     stampLabelFontSize?: number;

package/dist/annotation/canvas/AnnotationCanvasInner.js

@@ -3,7 +3,7 @@ import { Skia, useFont, useTypeface } from '@shopify/react-native-skia';
 import { useCallback, useEffect, useMemo, useRef, } from 'react';
 import { AnnotationCanvasSkia } from './AnnotationCanvasSkia.js';
 import { TEXT_FONT_FAMILY } from './elements/ShapeElement.js';
-import { buildRemoveMeasurementOps } from './measurementGeometry.js';
+import { buildRemoveMeasurementOps, hitPlacedMeasurement, } from './measurementGeometry.js';
 import { useAnnotationCanvasState, } from './useAnnotationCanvasState.js';
 import { stampTileSize } from './stampLayout.js';
 // Screen-px radius of a measurement-annotation endpoint handle (matches the
@@ -244,8 +244,28 @@ export const AnnotationCanvasInner = (props) => {
         ...style,
     };
     const customPreview = activeTool?.renderPreview?.(state.customPreviewState, state.ctx);
-    const { renderMeasurementStamp, onMeasurementStampPress, onMeasurementStampLongPress, selection, } = props;
-    return (_jsxs("div", { ref: containerRef, style: containerStyle, onPointerDown: handlePointerDown, onPointerMove: handlePointerMove, onPointerUp: handlePointerUp, onPointerCancel: handlePointerCancel, onWheel: handleWheel, onContextMenu: handleContextMenu, children: [AnnotationCanvasSkia({
+    const { renderMeasurementStamp, onMeasurementStampPress, onMeasurementStampLongPress, onMeasurementStampDoubleTap, resolveStampMeasurement, onMeasurementStampRemove, selection, } = props;
+    // Double-click a stamp → fire the consumer callback (e.g. open its value
+    // editor). Runs the SAME hit-test the select tool uses (top-of-z-order), on
+    // the gesture container, so the stamp overlay stays pointer-events:none and
+    // drag-to-move / single-tap select are unaffected. dblclick is a distinct
+    // browser event that doesn't suppress the preceding pointerdown/up select.
+    const handleDoubleClick = useCallback((event) => {
+        if (!onMeasurementStampDoubleTap)
+            return;
+        const rect = containerRef.current?.getBoundingClientRect();
+        const screen = {
+            x: event.clientX - (rect?.left ?? 0),
+            y: event.clientY - (rect?.top ?? 0),
+        };
+        const world = state.ctx.viewport.screenToWorld(screen);
+        const placed = [...state.effectiveCanvas.placedMeasurements]
+            .reverse()
+            .find((m) => hitPlacedMeasurement(m, world, state.viewport.zoom, state.effectiveCanvas.tileScaleFactor, state.tileViewportScale));
+        if (placed)
+            onMeasurementStampDoubleTap(placed);
+    }, [onMeasurementStampDoubleTap, state]);
+    return (_jsxs("div", { ref: containerRef, style: containerStyle, onPointerDown: handlePointerDown, onPointerMove: handlePointerMove, onPointerUp: handlePointerUp, onPointerCancel: handlePointerCancel, onDoubleClick: handleDoubleClick, onWheel: handleWheel, onContextMenu: handleContextMenu, children: [AnnotationCanvasSkia({
                 width,
                 height,
                 effectiveCanvas: state.effectiveCanvas,
@@ -279,7 +299,7 @@ export const AnnotationCanvasInner = (props) => {
                     const isSelected = selection?.ids.includes(placed.id) ?? false;
                     const measurement = placed.measurementId
                         ? (state.measurementsById.get(placed.measurementId) ?? null)
-                        : null;
+                        : (resolveStampMeasurement?.(placed) ?? 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);
@@ -300,10 +320,17 @@ export const AnnotationCanvasInner = (props) => {
                                     ? () => onMeasurementStampLongPress(placed)
                                     : undefined })), isSelected && measurement && (_jsx("div", { role: "button", "aria-label": "Remove measurement", onPointerDown: (e) => {
                                     e.stopPropagation();
-                                    const { ops, keepSelection } = buildRemoveMeasurementOps(placed);
-                                    state.ctx.commit({ ops });
-                                    if (!keepSelection)
-                                        state.ctx.setSelection(null);
+                                    const defaultRemove = () => {
+                                        const { ops, keepSelection } = buildRemoveMeasurementOps(placed);
+                                        state.ctx.commit({ ops });
+                                        if (!keepSelection)
+                                            state.ctx.setSelection(null);
+                                    };
+                                    if (onMeasurementStampRemove) {
+                                        onMeasurementStampRemove(placed, defaultRemove);
+                                        return;
+                                    }
+                                    defaultRemove();
                                 }, style: {
                                     // Sized as a fraction of the tile and corner-pinned so it
                                     // never covers the center. A fixed 40px target blanketed

package/dist/annotation/canvas/AnnotationCanvasInner.native.d.ts

@@ -25,6 +25,9 @@ export interface AnnotationCanvasInnerProps {
     renderMeasurementStamp?: RenderMeasurementStamp;
     onMeasurementStampPress?: (placed: PlacedMeasurementRef) => void;
     onMeasurementStampLongPress?: (placed: PlacedMeasurementRef) => void;
+    onMeasurementStampDoubleTap?: (placed: PlacedMeasurementRef) => void;
+    resolveStampMeasurement?: (placed: PlacedMeasurementRef) => Measurement | null;
+    onMeasurementStampRemove?: (placed: PlacedMeasurementRef, defaultRemove: () => void) => void;
     stampFontSource?: unknown;
     stampValueFontSize?: number;
     stampLabelFontSize?: number;

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

@@ -9,6 +9,7 @@ import { DEFAULT_LAYER_ID, } from '../../types/annotation.js';
 import { AnnotationCanvasSkia } from './AnnotationCanvasSkia.js';
 import { buildRemoveMeasurementOps, } from './measurementGeometry.js';
 import { buildShapeFromDrag } from './tools/shapeTool.js';
+import { SELECTION_PAD } from './textGeometry.js';
 import { useAnnotationCanvasState, } from './useAnnotationCanvasState.js';
 let strokeCounter = 0;
 const makeStrokeId = () => `stroke-${Date.now().toString(36)}-${(strokeCounter++).toString(36)}`;
@@ -24,6 +25,10 @@ const HANDLE_RADIUS_PX = 7;
 // Screen-px stroke width of the handle's colored ring (white-disc + ring, so the
 // knob stays legible over a line of any color). Also zoom-divided.
 const HANDLE_RING_PX = 2;
+// Doc-space floor on a shape-corner resize's width/height — the worklet twin of
+// selectTool's MIN_SHAPE_EXTENT (the live preview must clamp identically to the
+// buildShapeCornerPatch commit). Keep the two in sync.
+const MIN_SHAPE_EXTENT = 1;
 // Native fingerprint: one finger drives the active tool, two fingers
 // pan/zoom the viewport. Tap counts as a brief pointer down+up so tools
 // like measurement-stamp (which only listen to onPointerUp) work via tap.
@@ -43,6 +48,11 @@ export const AnnotationCanvasInner = (props) => {
     // never rebuilt mid-gesture — its JS callbacks read `stateRef.current`.
     const stateRef = useRef(state);
     stateRef.current = state;
+    // Open-value-entry callback (edit mode). Rides a ref so the gesture needn't
+    // rebuild when it changes; the second-tap-on-selected detection lives in the
+    // tap gesture below (it compares against the selection captured pre-tap).
+    const onStampDoubleTapRef = useRef(props.onMeasurementStampDoubleTap);
+    onStampDoubleTapRef.current = props.onMeasurementStampDoubleTap;
     // Live viewport on the UI thread. Initialised from the JS snapshot; kept in
     // sync from JS only when not actively gesturing (see the effect below).
     const zoom = useSharedValue(state.viewport.zoom);
@@ -179,13 +189,14 @@ export const AnnotationCanvasInner = (props) => {
     // Live mirror of the active shape tool's config for the worklet path
     // builders (the derived values are created once, so they can't close over
     // the changing `shapeDraw` prop).
-    const shapeCfg = useSharedValue({ kind: 'line', cap: 'round', width: 2 });
+    const shapeCfg = useSharedValue({ kind: 'line', cap: 'round', startCap: 'round', width: 2 });
     useEffect(() => {
         if (!shapeDraw)
             return;
         shapeCfg.value = {
             kind: shapeDraw.kind,
             cap: shapeDraw.cap ?? 'round',
+            startCap: shapeDraw.startCap ?? 'round',
             width: shapeDraw.width,
         };
     }, [shapeDraw, shapeCfg]);
@@ -256,15 +267,20 @@ export const AnnotationCanvasInner = (props) => {
             path.close();
         };
         for (const e of handoffShapes.value) {
-            if (e.kind === 'line' && e.cap === 'arrow') {
+            if (e.kind !== 'line')
+                continue;
+            // End head at b (points a→b); start head at a (points b→a, args swapped).
+            if (e.cap === 'arrow')
                 addHead(e.ax, e.ay, e.bx, e.by);
-            }
+            if (e.startCap === 'arrow')
+                addHead(e.bx, e.by, e.ax, e.ay);
         }
         const s = liveShape.value;
-        if (s.active &&
-            shapeCfg.value.kind === 'line' &&
-            shapeCfg.value.cap === 'arrow') {
-            addHead(s.ax, s.ay, s.bx, s.by);
+        if (s.active && shapeCfg.value.kind === 'line') {
+            if (shapeCfg.value.cap === 'arrow')
+                addHead(s.ax, s.ay, s.bx, s.by);
+            if (shapeCfg.value.startCap === 'arrow')
+                addHead(s.bx, s.by, s.ax, s.ay);
         }
         return path;
     });
@@ -420,6 +436,124 @@ export const AnnotationCanvasInner = (props) => {
             { translateY: -c.py },
         ];
     });
+    // Geometric-shape corner resize (rect/ellipse/polygon). `shapeResizeId`
+    // (React state) gates which shape renders live; `shapeResizeCtx` carries the
+    // fixed (opposite) corner and the grabbed corner's start position (from
+    // DragSelectionConfig.hitTestShapeCorner), and `shapeResizePts` the shape's
+    // start geometry. The preview re-renders the shape from live GEOMETRY (a
+    // derived path) rather than a scale transform — a non-uniform scale transform
+    // would warp the stroke width (top/bottom edges thicken with scaleY); drawing
+    // the scaled outline at a constant stroke keeps it crisp. The commit on
+    // release goes through buildShapeCornerPatch, which scales identically.
+    const [shapeResizeId, setShapeResizeId] = useState(null);
+    const shapeResizeCtx = useSharedValue({ fx: 0, fy: 0, mx: 0, my: 0, uni: 0 });
+    // The resized shape's start geometry: kind + flat [x,y,x,y,…] points.
+    const shapeResizePts = useSharedValue({
+        kind: '',
+        pts: [],
+    });
+    const shapeResizeTargetRef = useRef(null);
+    // Live scale factors about the fixed corner. WORKLET TWIN of
+    // selectTool.shapeCornerPatch — keep the clamp + the ellipse uniform-scale
+    // branch in sync. Read by the path + box derived values below.
+    const shapeResizeScale = useDerivedValue(() => {
+        'worklet';
+        const c = shapeResizeCtx.value;
+        const denomX = c.mx - c.fx;
+        const denomY = c.my - c.fy;
+        let offX = c.mx + dragX.value - c.fx;
+        let offY = c.my + dragY.value - c.fy;
+        offX =
+            denomX >= 0
+                ? Math.max(MIN_SHAPE_EXTENT, offX)
+                : Math.min(-MIN_SHAPE_EXTENT, offX);
+        offY =
+            denomY >= 0
+                ? Math.max(MIN_SHAPE_EXTENT, offY)
+                : Math.min(-MIN_SHAPE_EXTENT, offY);
+        let sx = denomX !== 0 ? offX / denomX : 1;
+        let sy = denomY !== 0 ? offY / denomY : 1;
+        if (c.uni === 1) {
+            const oldDiag = Math.sqrt(denomX * denomX + denomY * denomY);
+            const s0 = oldDiag !== 0 ? Math.sqrt(offX * offX + offY * offY) / oldDiag : 1;
+            sx = s0;
+            sy = s0;
+        }
+        return { sx, sy };
+    });
+    // The shape's outline scaled about the fixed corner, rebuilt per frame.
+    // WORKLET TWIN of ShapeElement's per-kind rendering (rect/ellipse/polygon) —
+    // keep in sync.
+    const shapeResizePath = useDerivedValue(() => {
+        'worklet';
+        const path = Skia.Path.Make();
+        const g = shapeResizePts.value;
+        const c = shapeResizeCtx.value;
+        const { sx, sy } = shapeResizeScale.value;
+        const n = g.pts.length;
+        if (n < 4)
+            return path;
+        const px = (i) => c.fx + (g.pts[i] - c.fx) * sx;
+        const py = (i) => c.fy + (g.pts[i + 1] - c.fy) * sy;
+        if (g.kind === 'rect' || g.kind === 'ellipse') {
+            const ax = px(0);
+            const ay = py(0);
+            const bx = px(2);
+            const by = py(2);
+            if (g.kind === 'ellipse') {
+                const r = Math.max(Math.abs(bx - ax), Math.abs(by - ay)) / 2;
+                path.addCircle((ax + bx) / 2, (ay + by) / 2, r);
+            }
+            else {
+                const minX = Math.min(ax, bx);
+                const maxX = Math.max(ax, bx);
+                const minY = Math.min(ay, by);
+                const maxY = Math.max(ay, by);
+                path.moveTo(minX, minY);
+                path.lineTo(maxX, minY);
+                path.lineTo(maxX, maxY);
+                path.lineTo(minX, maxY);
+                path.close();
+            }
+        }
+        else {
+            // polygon (incl. triangle): the scaled outline through every point.
+            path.moveTo(px(0), py(0));
+            for (let i = 2; i < n; i += 2)
+                path.lineTo(px(i), py(i));
+            path.close();
+        }
+        return path;
+    });
+    // Live selection box: the scaled visual bounds (fixed corner ↔ scaled moving
+    // corner) padded by SELECTION_PAD, so the box tracks the resize at a constant
+    // stroke too (the transform would have warped it like the shape). Four
+    // separate derived values so each feeds its own animated <Rect> prop (Skia
+    // animates props individually — see `liveRect`).
+    const shapeResizeBoxX = useDerivedValue(() => {
+        'worklet';
+        const c = shapeResizeCtx.value;
+        const nmx = c.fx + (c.mx - c.fx) * shapeResizeScale.value.sx;
+        return Math.min(c.fx, nmx) - SELECTION_PAD;
+    });
+    const shapeResizeBoxY = useDerivedValue(() => {
+        'worklet';
+        const c = shapeResizeCtx.value;
+        const nmy = c.fy + (c.my - c.fy) * shapeResizeScale.value.sy;
+        return Math.min(c.fy, nmy) - SELECTION_PAD;
+    });
+    const shapeResizeBoxW = useDerivedValue(() => {
+        'worklet';
+        const c = shapeResizeCtx.value;
+        const nmx = c.fx + (c.mx - c.fx) * shapeResizeScale.value.sx;
+        return Math.abs(nmx - c.fx) + SELECTION_PAD * 2;
+    });
+    const shapeResizeBoxH = useDerivedValue(() => {
+        'worklet';
+        const c = shapeResizeCtx.value;
+        const nmy = c.fy + (c.my - c.fy) * shapeResizeScale.value.sy;
+        return Math.abs(nmy - c.fy) + SELECTION_PAD * 2;
+    });
     // Per-gesture refs so we always emit a matching down/move/up sequence.
     const pointerIdRef = useRef(1);
     const inFlightRef = useRef(null);
@@ -530,11 +664,33 @@ export const AnnotationCanvasInner = (props) => {
                 st.ctx.commit({ ops: [{ op: 'addStroke', stroke }] });
                 return;
             }
+            // Capture the selection BEFORE this tap re-selects, so we can tell a
+            // first tap (select) from a second tap on the already-selected tile.
+            const prevSelectedId = st.ctx.selection?.ids[0] ?? null;
             // Otherwise synthesize a down+up sequence so tools that only listen to
             // onPointerUp (e.g. measurement stamp) still fire.
             const id = pointerIdRef.current++;
             st.dispatchPointerDown(buildEvent(id, screen));
             st.dispatchPointerUp(buildEvent(id, screen));
+            // Edit-mode "tap the selected tile to open value entry": when the select
+            // tool is active the stamp overlay is non-interactive (so drag/select
+            // keep working), which means the view-mode TouchableOpacity can't catch
+            // the tap. Mirror handleViewStampPress here — a first tap only selects, a
+            // second tap on the same (already-selected) tile fires the consumer
+            // callback. Not a timed double-tap: the tile must already have been
+            // selected by a previous tap.
+            const onActivate = onStampDoubleTapRef.current;
+            if (!onActivate || !dragSelection || !prevSelectedId)
+                return;
+            const world = st.ctx.viewport.screenToWorld(screen);
+            const zoomNow = st.ctx.viewport.state.zoom;
+            const hit = dragSelection.hitTest(st.ctx.document, world, zoomNow, st.ctx.tileViewportScale);
+            if (!hit || hit.kind !== 'measurement' || hit.id !== prevSelectedId) {
+                return;
+            }
+            const placed = st.ctx.document.placedMeasurements.find((p) => p.id === hit.id);
+            if (placed)
+                onActivate(placed);
         });
         // Viewport pan — runs on the UI thread (no runOnJS), mutating the shared
         // viewport directly. Mirrors viewport.ts `panBy`. Used for both the
@@ -610,6 +766,7 @@ export const AnnotationCanvasInner = (props) => {
                         color: fh.color,
                         width: fh.width,
                         cap: fh.cap ?? 'round',
+                        ...(fh.startCap === 'arrow' && { startCap: 'arrow' }),
                         ...(fh.dash && { dash: true }),
                         points: worldPoints,
                         createdAt: Date.now(),
@@ -694,6 +851,7 @@ export const AnnotationCanvasInner = (props) => {
                     color: cfg.color,
                     width: cfg.width,
                     cap: cfg.cap,
+                    startCap: cfg.startCap,
                     dash: cfg.dash,
                     layerId: st.ctx.document.layers[0]?.id ?? DEFAULT_LAYER_ID,
                     id,
@@ -746,6 +904,7 @@ export const AnnotationCanvasInner = (props) => {
                         id,
                         kind: cfg.kind,
                         cap: cfg.cap ?? 'round',
+                        startCap: cfg.startCap ?? 'round',
                         ax: s.ax,
                         ay: s.ay,
                         bx: s.bx,
@@ -846,6 +1005,33 @@ export const AnnotationCanvasInner = (props) => {
                         setRectDragId(selId);
                         return;
                     }
+                    // Shape (rect/ellipse/polygon) bounding-box corner handle — the shape
+                    // twin of the rect-annotation corner above; scales length and width.
+                    const shapeCornerHit = cfg.hitTestShapeCorner?.(st.ctx.document, selId, world, zoomNow);
+                    if (shapeCornerHit) {
+                        const cornerShape = st.ctx.document.shapes.find((x) => x.id === selId);
+                        shapeResizeCtx.value = {
+                            fx: shapeCornerHit.fixed.x,
+                            fy: shapeCornerHit.fixed.y,
+                            mx: shapeCornerHit.moving.x,
+                            my: shapeCornerHit.moving.y,
+                            uni: cornerShape?.kind === 'ellipse' ? 1 : 0,
+                        };
+                        const flat = [];
+                        for (const p of cornerShape?.geometry.points ?? []) {
+                            flat.push(p.x, p.y);
+                        }
+                        shapeResizePts.value = {
+                            kind: cornerShape?.kind ?? '',
+                            pts: flat,
+                        };
+                        shapeResizeTargetRef.current = {
+                            id: selId,
+                            corner: shapeCornerHit.corner,
+                        };
+                        setShapeResizeId(selId);
+                        return;
+                    }
                 }
                 const hit = cfg.hitTest(st.ctx.document, world, zoomNow, st.ctx.tileViewportScale);
                 if (!hit) {
@@ -907,6 +1093,19 @@ export const AnnotationCanvasInner = (props) => {
                     setRectDragId(null);
                     return;
                 }
+                // Shape-corner commit: scale the shape by dragging the grabbed corner
+                // (opposite corner fixed); buildShapeCornerPatch clamps as the preview.
+                const shapeRT = shapeResizeTargetRef.current;
+                if (shapeRT) {
+                    if (dx !== 0 || dy !== 0) {
+                        const patch = cfg.buildShapeCornerPatch?.(st.ctx.document, shapeRT.id, shapeRT.corner, { x: dx, y: dy });
+                        if (patch)
+                            st.ctx.commit(patch);
+                    }
+                    shapeResizeTargetRef.current = null;
+                    setShapeResizeId(null);
+                    return;
+                }
                 // Endpoint commit: move the grabbed endpoint by the world delta.
                 const epT = epTargetRef.current;
                 if (epT) {
@@ -966,12 +1165,14 @@ export const AnnotationCanvasInner = (props) => {
                 shapeEpTargetRef.current = null;
                 resizeTargetRef.current = null;
                 rectTargetRef.current = null;
+                shapeResizeTargetRef.current = null;
                 setDraggingId(null);
                 setSlidingId(null);
                 setEpDragId(null);
                 setShapeEpDragId(null);
                 setResizingId(null);
                 setRectDragId(null);
+                setShapeResizeId(null);
             };
             return Gesture.Pan()
                 .minPointers(1)
@@ -1049,7 +1250,7 @@ export const AnnotationCanvasInner = (props) => {
     ]);
     const activeTool = props.tools.find((t) => t.id === props.activeToolId) ?? null;
     const customPreview = activeTool?.renderPreview?.(state.customPreviewState, state.ctx);
-    const { renderMeasurementStamp, onMeasurementStampPress, onMeasurementStampLongPress, selection, } = props;
+    const { renderMeasurementStamp, onMeasurementStampPress, onMeasurementStampLongPress, resolveStampMeasurement, onMeasurementStampRemove, selection, } = props;
     return (_jsxs(GestureHandlerRootView, { style: [{ width, height }, style], children: [_jsx(GestureDetector, { gesture: gesture, children: _jsx(View, { style: { width, height }, collapsable: false, children: AnnotationCanvasSkia({
                         width,
                         height,
@@ -1105,6 +1306,14 @@ export const AnnotationCanvasInner = (props) => {
                             width: liveRectW,
                             height: liveRectH,
                         },
+                        shapeResizeId,
+                        shapeResizePath,
+                        shapeResizeBox: {
+                            x: shapeResizeBoxX,
+                            y: shapeResizeBoxY,
+                            width: shapeResizeBoxW,
+                            height: shapeResizeBoxH,
+                        },
                         // Endpoint/corner handles are drag affordances — only the select
                         // tool can act on them, so suppress them when the active tool has
                         // no drag support (e.g. view mode's pan tool, where a selected
@@ -1117,11 +1326,18 @@ export const AnnotationCanvasInner = (props) => {
                         customPreview,
                     }) }) }), renderMeasurementStamp && (_jsx(View, { pointerEvents: "box-none", style: StyleSheet.absoluteFill, children: state.effectiveCanvas.placedMeasurements.map((placed) => (_jsx(MeasurementStampOverlayItem, { placed: placed, measurement: placed.measurementId
                         ? (state.measurementsById.get(placed.measurementId) ?? null)
-                        : null, selected: selection?.ids.includes(placed.id) ?? false, dragging: draggingId === placed.id, sliding: slidingId === placed.id, endpointDragging: epDragId === placed.id, rectResizing: rectDragId === placed.id, zoomSnapshot: state.viewport.zoom, zoom: zoom, panX: panX, panY: panY, dragX: dragX, dragY: dragY, slideCtx: slideCtx, epCtx: epCtx, rectCtx: rectCtx, renderMeasurementStamp: renderMeasurementStamp, tileScaleFactor: state.effectiveCanvas.tileScaleFactor, tileViewportScale: state.tileViewportScale, onStampPress: onMeasurementStampPress, onStampLongPress: onMeasurementStampLongPress, onRemove: () => {
-                        const { ops, keepSelection } = buildRemoveMeasurementOps(placed);
-                        state.ctx.commit({ ops });
-                        if (!keepSelection)
-                            state.ctx.setSelection(null);
+                        : (resolveStampMeasurement?.(placed) ?? null), selected: selection?.ids.includes(placed.id) ?? false, dragging: draggingId === placed.id, sliding: slidingId === placed.id, endpointDragging: epDragId === placed.id, rectResizing: rectDragId === placed.id, zoomSnapshot: state.viewport.zoom, zoom: zoom, panX: panX, panY: panY, dragX: dragX, dragY: dragY, slideCtx: slideCtx, epCtx: epCtx, rectCtx: rectCtx, renderMeasurementStamp: renderMeasurementStamp, tileScaleFactor: state.effectiveCanvas.tileScaleFactor, tileViewportScale: state.tileViewportScale, onStampPress: onMeasurementStampPress, onStampLongPress: onMeasurementStampLongPress, onRemove: () => {
+                        const defaultRemove = () => {
+                            const { ops, keepSelection } = buildRemoveMeasurementOps(placed);
+                            state.ctx.commit({ ops });
+                            if (!keepSelection)
+                                state.ctx.setSelection(null);
+                        };
+                        if (onMeasurementStampRemove) {
+                            onMeasurementStampRemove(placed, defaultRemove);
+                            return;
+                        }
+                        defaultRemove();
                     } }, placed.id))) }))] }));
 };
 const MeasurementStampOverlayItem = ({ placed, measurement, selected, dragging, sliding, endpointDragging, rectResizing, zoomSnapshot, zoom, panX, panY, dragX, dragY, slideCtx, epCtx, rectCtx, renderMeasurementStamp, tileScaleFactor, tileViewportScale, onStampPress, onStampLongPress, onRemove, }) => {

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

@@ -69,6 +69,16 @@ export interface AnnotationCanvasSkiaProps {
         width: AnimatedNumber;
         height: AnimatedNumber;
     };
+    shapeResizeId?: string | null;
+    shapeResizePath?: SkPath | {
+        value: SkPath;
+    };
+    shapeResizeBox?: {
+        x: AnimatedNumber;
+        y: AnimatedNumber;
+        width: AnimatedNumber;
+        height: AnimatedNumber;
+    };
     handleRadius?: number | {
         value: number;
     };
@@ -77,5 +87,5 @@ export interface AnnotationCanvasSkiaProps {
     };
     customPreview?: ReactNode;
 }
-export declare const AnnotationCanvasSkia: ({ width, height, effectiveCanvas, worldTransform, resolveImageUrl, valueFont, textFontMgr, penDrawingStroke, livePreview, shapePreview, draggingId, dragTransform, resizingId, resizeTransform, selectedId, endpointDragId, shapeEndpointDragId, liveLineP1, liveLineP2, rectDragId, liveRect, handleRadius, handleRingWidth, customPreview, }: AnnotationCanvasSkiaProps) => import("react/jsx-runtime").JSX.Element;
+export declare const AnnotationCanvasSkia: ({ width, height, effectiveCanvas, worldTransform, resolveImageUrl, valueFont, textFontMgr, penDrawingStroke, livePreview, shapePreview, draggingId, dragTransform, resizingId, resizeTransform, selectedId, endpointDragId, shapeEndpointDragId, liveLineP1, liveLineP2, rectDragId, liveRect, shapeResizeId, shapeResizePath, shapeResizeBox, handleRadius, handleRingWidth, customPreview, }: AnnotationCanvasSkiaProps) => import("react/jsx-runtime").JSX.Element;
 export {};