@reekon-tools/boldr-utils 1.6.18 → 1.6.19

package/dist/canvas/useAnnotationCanvasState.js

@@ -1,210 +0,0 @@
-import { useCallback, useEffect, useMemo, useRef, useState } from 'react';
-import { applyPatch, invertPatch, DEFAULT_LAYER_ID, } from '../types/annotation.js';
-import { createViewportApi, panBy, zoomAt, DEFAULT_VIEWPORT, } from './viewport.js';
-// Platform-agnostic state machine for the annotation canvas. Web and native
-// inners share this hook; each wraps it with platform-specific event
-// capture and JSX (div + DOM events vs. GestureDetector + RN Views).
-export const useAnnotationCanvasState = (props) => {
-    const { canvas, onCommit, tools, activeToolId, selection, onSelectionChange, measurements, pickMeasurement, width, height, initialViewport, imperativeRef, } = props;
-    const [viewport, setViewport] = useState(initialViewport ?? DEFAULT_VIEWPORT);
-    const [toolState, setToolState] = useState(undefined);
-    const [previewPatch, setPreviewPatch] = useState(null);
-    const undoStackRef = useRef([]);
-    const redoStackRef = useRef([]);
-    const activePointerIdRef = useRef(null);
-    const activeTool = useMemo(() => tools.find((t) => t.id === activeToolId) ?? null, [tools, activeToolId]);
-    const effectiveCanvas = useMemo(() => (previewPatch ? applyPatch(canvas, previewPatch) : canvas), [canvas, previewPatch]);
-    const measurementsById = useMemo(() => {
-        const map = new Map();
-        measurements?.forEach((m) => map.set(m.id, m));
-        return map;
-    }, [measurements]);
-    const viewportApi = useMemo(() => createViewportApi(viewport), [viewport]);
-    const ctx = useMemo(() => ({
-        document: canvas,
-        selection,
-        viewport: viewportApi,
-        preview(patch) {
-            setPreviewPatch(patch);
-        },
-        commit(patch) {
-            const inverse = invertPatch(canvas, patch);
-            undoStackRef.current.push({ forward: patch, inverse });
-            redoStackRef.current = [];
-            setPreviewPatch(null);
-            onCommit(patch);
-        },
-        setSelection(s) {
-            onSelectionChange(s);
-        },
-        requestPickMeasurement() {
-            return pickMeasurement ? pickMeasurement() : Promise.resolve(null);
-        },
-        applyPan(deltaScreen) {
-            setViewport((v) => panBy(v, deltaScreen));
-        },
-        applyZoom(focalScreen, nextZoom) {
-            setViewport((v) => zoomAt(v, focalScreen, nextZoom));
-        },
-    }), [
-        canvas,
-        selection,
-        viewportApi,
-        onCommit,
-        onSelectionChange,
-        pickMeasurement,
-    ]);
-    // Live ctx for imperative handle methods (which are created in an effect and
-    // would otherwise capture a stale ctx/viewport).
-    const ctxRef = useRef(ctx);
-    ctxRef.current = ctx;
-    const dispatchPointerDown = useCallback((event) => {
-        if (!activeTool)
-            return;
-        activePointerIdRef.current = event.pointerId;
-        const next = activeTool.onPointerDown?.(event, ctx, toolState);
-        if (next !== undefined)
-            setToolState(next);
-    }, [activeTool, ctx, toolState]);
-    const dispatchPointerMove = useCallback((event) => {
-        if (!activeTool)
-            return;
-        if (activePointerIdRef.current !== null &&
-            event.pointerId !== activePointerIdRef.current) {
-            return;
-        }
-        const next = activeTool.onPointerMove?.(event, ctx, toolState);
-        if (next !== undefined)
-            setToolState(next);
-    }, [activeTool, ctx, toolState]);
-    const dispatchPointerUp = useCallback((event) => {
-        if (!activeTool)
-            return;
-        if (activePointerIdRef.current !== null &&
-            event.pointerId !== activePointerIdRef.current) {
-            return;
-        }
-        activeTool.onPointerUp?.(event, ctx, toolState);
-        activePointerIdRef.current = null;
-        setToolState(undefined);
-    }, [activeTool, ctx, toolState]);
-    const dispatchPointerCancel = useCallback(() => {
-        if (activeTool)
-            activeTool.onCancel?.(toolState, ctx);
-        activePointerIdRef.current = null;
-        setToolState(undefined);
-        setPreviewPatch(null);
-    }, [activeTool, ctx, toolState]);
-    const pan = useCallback((deltaScreen) => {
-        setViewport((v) => panBy(v, deltaScreen));
-    }, []);
-    const zoom = useCallback((focalScreen, nextZoom) => {
-        setViewport((v) => zoomAt(v, focalScreen, nextZoom));
-    }, []);
-    // Imperative API mirror — set via prop so it survives WithSkiaWeb's lazy
-    // boundary on web.
-    useEffect(() => {
-        if (!imperativeRef)
-            return;
-        imperativeRef.current = {
-            undo() {
-                const entry = undoStackRef.current.pop();
-                if (!entry)
-                    return;
-                redoStackRef.current.push(entry);
-                onCommit(entry.inverse);
-            },
-            redo() {
-                const entry = redoStackRef.current.pop();
-                if (!entry)
-                    return;
-                undoStackRef.current.push(entry);
-                onCommit(entry.forward);
-            },
-            canUndo() {
-                return undoStackRef.current.length > 0;
-            },
-            canRedo() {
-                return redoStackRef.current.length > 0;
-            },
-            zoomToFit() {
-                setViewport(() => {
-                    const docW = canvas.viewport.width;
-                    const docH = canvas.viewport.height;
-                    const z = Math.min(width / docW, height / docH);
-                    const offsetX = (width - docW * z) / 2;
-                    const offsetY = (height - docH * z) / 2;
-                    return { zoom: z, pan: { x: -offsetX / z, y: -offsetY / z } };
-                });
-            },
-            resetView() {
-                setViewport(DEFAULT_VIEWPORT);
-            },
-            placeMeasurementAtCenter(ref) {
-                const c = ctxRef.current;
-                const anchor = c.viewport.screenToWorld({
-                    x: width / 2,
-                    y: height / 2,
-                });
-                const placed = {
-                    id: `measurement-${Date.now().toString(36)}-${Math.floor(Math.random() * 1e9).toString(36)}`,
-                    layerId: c.document.layers[0]?.id ?? DEFAULT_LAYER_ID,
-                    measurementPath: ref.measurementPath,
-                    measurementId: ref.measurementId,
-                    groupId: ref.groupId,
-                    anchor,
-                    labelOverride: ref.label,
-                    unitOverride: ref.unit,
-                    showLabel: true,
-                    showValue: true,
-                    createdAt: Date.now(),
-                };
-                c.commit({ ops: [{ op: 'addMeasurement', measurement: placed }] });
-                // Select it so the consumer can immediately move it (the consumer is
-                // responsible for switching to its move/select tool).
-                c.setSelection({ ids: [placed.id] });
-            },
-        };
-        return () => {
-            if (imperativeRef)
-                imperativeRef.current = null;
-        };
-    }, [
-        imperativeRef,
-        onCommit,
-        canvas.viewport.width,
-        canvas.viewport.height,
-        width,
-        height,
-    ]);
-    const worldTransform = useMemo(() => [
-        { scale: viewport.zoom },
-        { translateX: -viewport.pan.x },
-        { translateY: -viewport.pan.y },
-    ], [viewport]);
-    // Detect the built-in pen tool's in-flight state shape so the canvas can
-    // render the preview (the tool factory is Skia-free and can't render).
-    const penDrawingStroke = toolState &&
-        typeof toolState === 'object' &&
-        'kind' in toolState &&
-        toolState.kind === 'pen-drawing'
-        ? toolState.stroke
-        : null;
-    return {
-        effectiveCanvas,
-        worldTransform,
-        viewport,
-        measurementsById,
-        activeTool,
-        toolState,
-        ctx,
-        penDrawingStroke,
-        customPreviewState: toolState,
-        dispatchPointerDown,
-        dispatchPointerMove,
-        dispatchPointerUp,
-        dispatchPointerCancel,
-        pan,
-        zoom,
-    };
-};

package/dist/canvas/viewport.d.ts

@@ -1,16 +0,0 @@
-import type { Vec2 } from '../types/annotation.js';
-export interface ViewportState {
-    zoom: number;
-    pan: Vec2;
-}
-export interface ViewportApi {
-    state: ViewportState;
-    screenToWorld(screen: Vec2): Vec2;
-    worldToScreen(world: Vec2): Vec2;
-    worldDistanceToScreen(distance: number): number;
-}
-export declare const createViewportApi: (state: ViewportState) => ViewportApi;
-export declare const DEFAULT_VIEWPORT: ViewportState;
-export declare const fitToScreen: (docWidth: number, docHeight: number, screenWidth: number, screenHeight: number, padding?: number) => ViewportState;
-export declare const zoomAt: (state: ViewportState, focalScreen: Vec2, nextZoom: number) => ViewportState;
-export declare const panBy: (state: ViewportState, deltaScreen: Vec2) => ViewportState;

package/dist/canvas/viewport.js

@@ -1,54 +0,0 @@
-export const createViewportApi = (state) => ({
-    state,
-    screenToWorld: ({ x, y }) => ({
-        x: x / state.zoom + state.pan.x,
-        y: y / state.zoom + state.pan.y,
-    }),
-    worldToScreen: ({ x, y }) => ({
-        x: (x - state.pan.x) * state.zoom,
-        y: (y - state.pan.y) * state.zoom,
-    }),
-    worldDistanceToScreen: (d) => d * state.zoom,
-});
-export const DEFAULT_VIEWPORT = {
-    zoom: 1,
-    pan: { x: 0, y: 0 },
-};
-// Returns a viewport that fits `docWidth x docHeight` into `screenWidth x
-// screenHeight` with optional padding (screen-space pixels).
-export const fitToScreen = (docWidth, docHeight, screenWidth, screenHeight, padding = 16) => {
-    const availableW = Math.max(1, screenWidth - padding * 2);
-    const availableH = Math.max(1, screenHeight - padding * 2);
-    const zoom = Math.min(availableW / docWidth, availableH / docHeight);
-    const renderedW = docWidth * zoom;
-    const renderedH = docHeight * zoom;
-    const offsetX = (screenWidth - renderedW) / 2;
-    const offsetY = (screenHeight - renderedH) / 2;
-    return {
-        zoom,
-        pan: { x: -offsetX / zoom, y: -offsetY / zoom },
-    };
-};
-// Zoom toward a focal screen point so the world point under the cursor stays
-// fixed. Used for wheel-zoom on web and pinch on native.
-export const zoomAt = (state, focalScreen, nextZoom) => {
-    const clampedZoom = Math.max(0.05, Math.min(50, nextZoom));
-    const focalWorld = {
-        x: focalScreen.x / state.zoom + state.pan.x,
-        y: focalScreen.y / state.zoom + state.pan.y,
-    };
-    return {
-        zoom: clampedZoom,
-        pan: {
-            x: focalWorld.x - focalScreen.x / clampedZoom,
-            y: focalWorld.y - focalScreen.y / clampedZoom,
-        },
-    };
-};
-export const panBy = (state, deltaScreen) => ({
-    zoom: state.zoom,
-    pan: {
-        x: state.pan.x - deltaScreen.x / state.zoom,
-        y: state.pan.y - deltaScreen.y / state.zoom,
-    },
-});

package/dist/data/AnnotationDataContext.d.ts

@@ -1,8 +0,0 @@
-import { type ReactNode } from 'react';
-import type { AnnotationDataProvider } from './AnnotationDataProvider.js';
-export interface AnnotationDataProviderProps {
-    value: AnnotationDataProvider;
-    children: ReactNode;
-}
-export declare const AnnotationDataProviderContext: ({ value, children, }: AnnotationDataProviderProps) => import("react/jsx-runtime").JSX.Element;
-export declare const useAnnotationData: () => AnnotationDataProvider;

package/dist/data/AnnotationDataContext.js

@@ -1,11 +0,0 @@
-import { jsx as _jsx } from "react/jsx-runtime";
-import { createContext, useContext } from 'react';
-const AnnotationDataContext = createContext(null);
-export const AnnotationDataProviderContext = ({ value, children, }) => (_jsx(AnnotationDataContext.Provider, { value: value, children: children }));
-export const useAnnotationData = () => {
-    const provider = useContext(AnnotationDataContext);
-    if (!provider) {
-        throw new Error('useAnnotationData must be used inside <AnnotationDataProviderContext>');
-    }
-    return provider;
-};

package/dist/data/AnnotationDataProvider.d.ts

@@ -1,65 +0,0 @@
-import type { FileUpload, FileUploadType, Measurement } from '../types/firestore.js';
-export interface JobScope {
-    orgId: string;
-    projectId: string;
-    jobId: string;
-}
-export interface JobGroupScope extends JobScope {
-    groupId: string;
-}
-export type Unsubscribe = () => void;
-export type FieldOp = {
-    kind: 'serverTimestamp';
-} | {
-    kind: 'arrayUnion';
-    values: unknown[];
-} | {
-    kind: 'arrayRemove';
-    values: unknown[];
-} | {
-    kind: 'increment';
-    by: number;
-} | {
-    kind: 'delete';
-};
-export declare const isFieldOp: (v: unknown) => v is FieldOp;
-export type Patch<T> = {
-    [K in keyof T]?: T[K] | FieldOp;
-};
-export interface ImageBlob {
-    data: Blob | ArrayBuffer | string;
-    contentType: string;
-    filename?: string;
-}
-export interface UploadedImageRef {
-    storagePath: string;
-    downloadUrl: string;
-    width?: number;
-    height?: number;
-    bytes?: number;
-}
-export type AnnotationFile = Extract<FileUpload, {
-    type: FileUploadType.Canvas;
-}>;
-export interface AnnotationFileSummary {
-    id: string;
-    name: string;
-    thumbnailUrl: string | null;
-    fileType: 'sketch' | 'document';
-    isLabel?: boolean;
-    createdAt?: Date;
-    createdBy?: AnnotationFile['createdBy'];
-}
-export interface AnnotationDataProvider {
-    create(scope: JobGroupScope, seed: Partial<AnnotationFile>): Promise<string>;
-    get(scope: JobGroupScope, fileId: string): Promise<AnnotationFile | null>;
-    update(scope: JobGroupScope, fileId: string, patch: Patch<AnnotationFile>): Promise<void>;
-    delete(scope: JobGroupScope, fileId: string): Promise<void>;
-    subscribe(scope: JobGroupScope, fileId: string, onNext: (doc: AnnotationFile | null) => void, onError?: (err: Error) => void): Unsubscribe;
-    list(scope: JobGroupScope, onNext: (files: AnnotationFileSummary[]) => void, onError?: (err: Error) => void): Unsubscribe;
-    subscribeGroupMeasurements(scope: JobGroupScope, onNext: (measurements: Measurement[]) => void, onError?: (err: Error) => void): Unsubscribe;
-    subscribeJobMeasurements(scope: JobScope, onNext: (measurements: Measurement[]) => void, onError?: (err: Error) => void): Unsubscribe;
-    uploadImage(scope: JobGroupScope, fileId: string, role: 'background' | 'thumbnail', blob: ImageBlob): Promise<UploadedImageRef>;
-    getImageUrl(scope: JobGroupScope, fileId: string, storagePath: string): Promise<string>;
-    deleteImage(scope: JobGroupScope, fileId: string, storagePath: string): Promise<void>;
-}

package/dist/data/AnnotationDataProvider.js

@@ -1,4 +0,0 @@
-export const isFieldOp = (v) => !!v &&
-    typeof v === 'object' &&
-    'kind' in v &&
-    typeof v.kind === 'string';

package/dist/data/InMemoryAnnotationProvider.d.ts

@@ -1,30 +0,0 @@
-import { type Measurement } from '../types/firestore.js';
-import { type AnnotationDataProvider, type AnnotationFile, type AnnotationFileSummary, type ImageBlob, type JobGroupScope, type JobScope, type Patch, type Unsubscribe, type UploadedImageRef } from './AnnotationDataProvider.js';
-export declare class InMemoryAnnotationProvider implements AnnotationDataProvider {
-    private docs;
-    private measurements;
-    private images;
-    private docListeners;
-    private listListeners;
-    private groupMeasurementListeners;
-    private jobMeasurementListeners;
-    private nextId;
-    setMeasurements(scope: JobGroupScope, measurements: Measurement[]): void;
-    create(scope: JobGroupScope, seed: Partial<AnnotationFile>): Promise<string>;
-    get(scope: JobGroupScope, fileId: string): Promise<AnnotationFile | null>;
-    update(scope: JobGroupScope, fileId: string, patch: Patch<AnnotationFile>): Promise<void>;
-    delete(scope: JobGroupScope, fileId: string): Promise<void>;
-    subscribe(scope: JobGroupScope, fileId: string, onNext: (doc: AnnotationFile | null) => void): Unsubscribe;
-    list(scope: JobGroupScope, onNext: (files: AnnotationFileSummary[]) => void): Unsubscribe;
-    subscribeGroupMeasurements(scope: JobGroupScope, onNext: (measurements: Measurement[]) => void): Unsubscribe;
-    subscribeJobMeasurements(scope: JobScope, onNext: (measurements: Measurement[]) => void): Unsubscribe;
-    uploadImage(scope: JobGroupScope, fileId: string, role: 'background' | 'thumbnail', blob: ImageBlob): Promise<UploadedImageRef>;
-    getImageUrl(_scope: JobGroupScope, fileId: string, storagePath: string): Promise<string>;
-    deleteImage(_scope: JobGroupScope, fileId: string, storagePath: string): Promise<void>;
-    private getBucket;
-    private notifyDoc;
-    private notifyList;
-    private notifyGroupMeasurements;
-    private notifyJobMeasurements;
-    private collectJobMeasurements;
-}

package/dist/data/InMemoryAnnotationProvider.js

@@ -1,197 +0,0 @@
-import { FileUploadType } from '../types/firestore.js';
-import { isFieldOp, } from './AnnotationDataProvider.js';
-const scopeKey = (s) => `${s.orgId}/${s.projectId}/${s.jobId}/${s.groupId}`;
-const jobKey = (s) => `${s.orgId}/${s.projectId}/${s.jobId}`;
-const summarize = (file) => ({
-    id: file.id,
-    name: file.name,
-    thumbnailUrl: file.thumbnailUrl,
-    fileType: file.fileData.fileType,
-    isLabel: file.fileData.isLabel,
-    createdAt: file.createdAt,
-    createdBy: file.createdBy,
-});
-const applyFieldOps = (patch) => {
-    const out = {};
-    for (const [key, value] of Object.entries(patch)) {
-        if (isFieldOp(value)) {
-            out[key] = resolveFieldOp(value);
-        }
-        else {
-            out[key] = value;
-        }
-    }
-    return out;
-};
-const resolveFieldOp = (op) => {
-    switch (op.kind) {
-        case 'serverTimestamp':
-            return new Date();
-        case 'arrayUnion':
-            return op.values;
-        case 'arrayRemove':
-            return [];
-        case 'increment':
-            return op.by;
-        case 'delete':
-            return undefined;
-    }
-};
-// Simple test/dev provider. Stores documents and image blobs in memory and
-// fans out subscription notifications synchronously. Not designed for
-// performance — designed for predictable behavior in tests and Storybook.
-export class InMemoryAnnotationProvider {
-    constructor() {
-        this.docs = new Map();
-        this.measurements = new Map();
-        this.images = new Map();
-        this.docListeners = new Map();
-        this.listListeners = new Map();
-        this.groupMeasurementListeners = new Map();
-        this.jobMeasurementListeners = new Map();
-        this.nextId = 1;
-    }
-    // Seed helpers for tests
-    setMeasurements(scope, measurements) {
-        this.measurements.set(scopeKey(scope), measurements);
-        this.notifyGroupMeasurements(scope);
-        this.notifyJobMeasurements({
-            orgId: scope.orgId,
-            projectId: scope.projectId,
-            jobId: scope.jobId,
-        });
-    }
-    async create(scope, seed) {
-        const id = seed.id ?? `mem-${this.nextId++}`;
-        const file = {
-            id,
-            name: seed.name ?? 'Untitled annotation',
-            thumbnailUrl: seed.thumbnailUrl ?? null,
-            createdAt: seed.createdAt ?? new Date(),
-            createdBy: seed.createdBy,
-            type: FileUploadType.Canvas,
-            fileData: seed.fileData ?? { fileType: 'sketch' },
-        };
-        this.getBucket(scope).set(id, file);
-        this.notifyDoc(scope, id);
-        this.notifyList(scope);
-        return id;
-    }
-    async get(scope, fileId) {
-        return this.getBucket(scope).get(fileId) ?? null;
-    }
-    async update(scope, fileId, patch) {
-        const bucket = this.getBucket(scope);
-        const prev = bucket.get(fileId);
-        if (!prev)
-            throw new Error(`Annotation file ${fileId} not found`);
-        const resolved = applyFieldOps(patch);
-        const next = { ...prev, ...resolved };
-        bucket.set(fileId, next);
-        this.notifyDoc(scope, fileId);
-        this.notifyList(scope);
-    }
-    async delete(scope, fileId) {
-        this.getBucket(scope).delete(fileId);
-        this.notifyDoc(scope, fileId);
-        this.notifyList(scope);
-    }
-    subscribe(scope, fileId, onNext) {
-        const key = `${scopeKey(scope)}/${fileId}`;
-        const set = this.docListeners.get(key) ?? new Set();
-        set.add(onNext);
-        this.docListeners.set(key, set);
-        queueMicrotask(() => onNext(this.getBucket(scope).get(fileId) ?? null));
-        return () => {
-            set.delete(onNext);
-        };
-    }
-    list(scope, onNext) {
-        const key = scopeKey(scope);
-        const set = this.listListeners.get(key) ?? new Set();
-        set.add(onNext);
-        this.listListeners.set(key, set);
-        queueMicrotask(() => onNext(Array.from(this.getBucket(scope).values()).map(summarize)));
-        return () => {
-            set.delete(onNext);
-        };
-    }
-    subscribeGroupMeasurements(scope, onNext) {
-        const key = scopeKey(scope);
-        const set = this.groupMeasurementListeners.get(key) ?? new Set();
-        set.add(onNext);
-        this.groupMeasurementListeners.set(key, set);
-        queueMicrotask(() => onNext(this.measurements.get(key) ?? []));
-        return () => {
-            set.delete(onNext);
-        };
-    }
-    subscribeJobMeasurements(scope, onNext) {
-        const key = jobKey(scope);
-        const set = this.jobMeasurementListeners.get(key) ?? new Set();
-        set.add(onNext);
-        this.jobMeasurementListeners.set(key, set);
-        queueMicrotask(() => onNext(this.collectJobMeasurements(scope)));
-        return () => {
-            set.delete(onNext);
-        };
-    }
-    async uploadImage(scope, fileId, role, blob) {
-        const storagePath = `${scopeKey(scope)}/${fileId}/${role}`;
-        const ref = {
-            storagePath,
-            downloadUrl: `mem://${storagePath}`,
-        };
-        const bucket = this.images.get(fileId) ?? new Map();
-        bucket.set(storagePath, { blob, ref });
-        this.images.set(fileId, bucket);
-        return ref;
-    }
-    async getImageUrl(_scope, fileId, storagePath) {
-        const ref = this.images.get(fileId)?.get(storagePath);
-        if (!ref)
-            throw new Error(`Image ${storagePath} not found`);
-        return ref.ref.downloadUrl;
-    }
-    async deleteImage(_scope, fileId, storagePath) {
-        this.images.get(fileId)?.delete(storagePath);
-    }
-    getBucket(scope) {
-        const key = scopeKey(scope);
-        let bucket = this.docs.get(key);
-        if (!bucket) {
-            bucket = new Map();
-            this.docs.set(key, bucket);
-        }
-        return bucket;
-    }
-    notifyDoc(scope, fileId) {
-        const key = `${scopeKey(scope)}/${fileId}`;
-        const doc = this.getBucket(scope).get(fileId) ?? null;
-        this.docListeners.get(key)?.forEach((cb) => cb(doc));
-    }
-    notifyList(scope) {
-        const key = scopeKey(scope);
-        const files = Array.from(this.getBucket(scope).values()).map(summarize);
-        this.listListeners.get(key)?.forEach((cb) => cb(files));
-    }
-    notifyGroupMeasurements(scope) {
-        const key = scopeKey(scope);
-        const ms = this.measurements.get(key) ?? [];
-        this.groupMeasurementListeners.get(key)?.forEach((cb) => cb(ms));
-    }
-    notifyJobMeasurements(scope) {
-        const key = jobKey(scope);
-        const ms = this.collectJobMeasurements(scope);
-        this.jobMeasurementListeners.get(key)?.forEach((cb) => cb(ms));
-    }
-    collectJobMeasurements(scope) {
-        const prefix = `${jobKey(scope)}/`;
-        const out = [];
-        for (const [key, ms] of this.measurements) {
-            if (key.startsWith(prefix))
-                out.push(...ms);
-        }
-        return out;
-    }
-}

package/dist/data/canvasPersistence.d.ts

@@ -1,3 +0,0 @@
-import { type AnnotationCanvasState, type AnnotationViewport } from '../types/annotation.js';
-import type { AnnotationFile } from './AnnotationDataProvider.js';
-export declare const hydrateCanvasState: (file: AnnotationFile | null, fallbackViewport?: Partial<AnnotationViewport>) => AnnotationCanvasState;

package/dist/data/canvasPersistence.js

@@ -1,26 +0,0 @@
-import { createEmptyCanvasState, } from '../types/annotation.js';
-// Bring a persisted canvas forward to the current schema. Keyed on
-// `schemaVersion` so each client migrates identically and the provider can
-// stay a dumb transport. Identity for v1 today; add a `case 1: return
-// upgradeV1toV2(raw)` arm when the schema bumps.
-const migrateCanvasState = (raw) => {
-    switch (raw.schemaVersion) {
-        case 1:
-            return raw;
-        default:
-            // Forward-compat: a doc written by a newer client. Trust it as-is
-            // rather than risk a lossy downgrade-write.
-            return raw;
-    }
-};
-// Turn a loaded annotation file into a working canvas state ready to feed the
-// canvas. Missing/legacy docs (no `fileData.canvas`) start from an empty
-// canvas sized by `fallbackViewport`. This is the single entry point for going
-// from `useAnnotationDoc` data to an `AnnotationCanvasState` — consumers should
-// not call `createEmptyCanvasState` directly.
-export const hydrateCanvasState = (file, fallbackViewport) => {
-    const persisted = file?.fileData.canvas;
-    if (!persisted)
-        return createEmptyCanvasState(fallbackViewport);
-    return migrateCanvasState(persisted);
-};

package/dist/data/hooks/useAnnotationCanvasDoc.d.ts

@@ -1,33 +0,0 @@
-import { type AnnotationCanvasState, type AnnotationDocumentPatch, type AnnotationViewport, type BackgroundFit } from '../../types/annotation.js';
-import type { ImageBlob, JobGroupScope } from '../AnnotationDataProvider.js';
-export type SaveStatus = 'idle' | 'dirty' | 'saving' | 'saved' | 'error';
-export interface UseAnnotationCanvasDocOptions {
-    scope: JobGroupScope | null;
-    fileId: string | null;
-    fallbackViewport?: Partial<AnnotationViewport>;
-    debounceMs?: number;
-    createSeed?: {
-        name?: string;
-        fileType?: 'sketch' | 'document';
-        isLabel?: boolean;
-    };
-    onFileCreated?: (fileId: string) => void;
-    onSaveError?: (error: unknown) => void;
-    captureThumbnail?: () => Promise<ImageBlob | null>;
-    debugLogging?: boolean;
-}
-export interface UseAnnotationCanvasDocResult {
-    canvas: AnnotationCanvasState;
-    onCommit: (patch: AnnotationDocumentPatch) => void;
-    loading: boolean;
-    error: Error | null;
-    saveStatus: SaveStatus;
-    save: () => Promise<void>;
-    ensureFileId: () => Promise<string>;
-    setBackgroundImage: (blob: ImageBlob, dims: {
-        width: number;
-        height: number;
-    }, fit?: BackgroundFit) => Promise<void>;
-    clearBackgroundImage: () => Promise<void>;
-}
-export declare const useAnnotationCanvasDoc: (options: UseAnnotationCanvasDocOptions) => UseAnnotationCanvasDocResult;