@reekon-tools/boldr-utils 1.6.4 → 1.6.5

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.Annotation;
+}>;
+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;
+}

package/dist/data/InMemoryAnnotationProvider.js

@@ -0,0 +1,197 @@
+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.Annotation,
+            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/hooks/useAnnotationDoc.d.ts

@@ -0,0 +1,7 @@
+import type { AnnotationFile, JobGroupScope } from '../AnnotationDataProvider.js';
+export interface UseAnnotationDocResult {
+    data: AnnotationFile | null;
+    loading: boolean;
+    error: Error | null;
+}
+export declare const useAnnotationDoc: (scope: JobGroupScope | null, fileId: string | null) => UseAnnotationDocResult;

package/dist/data/hooks/useAnnotationDoc.js

@@ -0,0 +1,33 @@
+import { useEffect, useState } from 'react';
+import { useAnnotationData } from '../AnnotationDataContext.js';
+export const useAnnotationDoc = (scope, fileId) => {
+    const provider = useAnnotationData();
+    const [data, setData] = useState(null);
+    const [loading, setLoading] = useState(true);
+    const [error, setError] = useState(null);
+    useEffect(() => {
+        if (!scope || !fileId) {
+            setData(null);
+            setLoading(false);
+            return;
+        }
+        setLoading(true);
+        setError(null);
+        const unsubscribe = provider.subscribe(scope, fileId, (doc) => {
+            setData(doc);
+            setLoading(false);
+        }, (err) => {
+            setError(err);
+            setLoading(false);
+        });
+        return unsubscribe;
+    }, [
+        provider,
+        scope?.orgId,
+        scope?.projectId,
+        scope?.jobId,
+        scope?.groupId,
+        fileId,
+    ]);
+    return { data, loading, error };
+};

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

@@ -0,0 +1,7 @@
+import type { AnnotationFileSummary, JobGroupScope } from '../AnnotationDataProvider.js';
+export interface UseAnnotationListResult {
+    files: AnnotationFileSummary[];
+    loading: boolean;
+    error: Error | null;
+}
+export declare const useAnnotationList: (scope: JobGroupScope | null) => UseAnnotationListResult;

package/dist/data/hooks/useAnnotationList.js

@@ -0,0 +1,26 @@
+import { useEffect, useState } from 'react';
+import { useAnnotationData } from '../AnnotationDataContext.js';
+export const useAnnotationList = (scope) => {
+    const provider = useAnnotationData();
+    const [files, setFiles] = useState([]);
+    const [loading, setLoading] = useState(true);
+    const [error, setError] = useState(null);
+    useEffect(() => {
+        if (!scope) {
+            setFiles([]);
+            setLoading(false);
+            return;
+        }
+        setLoading(true);
+        setError(null);
+        const unsubscribe = provider.list(scope, (next) => {
+            setFiles(next);
+            setLoading(false);
+        }, (err) => {
+            setError(err);
+            setLoading(false);
+        });
+        return unsubscribe;
+    }, [provider, scope?.orgId, scope?.projectId, scope?.jobId, scope?.groupId]);
+    return { files, loading, error };
+};

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

@@ -0,0 +1,9 @@
+import type { AnnotationFile, ImageBlob, JobGroupScope, Patch, UploadedImageRef } from '../AnnotationDataProvider.js';
+export interface AnnotationMutations {
+    create(seed: Partial<AnnotationFile>): Promise<string>;
+    update(fileId: string, patch: Patch<AnnotationFile>): Promise<void>;
+    remove(fileId: string): Promise<void>;
+    uploadImage(fileId: string, role: 'background' | 'thumbnail', blob: ImageBlob): Promise<UploadedImageRef>;
+    deleteImage(fileId: string, storagePath: string): Promise<void>;
+}
+export declare const useAnnotationMutations: (scope: JobGroupScope) => AnnotationMutations;

package/dist/data/hooks/useAnnotationMutations.js

@@ -0,0 +1,11 @@
+import { useCallback, useMemo } from 'react';
+import { useAnnotationData } from '../AnnotationDataContext.js';
+export const useAnnotationMutations = (scope) => {
+    const provider = useAnnotationData();
+    const create = useCallback((seed) => provider.create(scope, seed), [provider, scope.orgId, scope.projectId, scope.jobId, scope.groupId]);
+    const update = useCallback((fileId, patch) => provider.update(scope, fileId, patch), [provider, scope.orgId, scope.projectId, scope.jobId, scope.groupId]);
+    const remove = useCallback((fileId) => provider.delete(scope, fileId), [provider, scope.orgId, scope.projectId, scope.jobId, scope.groupId]);
+    const uploadImage = useCallback((fileId, role, blob) => provider.uploadImage(scope, fileId, role, blob), [provider, scope.orgId, scope.projectId, scope.jobId, scope.groupId]);
+    const deleteImage = useCallback((fileId, storagePath) => provider.deleteImage(scope, fileId, storagePath), [provider, scope.orgId, scope.projectId, scope.jobId, scope.groupId]);
+    return useMemo(() => ({ create, update, remove, uploadImage, deleteImage }), [create, update, remove, uploadImage, deleteImage]);
+};

package/dist/exports.d.ts

@@ -0,0 +1,25 @@
+export { evaluateFormula, createFormulaScope, createEnhancedFormulaScope, clearFormulaCache, type EnhancedMapping, type FormulaDefinition, type FormulaEvaluationOptions, } from './formulas/evaluateFormula.js';
+export { calculateFormula } from './formulas/calculateFormula.js';
+export { convertMicrometers } from './utils/micrometersToUnit.js';
+export { parseMeasurement } from './utils/parseMeasurement.js';
+export { useParseMeasurement } from './hooks/useParseMeasurement.js';
+export * from './types/firestore.js';
+export * from './types/layout.js';
+export * from './types/annotation.js';
+export { getToleranceColor, calculateDeviationPercentage, isWithinTolerance, generateToleranceGradient, createDefaultToleranceThresholds, DEFAULT_TOLERANCE_COLORS, type ToleranceThreshold, type ToleranceConfig, } from './utils/tolerance.js';
+export { DEFAULT_GROUP_INDEX, isDefaultGroup, findDefaultGroup, } from './utils/groups.js';
+export { isFieldOp, type AnnotationDataProvider, type AnnotationFile, type AnnotationFileSummary, type FieldOp, type ImageBlob, type JobGroupScope, type JobScope, type Patch, type Unsubscribe, type UploadedImageRef, } from './data/AnnotationDataProvider.js';
+export { AnnotationDataProviderContext, useAnnotationData, type AnnotationDataProviderProps, } from './data/AnnotationDataContext.js';
+export { useAnnotationDoc, type UseAnnotationDocResult, } from './data/hooks/useAnnotationDoc.js';
+export { useAnnotationList, type UseAnnotationListResult, } from './data/hooks/useAnnotationList.js';
+export { useAnnotationMutations, type AnnotationMutations, } from './data/hooks/useAnnotationMutations.js';
+export { InMemoryAnnotationProvider } from './data/InMemoryAnnotationProvider.js';
+export type { AnnotationCanvasHandle, } from './canvas/useAnnotationCanvasState.js';
+export type { GestureConfig, PanTrigger, AnnotationCanvasInnerProps, } from './canvas/AnnotationCanvasInner.js';
+export type { CanvasPointerEvent, Tool, ToolContext, ToolState, } from './canvas/Tool.js';
+export type { MeasurementRef, PickMeasurement, } from './canvas/measurementPicker.js';
+export { createViewportApi, fitToScreen, panBy, zoomAt, DEFAULT_VIEWPORT, type ViewportApi, type ViewportState, } from './canvas/viewport.js';
+export { createPenTool, type PenToolOptions, } from './canvas/tools/penTool.js';
+export { createSelectTool } from './canvas/tools/selectTool.js';
+export { createMeasurementStampTool, type MeasurementStampToolOptions, } from './canvas/tools/measurementStampTool.js';
+export { createPanTool, type PanToolOptions, } from './canvas/tools/panTool.js';

package/dist/exports.js

@@ -0,0 +1,26 @@
+// Shared exports for both platform entry points. Everything that is NOT the
+// platform-specific `AnnotationCanvas` wrapper lives here. The two index
+// files (index.ts, index.native.ts) re-export from this and add their own
+// AnnotationCanvas import.
+export { evaluateFormula, createFormulaScope, createEnhancedFormulaScope, clearFormulaCache, } from './formulas/evaluateFormula.js';
+export { calculateFormula } from './formulas/calculateFormula.js';
+export { convertMicrometers } from './utils/micrometersToUnit.js';
+export { parseMeasurement } from './utils/parseMeasurement.js';
+export { useParseMeasurement } from './hooks/useParseMeasurement.js';
+export * from './types/firestore.js';
+export * from './types/layout.js';
+export * from './types/annotation.js';
+export { getToleranceColor, calculateDeviationPercentage, isWithinTolerance, generateToleranceGradient, createDefaultToleranceThresholds, DEFAULT_TOLERANCE_COLORS, } from './utils/tolerance.js';
+export { DEFAULT_GROUP_INDEX, isDefaultGroup, findDefaultGroup, } from './utils/groups.js';
+// Annotation data layer (SDK-neutral; apps provide their own provider).
+export { isFieldOp, } from './data/AnnotationDataProvider.js';
+export { AnnotationDataProviderContext, useAnnotationData, } from './data/AnnotationDataContext.js';
+export { useAnnotationDoc, } from './data/hooks/useAnnotationDoc.js';
+export { useAnnotationList, } from './data/hooks/useAnnotationList.js';
+export { useAnnotationMutations, } from './data/hooks/useAnnotationMutations.js';
+export { InMemoryAnnotationProvider } from './data/InMemoryAnnotationProvider.js';
+export { createViewportApi, fitToScreen, panBy, zoomAt, DEFAULT_VIEWPORT, } from './canvas/viewport.js';
+export { createPenTool, } from './canvas/tools/penTool.js';
+export { createSelectTool } from './canvas/tools/selectTool.js';
+export { createMeasurementStampTool, } from './canvas/tools/measurementStampTool.js';
+export { createPanTool, } from './canvas/tools/panTool.js';

package/dist/index.d.ts

@@ -1,8 +1,2 @@
-export { evaluateFormula, createFormulaScope, createEnhancedFormulaScope, clearFormulaCache, type EnhancedMapping, type FormulaDefinition, type FormulaEvaluationOptions, } from './formulas/evaluateFormula.js';
-export { calculateFormula } from './formulas/calculateFormula.js';
-export { convertMicrometers } from './utils/micrometersToUnit.js';
-export { parseMeasurement } from './utils/parseMeasurement.js';
-export { useParseMeasurement } from './hooks/useParseMeasurement.js';
-export * from './types/firestore.js';
-export * from './types/layout.js';
-export { getToleranceColor, getToleranceSecondaryColor, calculateDeviationPercentage, isWithinTolerance, generateToleranceGradient, createDefaultToleranceThresholds, DEFAULT_TOLERANCE_COLORS, DEFAULT_TOLERANCE_SECONDARY_COLORS, type ToleranceThreshold, type ToleranceConfig, } from './utils/tolerance.js';
+export * from './exports.js';
+export { AnnotationCanvas, type AnnotationCanvasProps, type CanvasKitOpts, } from './canvas/AnnotationCanvas.js';

package/dist/index.js

@@ -1,8 +1,6 @@
-export { evaluateFormula, createFormulaScope, createEnhancedFormulaScope, clearFormulaCache, } from './formulas/evaluateFormula.js';
-export { calculateFormula } from './formulas/calculateFormula.js';
-export { convertMicrometers } from './utils/micrometersToUnit.js';
-export { parseMeasurement } from './utils/parseMeasurement.js';
-export { useParseMeasurement } from './hooks/useParseMeasurement.js';
-export * from './types/firestore.js';
-export * from './types/layout.js';
-export { getToleranceColor, getToleranceSecondaryColor, calculateDeviationPercentage, isWithinTolerance, generateToleranceGradient, createDefaultToleranceThresholds, DEFAULT_TOLERANCE_COLORS, DEFAULT_TOLERANCE_SECONDARY_COLORS, } from './utils/tolerance.js';
+// Web entry. Re-exports everything from the shared `exports.ts` plus the
+// web-targeted `AnnotationCanvas` that lazy-loads CanvasKit via
+// WithSkiaWeb. Metro/RN consumers resolve `index.native.ts` instead via
+// the `react-native` condition in package.json `exports`.
+export * from './exports.js';
+export { AnnotationCanvas, } from './canvas/AnnotationCanvas.js';

package/dist/index.native.d.ts

@@ -0,0 +1,5 @@
+export * from './exports.js';
+export { AnnotationCanvas, type AnnotationCanvasProps, } from './canvas/AnnotationCanvas.native.js';
+export interface CanvasKitOpts {
+    locateFile?: (file: string) => string;
+}

package/dist/index.native.js

@@ -0,0 +1,6 @@
+// React Native entry. Resolved by Metro via the `react-native` condition in
+// package.json `exports`. Pulls the native `AnnotationCanvas` (no
+// WithSkiaWeb / canvaskit-wasm), avoiding the `fs` import that Metro
+// chokes on.
+export * from './exports.js';
+export { AnnotationCanvas, } from './canvas/AnnotationCanvas.native.js';