@reekon-tools/boldr-utils 1.6.34 → 1.6.35

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

@@ -5,5 +5,7 @@ export declare const TILE_SCALE_MIN = 0.4;
 export declare const TILE_SCALE_MAX = 2;
 export declare const resolveTileScaleFactor: (canvas: Pick<AnnotationCanvasState, "tileScaleFactor" | "tileScaleFactorMobile">, platform: TileScalePlatform) => number;
 export declare const clampTileScale: (v: number) => number;
+export declare const tileDocSizeForFactor: (factor: number, zoom: number) => number;
+export declare const tileScaleFromDocSize: (docSize: number, zoom: number) => number;
 export declare const isUnassociatedStamp: (m: Pick<PlacedMeasurementRef, "measurementId" | "measurementPath" | "columnId">) => boolean;
 export declare const stampTileSize: (m: Pick<PlacedMeasurementRef, "scale">, tileScaleFactor?: number, viewportScale?: number) => number;

package/dist/annotation/canvas/stampLayout.js

@@ -37,6 +37,24 @@ export const resolveTileScaleFactor = (canvas, platform) => (platform === 'mobil
 // Clamp a tile-scale-factor candidate to the supported range. The single guard
 // for the value before it lands in the document (slider input, restored docs).
 export const clampTileScale = (v) => v < TILE_SCALE_MIN ? TILE_SCALE_MIN : v > TILE_SCALE_MAX ? TILE_SCALE_MAX : v;
+// --- Cross-platform initial-size calibration ---------------------------------
+// The platform knobs are screen-space multipliers, so the same value covers a
+// very different share of the DRAWING on a phone than on a desktop pane. To
+// hand mobile a sensible starting size, web persists the doc-space edge length
+// a scale-1 tile covered as the user saw it (`tileDocSize`, stamped on tile
+// placement and web slider commits); a mobile canvas with no own knob yet
+// inverts that at its content-fit zoom so its tiles cover the SAME area of the
+// image. Two inverses of one identity: screenSize = docSize × zoom.
+// Doc-space edge length a scale-1 tile covers at `zoom` under `factor` — the
+// web write side of the calibration. Non-positive zoom yields 0, which the
+// setTileDocSize op ignores.
+export const tileDocSizeForFactor = (factor, zoom) => zoom > 0 ? (STAMP_TILE_SIZE * factor) / zoom : 0;
+// Tile-scale factor that makes a scale-1 tile cover `docSize` doc units at
+// `zoom` — the mobile read side of the calibration. Deliberately NOT clamped
+// to the slider range: faithfully matching the web look can land below
+// TILE_SCALE_MIN on a phone, and rendering/hit-testing handle any positive
+// value. The clamp applies once the user drives the slider themselves.
+export const tileScaleFromDocSize = (docSize, zoom) => (docSize * zoom) / STAMP_TILE_SIZE;
 // --- Tile sizing is independent of canvas size ------------------------------
 // A measurement tile's footprint is base × per-tile `scale` × the document-wide
 // `tileScaleFactor` (below) — and NOTHING tied to the canvas's pixel size, so

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

@@ -10,6 +10,8 @@ export interface AnnotationCanvasHandle {
     canRedo(): boolean;
     zoomToFit(): void;
     resetView(): void;
+    getTileScaleFactor(): number;
+    getTileDocSize(factor: number): number;
     placeMeasurementAtCenter(ref: MeasurementRef): void;
     placeAnnotationAtCenter(opts?: {
         defaultLengthDoc?: number;

package/dist/annotation/canvas/useAnnotationCanvasState.js

@@ -1,6 +1,6 @@
 import { useCallback, useEffect, useMemo, useRef, useState } from 'react';
 import { applyPatch, invertPatch, DEFAULT_LAYER_ID, } from '../../types/annotation.js';
-import { resolveTileScaleFactor } from './stampLayout.js';
+import { resolveTileScaleFactor, tileDocSizeForFactor, tileScaleFromDocSize, } from './stampLayout.js';
 import { createViewportApi, fitRectToScreen, imageDocRect, panBy, zoomAt, DEFAULT_VIEWPORT, } from './viewport.js';
 import { buildRemoveMeasurementOps, recomputeAnchor, rectCenter, DEFAULT_LINE_POS, } from './measurementGeometry.js';
 // The viewport that frames the document's content on screen. When a background
@@ -76,7 +76,21 @@ export const useAnnotationCanvasState = (props) => {
     // tools (hit boxes) and overlays (drawn size) share one value. Uses the
     // effective (preview-applied) canvas for parity with what is on screen; the
     // slider only ever commits, so this matches ctx.document in practice.
-    const tileScaleFactor = resolveTileScaleFactor(effectiveCanvas, tileScalePlatform ?? 'web');
+    // A mobile canvas whose own knob is still unset derives its factor from the
+    // web-stamped doc-space calibration (tileDocSize) instead of web's raw
+    // screen-space value: at the initial content-fit view its tiles then cover
+    // the same area of the image the web user saw. The first mobile slider
+    // commit writes tileScaleFactorMobile and takes over for good.
+    const tileScalePlatformResolved = tileScalePlatform ?? 'web';
+    let tileScaleFactor = resolveTileScaleFactor(effectiveCanvas, tileScalePlatformResolved);
+    if (tileScalePlatformResolved === 'mobile' &&
+        effectiveCanvas.tileScaleFactorMobile == null &&
+        effectiveCanvas.tileDocSize != null &&
+        effectiveCanvas.tileDocSize > 0 &&
+        width > 0 &&
+        height > 0) {
+        tileScaleFactor = tileScaleFromDocSize(effectiveCanvas.tileDocSize, computeContentFit(effectiveCanvas, width, height).zoom);
+    }
     const ctx = useMemo(() => ({
         document: canvas,
         selection,
@@ -87,11 +101,27 @@ export const useAnnotationCanvasState = (props) => {
             setPreviewPatch(patch);
         },
         commit(patch) {
-            const inverse = invertPatch(canvas, patch);
-            undoStackRef.current.push({ forward: patch, inverse });
+            // Placing a tile on WEB stamps the doc-space calibration: the area of
+            // the drawing a scale-1 tile covers at the zoom the user is looking
+            // at, right when they judged the size against the image. Mobile
+            // derives its initial factor from it (see tileScaleFactor above).
+            // Appended into the same patch so placement + calibration are one
+            // undo step.
+            let effective = patch;
+            if (tileScalePlatformResolved !== 'mobile' &&
+                patch.ops.some((o) => o.op === 'addMeasurement')) {
+                const docSize = tileDocSizeForFactor(tileScaleFactor, viewportApi.state.zoom);
+                if (docSize > 0) {
+                    effective = {
+                        ops: [...patch.ops, { op: 'setTileDocSize', value: docSize }],
+                    };
+                }
+            }
+            const inverse = invertPatch(canvas, effective);
+            undoStackRef.current.push({ forward: effective, inverse });
             redoStackRef.current = [];
             setPreviewPatch(null);
-            onCommit(patch);
+            onCommit(effective);
         },
         setSelection(s) {
             onSelectionChange(s);
@@ -116,6 +146,7 @@ export const useAnnotationCanvasState = (props) => {
         viewportApi,
         tileViewportScale,
         tileScaleFactor,
+        tileScalePlatformResolved,
         onCommit,
         onSelectionChange,
         pickMeasurement,
@@ -264,6 +295,12 @@ export const useAnnotationCanvasState = (props) => {
                 // for a high-res background is the very crop this is meant to escape.
                 setViewport(computeContentFit(canvas, width, height));
             },
+            getTileScaleFactor() {
+                return ctxRef.current.tileScaleFactor;
+            },
+            getTileDocSize(factor) {
+                return tileDocSizeForFactor(factor, ctxRef.current.viewport.state.zoom);
+            },
             placeMeasurementAtCenter(ref) {
                 const c = ctxRef.current;
                 const anchor = c.viewport.screenToWorld({

package/dist/canvas/AnnotationCanvas.d.ts

@@ -0,0 +1,11 @@
+import { type ReactNode } from 'react';
+import type { AnnotationCanvasInnerProps } from './AnnotationCanvasInner.js';
+export type { AnnotationCanvasHandle, GestureConfig, PanTrigger, } from './AnnotationCanvasInner.js';
+export interface CanvasKitOpts {
+    locateFile?: (file: string) => string;
+}
+export type AnnotationCanvasProps = AnnotationCanvasInnerProps & {
+    fallback?: ReactNode;
+    canvasKitOpts?: CanvasKitOpts;
+};
+export declare const AnnotationCanvas: ({ fallback, canvasKitOpts, ...rest }: AnnotationCanvasProps) => import("react/jsx-runtime").JSX.Element;

package/dist/canvas/AnnotationCanvas.js

@@ -0,0 +1,10 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { WithSkiaWeb } from '@shopify/react-native-skia/lib/module/web/index.js';
+// Web-only entry point: lazy-loads CanvasKit wasm via WithSkiaWeb. Imperative
+// API (undo/redo/zoom) is exposed through the `imperativeRef` prop rather
+// than React refs, since WithSkiaWeb can't forward refs through its lazy
+// component boundary. The native build sits in `AnnotationCanvas.native.tsx`
+// and skips WithSkiaWeb entirely (no wasm to load).
+export const AnnotationCanvas = ({ fallback, canvasKitOpts, ...rest }) => (_jsx(WithSkiaWeb, { getComponent: () => import('./AnnotationCanvasInner.js').then((m) => ({
+        default: m.AnnotationCanvasInner,
+    })), fallback: fallback ?? null, componentProps: rest, opts: canvasKitOpts }));

package/dist/canvas/AnnotationCanvas.native.d.ts

@@ -0,0 +1,8 @@
+import type { AnnotationCanvasInnerProps } from './AnnotationCanvasInner.native.js';
+export type { AnnotationCanvasHandle, } from './useAnnotationCanvasState.js';
+export type { GestureConfig, PanTrigger, } from './AnnotationCanvasInner.js';
+export type AnnotationCanvasProps = AnnotationCanvasInnerProps & {
+    fallback?: unknown;
+    canvasKitOpts?: unknown;
+};
+export declare const AnnotationCanvas: (props: AnnotationCanvasProps) => import("react/jsx-runtime").JSX.Element;

package/dist/canvas/AnnotationCanvas.native.js

@@ -0,0 +1,6 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { AnnotationCanvasInner } from './AnnotationCanvasInner.native.js';
+export const AnnotationCanvas = (props) => {
+    const { fallback: _f, canvasKitOpts: _o, ...rest } = props;
+    return _jsx(AnnotationCanvasInner, { ...rest });
+};

package/dist/canvas/AnnotationCanvasInner.d.ts

@@ -0,0 +1,39 @@
+import { type CSSProperties, type MutableRefObject } from 'react';
+import type { DecimalTolerance, FractionalTolerance, Measurement, Units } from '../types/firestore.js';
+import type { AnnotationCanvasState, AnnotationDocumentPatch, Selection } from '../types/annotation.js';
+import type { MeasurementRef } from './measurementPicker.js';
+import type { Tool } from './Tool.js';
+import { type AnnotationCanvasHandle } from './useAnnotationCanvasState.js';
+import { type ViewportState } from './viewport.js';
+import type { RenderMeasurementStamp } from './measurementStampOverlay.js';
+export type { AnnotationCanvasHandle };
+export interface AnnotationCanvasInnerProps {
+    canvas: AnnotationCanvasState;
+    onCommit(patch: AnnotationDocumentPatch): void;
+    tools: Tool[];
+    activeToolId: string;
+    selection: Selection | null;
+    onSelectionChange(selection: Selection | null): void;
+    measurements?: Measurement[];
+    fallbackUnit?: Units;
+    fractionalTolerance?: FractionalTolerance;
+    decimalTolerance?: DecimalTolerance;
+    resolveImageUrl?: (storagePath: string) => Promise<string>;
+    pickMeasurement?: () => Promise<MeasurementRef | null>;
+    renderMeasurementStamp?: RenderMeasurementStamp;
+    stampFontSource?: unknown;
+    stampValueFontSize?: number;
+    stampLabelFontSize?: number;
+    gestures?: GestureConfig;
+    width: number;
+    height: number;
+    initialViewport?: ViewportState;
+    style?: CSSProperties;
+    imperativeRef?: MutableRefObject<AnnotationCanvasHandle | null>;
+}
+export type PanTrigger = 'middleMouse' | 'rightMouse' | 'space';
+export interface GestureConfig {
+    wheel?: 'zoom' | 'pan' | 'auto';
+    panTriggers?: PanTrigger[];
+}
+export declare const AnnotationCanvasInner: (props: AnnotationCanvasInnerProps) => import("react/jsx-runtime").JSX.Element;

package/dist/canvas/AnnotationCanvasInner.js

@@ -0,0 +1,219 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useFont } from '@shopify/react-native-skia';
+import { useCallback, useEffect, useRef, } from 'react';
+import { AnnotationCanvasSkia } from './AnnotationCanvasSkia.js';
+import { useAnnotationCanvasState, } from './useAnnotationCanvasState.js';
+import { STAMP_TILE_SIZE } from './stampLayout.js';
+const DEFAULT_PAN_TRIGGERS = ['middleMouse', 'space'];
+export const AnnotationCanvasInner = (props) => {
+    const { fallbackUnit, fractionalTolerance, decimalTolerance, resolveImageUrl, stampFontSource, stampValueFontSize = 14, stampLabelFontSize = 11, gestures, width, height, style, activeToolId, tools, } = props;
+    const wheelMode = gestures?.wheel ?? 'auto';
+    const panTriggers = gestures?.panTriggers ?? DEFAULT_PAN_TRIGGERS;
+    const allowSpacePan = panTriggers.includes('space');
+    const allowMiddlePan = panTriggers.includes('middleMouse');
+    const allowRightPan = panTriggers.includes('rightMouse');
+    const valueFont = useFont(stampFontSource, stampValueFontSize);
+    const labelFont = useFont(stampFontSource, stampLabelFontSize);
+    const state = useAnnotationCanvasState(props);
+    const containerRef = useRef(null);
+    const panGestureRef = useRef(null);
+    const spaceDownRef = useRef(false);
+    const activeTool = tools.find((t) => t.id === activeToolId) ?? null;
+    const toCanvasPointer = useCallback((event) => {
+        const rect = containerRef.current?.getBoundingClientRect();
+        const screen = {
+            x: event.clientX - (rect?.left ?? 0),
+            y: event.clientY - (rect?.top ?? 0),
+        };
+        return {
+            pointerId: event.pointerId,
+            screen,
+            world: state.ctx.viewport.screenToWorld(screen),
+            pressure: event.pressure || undefined,
+            shiftKey: event.shiftKey,
+            altKey: event.altKey,
+            metaKey: event.metaKey,
+            ctrlKey: event.ctrlKey,
+        };
+    }, [state.ctx.viewport]);
+    const isPanTriggerDown = useCallback((event) => {
+        if (allowMiddlePan && event.button === 1)
+            return true;
+        if (allowRightPan && event.button === 2)
+            return true;
+        if (allowSpacePan && event.button === 0 && spaceDownRef.current)
+            return true;
+        return false;
+    }, [allowMiddlePan, allowRightPan, allowSpacePan]);
+    const handlePointerDown = useCallback((event) => {
+        const rect = containerRef.current?.getBoundingClientRect();
+        const screen = {
+            x: event.clientX - (rect?.left ?? 0),
+            y: event.clientY - (rect?.top ?? 0),
+        };
+        if (isPanTriggerDown(event)) {
+            panGestureRef.current = { pointerId: event.pointerId, lastScreen: screen };
+            event.currentTarget.setPointerCapture(event.pointerId);
+            event.preventDefault();
+            return;
+        }
+        event.currentTarget.setPointerCapture(event.pointerId);
+        state.dispatchPointerDown(toCanvasPointer(event));
+    }, [state, toCanvasPointer, isPanTriggerDown]);
+    const handlePointerMove = useCallback((event) => {
+        const pan = panGestureRef.current;
+        if (pan && event.pointerId === pan.pointerId) {
+            const rect = containerRef.current?.getBoundingClientRect();
+            const screen = {
+                x: event.clientX - (rect?.left ?? 0),
+                y: event.clientY - (rect?.top ?? 0),
+            };
+            state.pan({
+                x: screen.x - pan.lastScreen.x,
+                y: screen.y - pan.lastScreen.y,
+            });
+            panGestureRef.current = { pointerId: pan.pointerId, lastScreen: screen };
+            return;
+        }
+        state.dispatchPointerMove(toCanvasPointer(event));
+    }, [state, toCanvasPointer]);
+    const handlePointerUp = useCallback((event) => {
+        const pan = panGestureRef.current;
+        if (pan && event.pointerId === pan.pointerId) {
+            panGestureRef.current = null;
+            return;
+        }
+        state.dispatchPointerUp(toCanvasPointer(event));
+    }, [state, toCanvasPointer]);
+    const handlePointerCancel = useCallback(() => {
+        panGestureRef.current = null;
+        state.dispatchPointerCancel();
+    }, [state]);
+    const handleWheel = useCallback((event) => {
+        const rect = containerRef.current?.getBoundingClientRect();
+        const focal = {
+            x: event.clientX - (rect?.left ?? 0),
+            y: event.clientY - (rect?.top ?? 0),
+        };
+        if (event.ctrlKey || event.metaKey) {
+            const factor = Math.exp(-event.deltaY / 200);
+            state.zoom(focal, state.ctx.viewport.state.zoom * factor);
+            return;
+        }
+        if (wheelMode === 'zoom') {
+            const factor = Math.exp(-event.deltaY / 300);
+            state.zoom(focal, state.ctx.viewport.state.zoom * factor);
+            return;
+        }
+        if (event.shiftKey) {
+            state.pan({ x: event.deltaY, y: event.deltaX });
+            return;
+        }
+        state.pan({ x: event.deltaX, y: event.deltaY });
+    }, [state, wheelMode]);
+    const handleContextMenu = useCallback((event) => {
+        if (allowRightPan)
+            event.preventDefault();
+    }, [allowRightPan]);
+    useEffect(() => {
+        const el = containerRef.current;
+        if (!el)
+            return;
+        const stop = (e) => {
+            if (e.target === el || el.contains(e.target)) {
+                e.preventDefault();
+            }
+        };
+        el.addEventListener('wheel', stop, { passive: false });
+        return () => el.removeEventListener('wheel', stop);
+    }, []);
+    useEffect(() => {
+        if (!allowSpacePan)
+            return;
+        const onKeyDown = (e) => {
+            if (e.code === 'Space' && !e.repeat) {
+                spaceDownRef.current = true;
+                if (containerRef.current)
+                    containerRef.current.style.cursor = 'grab';
+            }
+        };
+        const onKeyUp = (e) => {
+            if (e.code === 'Space') {
+                spaceDownRef.current = false;
+                if (containerRef.current)
+                    containerRef.current.style.cursor = '';
+            }
+        };
+        window.addEventListener('keydown', onKeyDown);
+        window.addEventListener('keyup', onKeyUp);
+        return () => {
+            window.removeEventListener('keydown', onKeyDown);
+            window.removeEventListener('keyup', onKeyUp);
+        };
+    }, [allowSpacePan]);
+    const containerStyle = {
+        position: 'relative',
+        width,
+        height,
+        overflow: 'hidden',
+        touchAction: 'none',
+        userSelect: 'none',
+        cursor: activeTool?.cursor ?? 'default',
+        ...style,
+    };
+    const customPreview = activeTool?.renderPreview?.(state.customPreviewState, state.ctx);
+    const { renderMeasurementStamp, selection } = props;
+    return (_jsxs("div", { ref: containerRef, style: containerStyle, onPointerDown: handlePointerDown, onPointerMove: handlePointerMove, onPointerUp: handlePointerUp, onPointerCancel: handlePointerCancel, onWheel: handleWheel, onContextMenu: handleContextMenu, children: [AnnotationCanvasSkia({
+                width,
+                height,
+                effectiveCanvas: state.effectiveCanvas,
+                worldTransform: state.worldTransform,
+                measurementsById: state.measurementsById,
+                fallbackUnit,
+                fractionalTolerance,
+                decimalTolerance,
+                resolveImageUrl,
+                valueFont,
+                labelFont,
+                hideMeasurementStamps: !!renderMeasurementStamp,
+                penDrawingStroke: state.penDrawingStroke,
+                customPreview,
+            }), renderMeasurementStamp && (_jsx("div", { style: {
+                    position: 'absolute',
+                    inset: 0,
+                    pointerEvents: 'none',
+                }, children: state.effectiveCanvas.placedMeasurements.map((placed) => {
+                    const size = STAMP_TILE_SIZE * (placed.scale ?? 1);
+                    const cx = (placed.anchor.x - state.viewport.pan.x) * state.viewport.zoom;
+                    const cy = (placed.anchor.y - state.viewport.pan.y) * state.viewport.zoom;
+                    const isSelected = selection?.ids.includes(placed.id) ?? false;
+                    return (_jsxs("div", { style: {
+                            position: 'absolute',
+                            left: 0,
+                            top: 0,
+                            width: size,
+                            height: size,
+                            transform: `translate(${cx - size / 2}px, ${cy - size / 2}px)`,
+                        }, children: [renderMeasurementStamp({
+                                placed,
+                                measurement: state.measurementsById.get(placed.measurementId) ?? null,
+                                selected: isSelected,
+                                size,
+                                zoom: state.viewport.zoom,
+                            }), isSelected && (_jsx("div", { role: "button", "aria-label": "Remove measurement", onPointerDown: (e) => {
+                                    e.stopPropagation();
+                                    state.ctx.commit({
+                                        ops: [{ op: 'removeMeasurement', id: placed.id }],
+                                    });
+                                    state.ctx.setSelection(null);
+                                }, style: {
+                                    position: 'absolute',
+                                    top: -10,
+                                    right: -10,
+                                    width: 40,
+                                    height: 40,
+                                    cursor: 'pointer',
+                                    pointerEvents: 'auto',
+                                } }))] }, placed.id));
+                }) }))] }));
+};

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

@@ -0,0 +1,35 @@
+import { type MutableRefObject } from 'react';
+import { type ViewStyle } from 'react-native';
+import type { RenderMeasurementStamp } from './measurementStampOverlay.js';
+import type { DecimalTolerance, FractionalTolerance, Measurement, Units } from '../types/firestore.js';
+import type { AnnotationCanvasState, AnnotationDocumentPatch, Selection } from '../types/annotation.js';
+import type { MeasurementRef } from './measurementPicker.js';
+import type { Tool } from './Tool.js';
+import { type AnnotationCanvasHandle } from './useAnnotationCanvasState.js';
+import type { ViewportState } from './viewport.js';
+export type { AnnotationCanvasHandle };
+export interface AnnotationCanvasInnerProps {
+    canvas: AnnotationCanvasState;
+    onCommit(patch: AnnotationDocumentPatch): void;
+    tools: Tool[];
+    activeToolId: string;
+    selection: Selection | null;
+    onSelectionChange(selection: Selection | null): void;
+    measurements?: Measurement[];
+    fallbackUnit?: Units;
+    fractionalTolerance?: FractionalTolerance;
+    decimalTolerance?: DecimalTolerance;
+    resolveImageUrl?: (storagePath: string) => Promise<string>;
+    pickMeasurement?: () => Promise<MeasurementRef | null>;
+    renderMeasurementStamp?: RenderMeasurementStamp;
+    stampFontSource?: unknown;
+    stampValueFontSize?: number;
+    stampLabelFontSize?: number;
+    gestures?: unknown;
+    width: number;
+    height: number;
+    initialViewport?: ViewportState;
+    style?: ViewStyle;
+    imperativeRef?: MutableRefObject<AnnotationCanvasHandle | null>;
+}
+export declare const AnnotationCanvasInner: (props: AnnotationCanvasInnerProps) => import("react/jsx-runtime").JSX.Element;

package/dist/canvas/AnnotationCanvasInner.native.js

@@ -0,0 +1,138 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useFont } from '@shopify/react-native-skia';
+import { useMemo, useRef } from 'react';
+import { StyleSheet, TouchableOpacity, View } from 'react-native';
+import { Gesture, GestureDetector, GestureHandlerRootView, } from 'react-native-gesture-handler';
+import { STAMP_TILE_SIZE } from './stampLayout.js';
+import { AnnotationCanvasSkia } from './AnnotationCanvasSkia.js';
+import { useAnnotationCanvasState, } from './useAnnotationCanvasState.js';
+// 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.
+export const AnnotationCanvasInner = (props) => {
+    const { fallbackUnit, fractionalTolerance, decimalTolerance, resolveImageUrl, stampFontSource, stampValueFontSize = 14, stampLabelFontSize = 11, width, height, style, } = props;
+    const valueFont = useFont(stampFontSource, stampValueFontSize);
+    const labelFont = useFont(stampFontSource, stampLabelFontSize);
+    const state = useAnnotationCanvasState(props);
+    // Per-gesture refs so we always emit a matching down/move/up sequence.
+    const pointerIdRef = useRef(1);
+    const inFlightRef = useRef(null);
+    const pinchStartZoomRef = useRef(1);
+    const buildEvent = (pointerId, screen) => ({
+        pointerId,
+        screen,
+        world: state.ctx.viewport.screenToWorld(screen),
+    });
+    const gesture = useMemo(() => {
+        const toolPan = Gesture.Pan()
+            .minPointers(1)
+            .maxPointers(1)
+            .runOnJS(true)
+            .onBegin((e) => {
+            const id = pointerIdRef.current++;
+            const screen = { x: e.x, y: e.y };
+            inFlightRef.current = { id, lastScreen: screen };
+            state.dispatchPointerDown(buildEvent(id, screen));
+        })
+            .onUpdate((e) => {
+            const f = inFlightRef.current;
+            if (!f)
+                return;
+            const screen = { x: e.x, y: e.y };
+            f.lastScreen = screen;
+            state.dispatchPointerMove(buildEvent(f.id, screen));
+        })
+            .onEnd((e) => {
+            const f = inFlightRef.current;
+            if (!f)
+                return;
+            state.dispatchPointerUp(buildEvent(f.id, { x: e.x, y: e.y }));
+            inFlightRef.current = null;
+        })
+            .onFinalize(() => {
+            if (inFlightRef.current) {
+                state.dispatchPointerCancel();
+                inFlightRef.current = null;
+            }
+        });
+        const tap = Gesture.Tap()
+            .maxDuration(250)
+            .runOnJS(true)
+            .onEnd((e) => {
+            const id = pointerIdRef.current++;
+            const screen = { x: e.x, y: e.y };
+            // Synthesize a down+up sequence so tools that only listen to
+            // onPointerUp (e.g. measurement stamp) still fire.
+            state.dispatchPointerDown(buildEvent(id, screen));
+            state.dispatchPointerUp(buildEvent(id, screen));
+        });
+        const viewportPan = Gesture.Pan()
+            .minPointers(2)
+            .maxPointers(2)
+            .runOnJS(true)
+            .onChange((e) => {
+            state.pan({ x: e.changeX, y: e.changeY });
+        });
+        const pinch = Gesture.Pinch()
+            .runOnJS(true)
+            .onBegin(() => {
+            pinchStartZoomRef.current = state.ctx.viewport.state.zoom;
+        })
+            .onUpdate((e) => {
+            state.zoom({ x: e.focalX, y: e.focalY }, pinchStartZoomRef.current * e.scale);
+        });
+        return Gesture.Race(tap, Gesture.Simultaneous(viewportPan, pinch), toolPan);
+    }, [state]);
+    const activeTool = props.tools.find((t) => t.id === props.activeToolId) ?? null;
+    const customPreview = activeTool?.renderPreview?.(state.customPreviewState, state.ctx);
+    const { renderMeasurementStamp, 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,
+                        effectiveCanvas: state.effectiveCanvas,
+                        worldTransform: state.worldTransform,
+                        measurementsById: state.measurementsById,
+                        fallbackUnit,
+                        fractionalTolerance,
+                        decimalTolerance,
+                        resolveImageUrl,
+                        valueFont,
+                        labelFont,
+                        hideMeasurementStamps: !!renderMeasurementStamp,
+                        penDrawingStroke: state.penDrawingStroke,
+                        customPreview,
+                    }) }) }), renderMeasurementStamp && (_jsx(View, { pointerEvents: "box-none", style: StyleSheet.absoluteFill, children: state.effectiveCanvas.placedMeasurements.map((placed) => {
+                    const size = STAMP_TILE_SIZE * (placed.scale ?? 1);
+                    const cx = (placed.anchor.x - state.viewport.pan.x) * state.viewport.zoom;
+                    const cy = (placed.anchor.y - state.viewport.pan.y) * state.viewport.zoom;
+                    const isSelected = selection?.ids.includes(placed.id) ?? false;
+                    return (_jsxs(View, { pointerEvents: "box-none", style: {
+                            position: 'absolute',
+                            left: 0,
+                            top: 0,
+                            width: size,
+                            height: size,
+                            transform: [
+                                { translateX: cx - size / 2 },
+                                { translateY: cy - size / 2 },
+                            ],
+                        }, children: [_jsx(View, { pointerEvents: "none", style: StyleSheet.absoluteFill, children: renderMeasurementStamp({
+                                    placed,
+                                    measurement: state.measurementsById.get(placed.measurementId) ?? null,
+                                    selected: isSelected,
+                                    size,
+                                    zoom: state.viewport.zoom,
+                                }) }), isSelected && (_jsx(TouchableOpacity, { accessibilityRole: "button", accessibilityLabel: "Remove measurement", hitSlop: 10, onPress: () => {
+                                    state.ctx.commit({
+                                        ops: [{ op: 'removeMeasurement', id: placed.id }],
+                                    });
+                                    state.ctx.setSelection(null);
+                                }, style: {
+                                    position: 'absolute',
+                                    top: -8,
+                                    right: -8,
+                                    width: 36,
+                                    height: 36,
+                                } }))] }, placed.id));
+                }) }))] }));
+};

package/dist/canvas/AnnotationCanvasSkia.d.ts

@@ -0,0 +1,27 @@
+import { type SkFont } from '@shopify/react-native-skia';
+import type { ReactNode } from 'react';
+import type { AnnotationCanvasState, AnnotationStroke } from '../types/annotation.js';
+import { DecimalTolerance, FractionalTolerance, Units, type Measurement } from '../types/firestore.js';
+export interface AnnotationCanvasSkiaProps {
+    width: number;
+    height: number;
+    effectiveCanvas: AnnotationCanvasState;
+    worldTransform: Array<{
+        scale: number;
+    } | {
+        translateX: number;
+    } | {
+        translateY: number;
+    }>;
+    measurementsById: Map<string, Measurement>;
+    fallbackUnit?: Units;
+    fractionalTolerance?: FractionalTolerance;
+    decimalTolerance?: DecimalTolerance;
+    resolveImageUrl?: (storagePath: string) => Promise<string>;
+    valueFont: SkFont | null;
+    labelFont: SkFont | null;
+    hideMeasurementStamps?: boolean;
+    penDrawingStroke: AnnotationStroke | null;
+    customPreview?: ReactNode;
+}
+export declare const AnnotationCanvasSkia: ({ width, height, effectiveCanvas, worldTransform, measurementsById, fallbackUnit, fractionalTolerance, decimalTolerance, resolveImageUrl, valueFont, labelFont, hideMeasurementStamps, penDrawingStroke, customPreview, }: AnnotationCanvasSkiaProps) => import("react/jsx-runtime").JSX.Element;

package/dist/canvas/AnnotationCanvasSkia.js

@@ -0,0 +1,20 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Canvas, Group } from '@shopify/react-native-skia';
+import { Units, } from '../types/firestore.js';
+import { BackgroundImageElement } from './elements/BackgroundImageElement.js';
+import { MeasurementStampElement } from './elements/MeasurementStampElement.js';
+import { ShapeElement } from './elements/ShapeElement.js';
+import { StrokeElement } from './elements/StrokeElement.js';
+// Platform-agnostic Skia subtree shared by web and native Inners.
+//
+// Call this as a FUNCTION (`AnnotationCanvasSkia({ ... })`), not as a JSX
+// component (`<AnnotationCanvasSkia ... />`). Used as a component, it adds
+// a React component boundary between the parent and Skia's `<Canvas>` that
+// breaks Skia's reconciler when the page first calls `useFont` — the JS
+// thread hangs in `MakeFreeTypeFaceFromData`. Symptoms only appeared on
+// Vite's dev server with a symlinked boldr-utils + React Refresh, but
+// since the function-call pattern works identically on native we use it
+// in both Inners for consistency. Don't add hooks here; this is a plain
+// JSX-returning helper, not a component.
+export const AnnotationCanvasSkia = ({ width, height, effectiveCanvas, worldTransform, measurementsById, fallbackUnit, fractionalTolerance, decimalTolerance, resolveImageUrl, valueFont, labelFont, hideMeasurementStamps, penDrawingStroke, customPreview, }) => (_jsx(Canvas, { style: { width, height }, children: _jsxs(Group, { transform: worldTransform, children: [effectiveCanvas.viewport.backgroundImage && (_jsx(BackgroundImageElement, { image: effectiveCanvas.viewport.backgroundImage, docWidth: effectiveCanvas.viewport.width, docHeight: effectiveCanvas.viewport.height, fit: effectiveCanvas.viewport.backgroundFit ?? 'contain', resolveUrl: resolveImageUrl })), effectiveCanvas.strokes.map((stroke) => (_jsx(StrokeElement, { stroke: stroke }, stroke.id))), effectiveCanvas.shapes.map((shape) => (_jsx(ShapeElement, { shape: shape, font: valueFont }, shape.id))), !hideMeasurementStamps &&
+                effectiveCanvas.placedMeasurements.map((placed) => (_jsx(MeasurementStampElement, { placed: placed, measurement: measurementsById.get(placed.measurementId) ?? null, fallbackUnit: fallbackUnit ?? Units.Millimeters, fractionalTolerance: fractionalTolerance, decimalTolerance: decimalTolerance, valueFont: valueFont, labelFont: labelFont }, placed.id))), penDrawingStroke && _jsx(StrokeElement, { stroke: penDrawingStroke }), customPreview] }) }));