@reekon-tools/boldr-utils 1.6.15 → 1.6.18

package/dist/canvas/tools/selectTool.js

@@ -0,0 +1,182 @@
+import { STAMP_TILE_SIZE } from '../stampLayout.js';
+const HIT_PADDING = 6;
+// Hit-test in doc-space. Crude but fast — good enough for v1; tools can
+// override via `hitTest` for more precision later.
+const hitStroke = (stroke, p) => {
+    const r = stroke.width / 2 + HIT_PADDING;
+    const r2 = r * r;
+    for (let i = 0; i < stroke.points.length - 2; i += 2) {
+        if (segmentDistanceSq(p.x, p.y, stroke.points[i], stroke.points[i + 1], stroke.points[i + 2], stroke.points[i + 3]) <= r2) {
+            return true;
+        }
+    }
+    return false;
+};
+const hitMeasurement = (m, p, zoom = 1) => {
+    // The stamp renders as a constant *screen*-size square centered on the
+    // anchor, so its doc-space footprint shrinks as you zoom in. Convert the
+    // screen-space half-extent (+ padding) back to doc space via the zoom so
+    // the hit box always matches what's drawn.
+    const scale = m.scale ?? 1;
+    const half = ((STAMP_TILE_SIZE * scale) / 2 + HIT_PADDING) / zoom;
+    const dx = Math.abs(p.x - m.anchor.x);
+    const dy = Math.abs(p.y - m.anchor.y);
+    return dx <= half && dy <= half;
+};
+const segmentDistanceSq = (px, py, ax, ay, bx, by) => {
+    const abx = bx - ax;
+    const aby = by - ay;
+    const lenSq = abx * abx + aby * aby;
+    let t = lenSq === 0 ? 0 : ((px - ax) * abx + (py - ay) * aby) / lenSq;
+    t = Math.max(0, Math.min(1, t));
+    const cx = ax + t * abx;
+    const cy = ay + t * aby;
+    const dx = px - cx;
+    const dy = py - cy;
+    return dx * dx + dy * dy;
+};
+const findHit = (doc, world, zoom) => {
+    // Hit-test in z-order (top first): measurements > shapes > strokes.
+    for (let i = doc.placedMeasurements.length - 1; i >= 0; i--) {
+        const m = doc.placedMeasurements[i];
+        if (hitMeasurement(m, world, zoom))
+            return { id: m.id, kind: 'measurement' };
+    }
+    for (let i = doc.shapes.length - 1; i >= 0; i--) {
+        // Default shape hit test: bounding box of the shape's points + padding.
+        const s = doc.shapes[i];
+        const pts = s.geometry.points;
+        if (pts.length === 0)
+            continue;
+        let minX = pts[0].x;
+        let maxX = pts[0].x;
+        let minY = pts[0].y;
+        let maxY = pts[0].y;
+        for (let j = 1; j < pts.length; j++) {
+            const p = pts[j];
+            if (p.x < minX)
+                minX = p.x;
+            if (p.x > maxX)
+                maxX = p.x;
+            if (p.y < minY)
+                minY = p.y;
+            if (p.y > maxY)
+                maxY = p.y;
+        }
+        if (world.x >= minX - HIT_PADDING &&
+            world.x <= maxX + HIT_PADDING &&
+            world.y >= minY - HIT_PADDING &&
+            world.y <= maxY + HIT_PADDING) {
+            return { id: s.id, kind: 'shape' };
+        }
+    }
+    for (let i = doc.strokes.length - 1; i >= 0; i--) {
+        const s = doc.strokes[i];
+        if (hitStroke(s, world))
+            return { id: s.id, kind: 'stroke' };
+    }
+    return null;
+};
+const translatePatch = (elementKind, id, doc, delta) => {
+    if (elementKind === 'measurement') {
+        const m = doc.placedMeasurements.find((x) => x.id === id);
+        if (!m)
+            return null;
+        return {
+            op: 'updateMeasurement',
+            id,
+            patch: {
+                anchor: { x: m.anchor.x + delta.x, y: m.anchor.y + delta.y },
+                leader: m.leader
+                    ? {
+                        from: {
+                            x: m.leader.from.x + delta.x,
+                            y: m.leader.from.y + delta.y,
+                        },
+                        to: {
+                            x: m.leader.to.x + delta.x,
+                            y: m.leader.to.y + delta.y,
+                        },
+                    }
+                    : undefined,
+            },
+        };
+    }
+    if (elementKind === 'shape') {
+        const s = doc.shapes.find((x) => x.id === id);
+        if (!s)
+            return null;
+        return {
+            op: 'updateShape',
+            id,
+            patch: {
+                geometry: {
+                    ...s.geometry,
+                    points: s.geometry.points.map((p) => ({
+                        x: p.x + delta.x,
+                        y: p.y + delta.y,
+                    })),
+                },
+            },
+        };
+    }
+    const stroke = doc.strokes.find((x) => x.id === id);
+    if (!stroke)
+        return null;
+    const points = stroke.points.slice();
+    for (let i = 0; i < points.length; i += 2) {
+        points[i] = points[i] + delta.x;
+        points[i + 1] = points[i + 1] + delta.y;
+    }
+    return { op: 'updateStroke', id, patch: { points } };
+};
+export const createSelectTool = () => ({
+    id: 'select',
+    label: 'Select',
+    cursor: 'default',
+    onPointerDown(event, ctx) {
+        const hit = findHit(ctx.document, event.world, ctx.viewport.state.zoom);
+        if (!hit) {
+            ctx.setSelection(null);
+            return { kind: 'idle' };
+        }
+        ctx.setSelection({ ids: [hit.id] });
+        return {
+            kind: 'dragging',
+            id: hit.id,
+            elementKind: hit.kind,
+            start: event.world,
+            delta: { x: 0, y: 0 },
+        };
+    },
+    onPointerMove(event, ctx, state) {
+        const s = state;
+        if (s?.kind !== 'dragging')
+            return s;
+        const delta = { x: event.world.x - s.start.x, y: event.world.y - s.start.y };
+        const op = translatePatch(s.elementKind, s.id, ctx.document, delta);
+        if (op)
+            ctx.preview({ ops: [op] });
+        return { ...s, delta };
+    },
+    onPointerUp(_event, ctx, state) {
+        const s = state;
+        if (s?.kind !== 'dragging')
+            return;
+        if (s.delta.x === 0 && s.delta.y === 0)
+            return;
+        const op = translatePatch(s.elementKind, s.id, ctx.document, s.delta);
+        if (op)
+            ctx.commit({ ops: [op] });
+    },
+    onCancel(_state, ctx) {
+        ctx.preview({ ops: [] });
+    },
+    hitTest(element, p) {
+        if (element.kind === 'measurement')
+            return hitMeasurement(element, p);
+        if (element.kind === 'stroke')
+            return hitStroke(element, p);
+        return false;
+    },
+});

package/dist/canvas/useAnnotationCanvasState.d.ts

@@ -0,0 +1,54 @@
+import type { Measurement } from '../types/firestore.js';
+import { type AnnotationCanvasState, type AnnotationDocumentPatch, type AnnotationStroke, type Selection, type Vec2 } from '../types/annotation.js';
+import type { MeasurementRef } from './measurementPicker.js';
+import type { CanvasPointerEvent, Tool, ToolContext, ToolState } from './Tool.js';
+import { type ViewportState } from './viewport.js';
+export interface AnnotationCanvasHandle {
+    undo(): void;
+    redo(): void;
+    canUndo(): boolean;
+    canRedo(): boolean;
+    zoomToFit(): void;
+    resetView(): void;
+    placeMeasurementAtCenter(ref: MeasurementRef): void;
+}
+export interface UseAnnotationCanvasStateProps {
+    canvas: AnnotationCanvasState;
+    onCommit(patch: AnnotationDocumentPatch): void;
+    tools: Tool[];
+    activeToolId: string;
+    selection: Selection | null;
+    onSelectionChange(selection: Selection | null): void;
+    measurements?: Measurement[];
+    pickMeasurement?: () => Promise<MeasurementRef | null>;
+    width: number;
+    height: number;
+    initialViewport?: ViewportState;
+    imperativeRef?: {
+        current: AnnotationCanvasHandle | null;
+    };
+}
+export interface AnnotationCanvasStateApi {
+    effectiveCanvas: AnnotationCanvasState;
+    worldTransform: Array<{
+        scale: number;
+    } | {
+        translateX: number;
+    } | {
+        translateY: number;
+    }>;
+    viewport: ViewportState;
+    measurementsById: Map<string, Measurement>;
+    activeTool: Tool | null;
+    toolState: ToolState;
+    ctx: ToolContext;
+    penDrawingStroke: AnnotationStroke | null;
+    customPreviewState: ToolState;
+    dispatchPointerDown(event: CanvasPointerEvent): void;
+    dispatchPointerMove(event: CanvasPointerEvent): void;
+    dispatchPointerUp(event: CanvasPointerEvent): void;
+    dispatchPointerCancel(): void;
+    pan(deltaScreen: Vec2): void;
+    zoom(focalScreen: Vec2, nextZoom: number): void;
+}
+export declare const useAnnotationCanvasState: (props: UseAnnotationCanvasStateProps) => AnnotationCanvasStateApi;

package/dist/canvas/useAnnotationCanvasState.js

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

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

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

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

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

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

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

package/dist/data/InMemoryAnnotationProvider.d.ts

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