@reekon-tools/boldr-utils 1.17.4 → 1.18.0

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

@@ -1469,10 +1469,16 @@ export const AnnotationCanvasInner = (props) => {
                     // drag once every annotation element misses, and only when ALREADY
                     // selected (tap-to-select flows through the tool's pointer
                     // handlers). The hit rides the exact same dragX/dragY transform and
-                    // buildTranslatePatch commit as any other element.
+                    // buildTranslatePatch commit as any other element. A LOCKED layer
+                    // never moves: the drag is inert, and the selection stays so the
+                    // chrome's lock toggle remains reachable.
                     const bg = cfg.hitTestSelectedBackground?.(st.ctx.document, world, st.ctx.selection?.ids ?? []);
                     if (bg) {
-                        dragTargetRef.current = bg;
+                        if (bg.locked) {
+                            dragTargetRef.current = null;
+                            return;
+                        }
+                        dragTargetRef.current = { id: bg.id, kind: bg.kind };
                         setDraggingId(bg.id);
                         return;
                     }

package/dist/annotation/canvas/AnnotationCanvasSkia.js

@@ -4,7 +4,7 @@ import { normalizeRect, placementOf } from './measurementGeometry.js';
 import { arrowheadTriangle, dashIntervals, toSkiaStrokeCap, } from './strokeGeometry.js';
 import { SELECTION_PAD, textResizeGeometry, textShapeBounds, } from './textGeometry.js';
 import { visualShapeBounds } from './shapeGeometry.js';
-import { backgroundLayerDocRect, backgroundLayersOf, canEditBackgroundLayers, } from './backgroundLayers.js';
+import { backgroundLayerDocRect, backgroundLayersOf, isBackgroundLayerLocked, } from './backgroundLayers.js';
 import { BackgroundLayerElement } from './elements/BackgroundImageElement.js';
 import { PlaneElement, PLANE_CHROME_COLOR, PLANE_GRID_COLOR, PLANE_GRID_OPACITY, PLANE_GRID_WIDTH, PLANE_OUTLINE_WIDTH, } from './elements/PlaneElement.js';
 import { ShapeElement } from './elements/ShapeElement.js';
@@ -253,18 +253,17 @@ export const AnnotationCanvasSkia = ({ width, height, effectiveCanvas, worldTran
                 // bottom-right handle — backgrounds scale uniformly about their
                 // top-left corner (the transform origin), so a single opposite-corner
                 // grab is the whole gizmo. Chrome tracks the live drag/resize
-                // transform the same way the layer itself does above. A lone
-                // background is never editable (canEditBackgroundLayers), so it gets
-                // no chrome even when a stale selection still names it — e.g. right
-                // after the other layer of a pair was removed.
-                const layer = canEditBackgroundLayers(effectiveCanvas.viewport)
-                    ? backgroundLayersOf(effectiveCanvas.viewport).find((l) => l.id === selectedId)
-                    : undefined;
+                // transform the same way the layer itself does above. A LOCKED layer
+                // (backgroundLayerIsLocked) keeps the outline — it is selected, and
+                // the host's chrome offers the lock toggle — but gets no handle: it
+                // cannot scale, so a grabbable corner would lie.
+                const layer = backgroundLayersOf(effectiveCanvas.viewport).find((l) => l.id === selectedId);
                 if (layer) {
+                    const locked = isBackgroundLayerLocked(effectiveCanvas.viewport, layer.id);
                     const r = backgroundLayerDocRect(layer);
                     const isResizing = layer.id === resizingId;
                     const liveTransform = isResizing ? resizeTransform : dragTransform;
-                    return (_jsxs(DraggableElement, { isDragging: isDragging || isResizing, transform: liveTransform, children: [_jsx(Rect, { x: r.x, y: r.y, width: r.width, height: r.height, color: SELECTION_COLOR, style: "stroke", strokeWidth: SELECTION_STROKE }), handleRadius != null && (_jsx(Handle, { c: { x: r.x + r.width, y: r.y + r.height }, r: handleRadius, ringWidth: handleRingWidth, color: SELECTION_COLOR }))] }));
+                    return (_jsxs(DraggableElement, { isDragging: isDragging || isResizing, transform: liveTransform, children: [_jsx(Rect, { x: r.x, y: r.y, width: r.width, height: r.height, color: SELECTION_COLOR, style: "stroke", strokeWidth: SELECTION_STROKE }), handleRadius != null && !locked && (_jsx(Handle, { c: { x: r.x + r.width, y: r.y + r.height }, r: handleRadius, ringWidth: handleRingWidth, color: SELECTION_COLOR }))] }));
                 }
                 return null;
             })(), penDrawingStroke && _jsx(StrokeElement, { stroke: penDrawingStroke }), shapePreview && (_jsxs(_Fragment, { children: [_jsx(Path, { path: shapePreview.path, color: shapePreview.color, style: "stroke", strokeWidth: shapePreview.width, strokeCap: toSkiaStrokeCap(shapePreview.cap), strokeJoin: "round", children: shapePreview.dash && (_jsx(DashPathEffect, { intervals: dashIntervals(shapePreview.width) })) }), _jsx(Path, { path: shapePreview.headPath, color: shapePreview.color, style: "fill" })] })), livePreview?.handoffPaths?.map((p, i) => (_jsx(Path, { path: p, color: livePreview.color, style: "stroke", strokeWidth: livePreview.width, strokeCap: toSkiaStrokeCap(livePreview.cap), strokeJoin: "round", opacity: livePreview.opacity, children: livePreview.dash && (_jsx(DashPathEffect, { intervals: dashIntervals(livePreview.width) })) }, i))), livePreview && (_jsx(Path, { path: livePreview.path, color: livePreview.color, style: "stroke", strokeWidth: livePreview.width, strokeCap: toSkiaStrokeCap(livePreview.cap), strokeJoin: "round", opacity: livePreview.opacity, children: livePreview.dash && (_jsx(DashPathEffect, { intervals: dashIntervals(livePreview.width) })) })), customPreview] }));

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

@@ -82,10 +82,12 @@ export interface DragSelectionConfig {
     isSelectedTileGrab?(doc: AnnotationCanvasState, id: AnnotationElementId, world: Vec2, zoom: number, viewportTileScale?: number, tileScaleFactor?: number, headerTileScaleFactor?: number, fileTileScaleFactor?: number): boolean;
     hitTestBackground?(doc: AnnotationCanvasState, world: Vec2): {
         id: AnnotationElementId;
+        locked: boolean;
     } | null;
     hitTestSelectedBackground?(doc: AnnotationCanvasState, world: Vec2, selectedIds: AnnotationElementId[]): {
         id: AnnotationElementId;
         kind: 'background';
+        locked: boolean;
     } | null;
     hitTestResizeHandle?(doc: AnnotationCanvasState, id: AnnotationElementId, world: Vec2, zoom: number): ResizeGeometry | null;
     buildResizePatch?(doc: AnnotationCanvasState, id: AnnotationElementId, delta: Vec2): AnnotationDocumentPatch | null;

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

@@ -2,7 +2,9 @@ import type { AnnotationBackgroundLayer, AnnotationViewport, BackgroundLayerTran
 export declare const LEGACY_BACKGROUND_LAYER_ID = "background-legacy";
 export declare const BACKGROUND_PLACEMENT_GAP_RATIO = 0.02;
 export declare const backgroundLayersOf: (viewport: AnnotationViewport) => AnnotationBackgroundLayer[];
-export declare const canEditBackgroundLayers: (viewport: AnnotationViewport) => boolean;
+export declare const backgroundLayerIsLocked: (layer: AnnotationBackgroundLayer, index: number) => boolean;
+export declare const isBackgroundLayerLocked: (viewport: AnnotationViewport, id: string) => boolean;
+export declare const defaultBackgroundLayerLocked: (existing: AnnotationBackgroundLayer[]) => boolean;
 export declare const backgroundLayerDocRect: (layer: AnnotationBackgroundLayer) => {
     x: number;
     y: number;

package/dist/annotation/canvas/backgroundLayers.js

@@ -46,14 +46,29 @@ export const backgroundLayersOf = (viewport) => {
         },
     ];
 };
-// Whether the background stack is user-editable at all — selectable, draggable,
-// corner-scalable. A lone image IS the canvas: there is nothing to arrange it
-// against, so it exposes no selection chrome and never moves; taps and drags
-// on it fall through to the ordinary empty-canvas behavior (deselect / pan).
-// Only once a second image exists does arranging make sense, and then every
-// layer becomes editable. Shared by the select tool's hit-tests and the
-// selection chrome so both platforms agree on the rule.
-export const canEditBackgroundLayers = (viewport) => backgroundLayersOf(viewport).length > 1;
+// Lock state of one layer in the stack. Every background is selectable; a
+// LOCKED one additionally refuses to move, corner-scale, or delete — it is
+// the canvas the rest is arranged against. `locked` is explicit on layers
+// written since the flag existed; absence falls back to the position rule the
+// default follows (see defaultBackgroundLayerLocked): the bottom layer —
+// index 0, the first image placed or the legacy single slot — is locked,
+// every later one is free. So a pre-flag doc behaves the way a fresh one
+// would: its base photo stays put, images added beside it arrange freely.
+// Shared by the select tool's hit-tests and the selection chrome so both
+// platforms agree on the rule.
+export const backgroundLayerIsLocked = (layer, index) => layer.locked ?? index === 0;
+// Lock state of the layer with `id` in this viewport's stack. False for an
+// unknown id — a stale selection naming a removed layer locks nothing.
+export const isBackgroundLayerLocked = (viewport, id) => {
+    const layers = backgroundLayersOf(viewport);
+    const index = layers.findIndex((l) => l.id === id);
+    return index >= 0 && backgroundLayerIsLocked(layers[index], index);
+};
+// Lock state a newly added image starts with: the first image on a canvas is
+// locked (it IS the canvas), later ones are free so they can be arranged
+// against it. Written explicitly onto the new layer so the state survives
+// later removals — a second image stays free even once it is the only one.
+export const defaultBackgroundLayerLocked = (existing) => existing.length === 0;
 // The doc-space rectangle a layer occupies: the intrinsic pixel grid under
 // the layer's translate+scale.
 export const backgroundLayerDocRect = (layer) => ({

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

@@ -1,4 +1,4 @@
-import { backgroundLayerDocRect, backgroundLayersOf, canEditBackgroundLayers, } from '../backgroundLayers.js';
+import { backgroundLayerDocRect, backgroundLayerIsLocked, backgroundLayersOf, isBackgroundLayerLocked, } from '../backgroundLayers.js';
 import { stampTileDims } from '../stampLayout.js';
 import { placementOf, linePosOf, snapLinePos, lerp, recomputeAnchor, rectCenter, rectCornerPoint, oppositeRectCorner, hitPlacedMeasurement, } from '../measurementGeometry.js';
 import { hitShapeOutline, visualShapeBounds } from '../shapeGeometry.js';
@@ -114,9 +114,10 @@ const translatePatch = (elementKind, id, doc, delta) => {
     if (elementKind === 'background') {
         // Looked up through the normalized view so a legacy single-image doc's
         // synthesized layer is draggable too — the dedicated op materializes the
-        // array on apply.
+        // array on apply. A locked layer never moves, whatever the caller thought
+        // it grabbed (belt and suspenders under the hit-tests below).
         const layer = backgroundLayerById(doc, id);
-        if (!layer)
+        if (!layer || isBackgroundLayerLocked(doc.viewport, id))
             return null;
         return {
             op: 'updateBackgroundImage',
@@ -462,10 +463,11 @@ const shapeCornerPatch = (doc, id, corner, delta) => {
 // hit-test: a tap selects one only when every stroke/shape/measurement
 // misses, and a drag translates one only when it is ALREADY selected — the
 // layout tool's two-step model, which keeps a full-bleed background from
-// hijacking pan/marquee gestures. And none of it applies to a LONE image: with
-// a single background there is nothing to arrange, so it is not selectable,
-// draggable, or scalable at all (canEditBackgroundLayers) — every hit-test
-// below misses, and the gesture falls through to deselect / pan. ---
+// hijacking pan/marquee gestures. A LOCKED layer (backgroundLayerIsLocked —
+// by default the first image, which IS the canvas) is selectable like any
+// other, but never moves or scales:
+// the drag/resize hit-tests below refuse it, and a gesture on it behaves like
+// empty canvas (pan) while leaving the selection in place. ---
 // Doc-space clamp on a resized background's larger doc dimension. The floor
 // keeps a corner drag from collapsing a layer below grabbable size; the
 // ceiling keeps the doc rect (which feeds fit math and the web SVG raster
@@ -481,12 +483,11 @@ const pointInBackgroundLayer = (layer, p) => {
 // layers draw on top). Point-in-doc-rect, no padding: a background is a big
 // target already.
 const findBackgroundHit = (doc, world) => {
-    if (!canEditBackgroundLayers(doc.viewport))
-        return null;
     const layers = backgroundLayersOf(doc.viewport);
     for (let i = layers.length - 1; i >= 0; i--) {
-        if (pointInBackgroundLayer(layers[i], world)) {
-            return { id: layers[i].id };
+        const layer = layers[i];
+        if (pointInBackgroundLayer(layer, world)) {
+            return { id: layer.id, locked: backgroundLayerIsLocked(layer, i) };
         }
     }
     return null;
@@ -495,15 +496,17 @@ const findBackgroundHit = (doc, world) => {
 // paths call this only after the general hit-test misses, so annotation
 // elements always win a grab over the background beneath them.
 const findSelectedBackgroundHit = (doc, world, selectedIds) => {
-    if (!canEditBackgroundLayers(doc.viewport))
-        return null;
     const layers = backgroundLayersOf(doc.viewport);
     for (let i = layers.length - 1; i >= 0; i--) {
         const layer = layers[i];
         if (!selectedIds.includes(layer.id))
             continue;
         if (pointInBackgroundLayer(layer, world)) {
-            return { id: layer.id, kind: 'background' };
+            return {
+                id: layer.id,
+                kind: 'background',
+                locked: backgroundLayerIsLocked(layer, i),
+            };
         }
     }
     return null;
@@ -534,9 +537,9 @@ const backgroundResizeGeometry = (layer) => {
 // endpoint handles either way.
 const findResizeHandleHit = (doc, id, world, zoom) => {
     const s = doc.shapes.find((x) => x.id === id);
-    // A lone background is not editable at all (canEditBackgroundLayers), so
-    // its corner offers no handle — even to a stale selection naming it.
-    const layer = s || !canEditBackgroundLayers(doc.viewport)
+    // A locked background cannot scale, so its corner offers no handle (the
+    // chrome draws none either — see AnnotationCanvasSkia).
+    const layer = s || isBackgroundLayerLocked(doc.viewport, id)
         ? null
         : backgroundLayerById(doc, id);
     const geom = s
@@ -561,7 +564,7 @@ const resizePatch = (doc, id, delta) => {
     const s = doc.shapes.find((x) => x.id === id);
     if (!s) {
         const layer = backgroundLayerById(doc, id);
-        if (!layer)
+        if (!layer || isBackgroundLayerLocked(doc.viewport, id))
             return null;
         const geom = backgroundResizeGeometry(layer);
         if (!geom)
@@ -737,10 +740,19 @@ export const createSelectTool = (options = {}) => ({
             // Background layers only get a look-in when every annotation element
             // misses — they can cover the whole document, so elements above always
             // win. An already-selected background grabs as a body drag (and arms
-            // the tap-toggle: a release with no movement deselects it).
+            // the tap-toggle: a release with no movement deselects it). A LOCKED
+            // one never moves: it keeps the tap-toggle but the gesture otherwise
+            // behaves like empty canvas — panning (with panOnEmptyDrag) while the
+            // selection stays put, so the lock toggle in the host's chrome remains
+            // reachable.
             const selectedBg = findSelectedBackgroundHit(ctx.document, world, ctx.selection?.ids ?? []);
             if (selectedBg) {
                 pendingBackgroundDeselectId = selectedBg.id;
+                if (selectedBg.locked) {
+                    return options.panOnEmptyDrag
+                        ? { kind: 'panning', lastScreen: event.screen }
+                        : { kind: 'idle' };
+                }
                 return {
                     kind: 'dragging',
                     id: selectedBg.id,
@@ -750,12 +762,16 @@ export const createSelectTool = (options = {}) => ({
                     delta: { x: 0, y: 0 },
                 };
             }
-            // An unselected background selects only — the gesture is consumed (no
-            // pan, no drag): translating it takes a second gesture once selected,
-            // the layout tool's two-step model.
+            // An unselected background selects. A free one consumes the gesture
+            // (no pan, no drag): translating it takes a second gesture once
+            // selected, the layout tool's two-step model. A locked one is the
+            // canvas: it selects AND the drag pans, as on empty canvas.
             const bg = findBackgroundHit(ctx.document, world);
             if (bg) {
                 ctx.setSelection({ ids: [bg.id] });
+                if (bg.locked && options.panOnEmptyDrag) {
+                    return { kind: 'panning', lastScreen: event.screen };
+                }
                 return { kind: 'idle' };
             }
             ctx.setSelection(null);
@@ -792,10 +808,13 @@ export const createSelectTool = (options = {}) => ({
     onPointerMove(event, ctx, state) {
         const s = state;
         if (s?.kind === 'panning') {
-            ctx.applyPan({
-                x: event.screen.x - s.lastScreen.x,
-                y: event.screen.y - s.lastScreen.y,
-            });
+            const dx = event.screen.x - s.lastScreen.x;
+            const dy = event.screen.y - s.lastScreen.y;
+            // A pan that started on a selected locked background is a pan, not a
+            // re-tap — disarm its deselect toggle once the pointer actually moves.
+            if (dx !== 0 || dy !== 0)
+                pendingBackgroundDeselectId = null;
+            ctx.applyPan({ x: dx, y: dy });
             return { ...s, lastScreen: event.screen };
         }
         if (s?.kind !== 'dragging')

package/dist/annotation/data/hooks/useAnnotationCanvasDoc.js

@@ -1,6 +1,6 @@
 import { useCallback, useEffect, useMemo, useRef, useState } from 'react';
 import { applyPatch, createEmptyCanvasState, } from '../../../types/annotation.js';
-import { backgroundLayersOf, placeNewBackgroundLayer, } from '../../canvas/backgroundLayers.js';
+import { backgroundLayersOf, placeNewBackgroundLayer, defaultBackgroundLayerLocked, } from '../../canvas/backgroundLayers.js';
 import { imageDocRect } from '../../canvas/viewport.js';
 import { FileUploadType } from '../../../types/firestore.js';
 import { useAnnotationDoc } from './useAnnotationDoc.js';
@@ -373,6 +373,7 @@ export const useAnnotationCanvasDoc = (options) => {
         // still-hydrating existing doc can reach here with no working state —
         // fall back to the same empty canvas hydration would start from.
         const { viewport } = workingRef.current ?? createEmptyCanvasState(fallbackViewport);
+        const existing = backgroundLayersOf(viewport);
         onCommit({
             ops: [
                 {
@@ -384,7 +385,10 @@ export const useAnnotationCanvasDoc = (options) => {
                         widthPx: dims.width,
                         heightPx: dims.height,
                         format: backgroundFormatOf(blob),
-                        transform: placeNewBackgroundLayer(backgroundLayersOf(viewport), dims, viewport),
+                        transform: placeNewBackgroundLayer(existing, dims, viewport),
+                        // The first image is the canvas and starts pinned; later ones
+                        // start free so they can be arranged against it.
+                        locked: defaultBackgroundLayerLocked(existing),
                     },
                 },
             ],
@@ -449,6 +453,9 @@ export const useAnnotationCanvasDoc = (options) => {
                             scaleX: dims.width > 0 ? rect.width / dims.width : 1,
                             scaleY: dims.height > 0 ? rect.height / dims.height : 1,
                         },
+                        // The replacement is the sole image — the canvas — so it
+                        // starts pinned like any first image.
+                        locked: true,
                     },
                 },
                 { op: 'setViewport', patch: { backgroundFit: fit } },

package/dist/exports.d.ts

@@ -34,7 +34,7 @@ export type { MeasurementStampRenderArgs, RenderMeasurementStamp, } from './anno
 export { STAMP_TILE_SIZE, GROUP_HEADER_TILE_WIDTH, GROUP_HEADER_TILE_HEIGHT, GROUP_HEADER_COLLAPSED_WIDTH, GROUP_HEADER_COLLAPSED_HEIGHT, GROUP_HEADER_DESIGN, groupHeaderBaseDims, DEFAULT_TILE_SCALE, TILE_SCALE_MIN, TILE_SCALE_MAX, clampTileScale, resolveTileScaleFactor, resolveHeaderTileScaleFactor, resolveFileTileScaleFactor, tileDocSizeForFactor, tileScaleFromDocSize, stampTileSize, stampTileDims, isUnassociatedStamp, isFileStamp, type StampTileDims, } from './annotation/canvas/stampLayout.js';
 export { GROUP_HEADER_STYLE, describeGroupHeader, groupHeaderSignature, type GroupHeaderBadge, type GroupHeaderDescriptor, } from './annotation/canvas/groupHeaderLayout.js';
 export { createViewportApi, fitToScreen, fitRectToScreen, imageDocRect, panBy, zoomAt, DEFAULT_VIEWPORT, type ViewportApi, type ViewportState, } from './annotation/canvas/viewport.js';
-export { LEGACY_BACKGROUND_LAYER_ID, BACKGROUND_PLACEMENT_GAP_RATIO, backgroundLayersOf, canEditBackgroundLayers, backgroundLayerDocRect, backgroundLayersUnionRect, placeNewBackgroundLayer, } from './annotation/canvas/backgroundLayers.js';
+export { LEGACY_BACKGROUND_LAYER_ID, BACKGROUND_PLACEMENT_GAP_RATIO, backgroundLayersOf, backgroundLayerIsLocked, isBackgroundLayerLocked, defaultBackgroundLayerLocked, backgroundLayerDocRect, backgroundLayersUnionRect, placeNewBackgroundLayer, } from './annotation/canvas/backgroundLayers.js';
 export { createPenTool, type PenToolOptions, } from './annotation/canvas/tools/penTool.js';
 export { createSelectTool, type SelectToolOptions, } from './annotation/canvas/tools/selectTool.js';
 export { createMeasurementStampTool, type MeasurementStampToolOptions, } from './annotation/canvas/tools/measurementStampTool.js';

package/dist/exports.js

@@ -39,7 +39,7 @@ export { InMemoryAnnotationProvider } from './annotation/data/InMemoryAnnotation
 export { STAMP_TILE_SIZE, GROUP_HEADER_TILE_WIDTH, GROUP_HEADER_TILE_HEIGHT, GROUP_HEADER_COLLAPSED_WIDTH, GROUP_HEADER_COLLAPSED_HEIGHT, GROUP_HEADER_DESIGN, groupHeaderBaseDims, DEFAULT_TILE_SCALE, TILE_SCALE_MIN, TILE_SCALE_MAX, clampTileScale, resolveTileScaleFactor, resolveHeaderTileScaleFactor, resolveFileTileScaleFactor, tileDocSizeForFactor, tileScaleFromDocSize, stampTileSize, stampTileDims, isUnassociatedStamp, isFileStamp, } from './annotation/canvas/stampLayout.js';
 export { GROUP_HEADER_STYLE, describeGroupHeader, groupHeaderSignature, } from './annotation/canvas/groupHeaderLayout.js';
 export { createViewportApi, fitToScreen, fitRectToScreen, imageDocRect, panBy, zoomAt, DEFAULT_VIEWPORT, } from './annotation/canvas/viewport.js';
-export { LEGACY_BACKGROUND_LAYER_ID, BACKGROUND_PLACEMENT_GAP_RATIO, backgroundLayersOf, canEditBackgroundLayers, backgroundLayerDocRect, backgroundLayersUnionRect, placeNewBackgroundLayer, } from './annotation/canvas/backgroundLayers.js';
+export { LEGACY_BACKGROUND_LAYER_ID, BACKGROUND_PLACEMENT_GAP_RATIO, backgroundLayersOf, backgroundLayerIsLocked, isBackgroundLayerLocked, defaultBackgroundLayerLocked, backgroundLayerDocRect, backgroundLayersUnionRect, placeNewBackgroundLayer, } from './annotation/canvas/backgroundLayers.js';
 export { createPenTool, } from './annotation/canvas/tools/penTool.js';
 export { createSelectTool, } from './annotation/canvas/tools/selectTool.js';
 export { createMeasurementStampTool, } from './annotation/canvas/tools/measurementStampTool.js';

package/dist/types/annotation.d.ts

@@ -143,6 +143,7 @@ export interface AnnotationBackgroundLayer {
     heightPx: number;
     format?: 'raster' | 'svg';
     transform: BackgroundLayerTransform;
+    locked?: boolean;
 }
 export interface AnnotationViewport {
     width: number;

package/package.json

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

package/dist/canvas/AnnotationCanvas.d.ts

@@ -1,11 +0,0 @@
-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

@@ -1,10 +0,0 @@
-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

@@ -1,8 +0,0 @@
-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

@@ -1,6 +0,0 @@
-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

@@ -1,39 +0,0 @@
-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;