@reekon-tools/boldr-utils 1.7.5 → 1.8.0

package/dist/annotation/canvas/elements/BackgroundImageElement.js

@@ -42,6 +42,11 @@ const useBackgroundUrl = (image, resolveUrl) => {
 // on a null/undefined source (despite its DataSourceParam type), so it can't
 // be called unconditionally from a component that usually renders raster
 // backgrounds. An empty url resolves to null (nothing to draw yet).
+// Loaded through Skia's own scheme-agnostic data loader rather than fetch():
+// RN's Android networking rejects non-http(s) schemes, and offline-first
+// consumers resolve the background to a local file:// URI (fromURI handles
+// file://, http(s) and data: on native and web alike). fetch() remains as a
+// fallback for any environment where fromURI can't service the URL.
 const useBackgroundSvg = (url) => {
     const [svg, setSvg] = useState(null);
     useEffect(() => {
@@ -52,9 +57,16 @@ const useBackgroundSvg = (url) => {
         let cancelled = false;
         (async () => {
             try {
-                const res = await fetch(url);
-                const text = await res.text();
-                const next = Skia.SVG.MakeFromString(text);
+                let next = null;
+                try {
+                    const data = await Skia.Data.fromURI(url);
+                    next = Skia.SVG.MakeFromData(data);
+                    data.dispose();
+                }
+                catch {
+                    const res = await fetch(url);
+                    next = Skia.SVG.MakeFromString(await res.text());
+                }
                 if (!cancelled)
                     setSvg(next);
             }

package/dist/annotation/canvas/tools/measurementLineTool.d.ts

@@ -0,0 +1,12 @@
+import type { PlacedMeasurementRef } from '../../../types/annotation.js';
+import type { Tool } from '../Tool.js';
+export interface MeasurementLineToolOptions {
+    id?: string;
+    label?: string;
+    minDragPx?: number;
+    autoSwitchToSelect?: boolean;
+    selectToolId?: string;
+    onAutoSwitch?: (toToolId: string) => void;
+    onPlaced?: (measurement: PlacedMeasurementRef) => void;
+}
+export declare const createMeasurementLineTool: (options?: MeasurementLineToolOptions) => Tool;

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

@@ -0,0 +1,95 @@
+import { DEFAULT_LAYER_ID } from '../../../types/annotation.js';
+import { DEFAULT_LINE_POS, recomputeAnchor } from '../measurementGeometry.js';
+let counter = 0;
+const makeId = () => `annotation-${Date.now().toString(36)}-${(counter++).toString(36)}`;
+const firstLayerId = (doc) => doc.layers[0]?.id ?? DEFAULT_LAYER_ID;
+// Build the blank line-measurement annotation for a drag from `a` to `b`: a
+// 2-point line with a value tile magnetized to its center (linePos 0.5). The
+// payload mirrors useAnnotationCanvasState's placeAnnotationAtCenter so a drawn
+// line and a (legacy) center-placed one are byte-identical once committed.
+const buildLineMeasurement = (opts) => {
+    const line = { a: opts.a, b: opts.b };
+    return {
+        id: opts.id,
+        layerId: opts.layerId,
+        placement: 'line',
+        line,
+        linePos: DEFAULT_LINE_POS,
+        // Center of the line; recomputeAnchor keeps this in sync on edits.
+        anchor: recomputeAnchor(line, 'line', DEFAULT_LINE_POS, {
+            x: (opts.a.x + opts.b.x) / 2,
+            y: (opts.a.y + opts.b.y) / 2,
+        }),
+        showLabel: true,
+        showValue: true,
+        createdAt: Date.now(),
+    };
+};
+// Drag-to-draw measurement-line tool. Press-drag rubber-bands a measurement
+// annotation (a line with a blank value tile at its center); release commits
+// it. Mirrors createShapeTool's interaction so "input lines" are placed the
+// same way as shapes — draw to add, not tap-the-icon-to-add — replacing the
+// old center-place affordance. The annotation stays blank (no measurement
+// associated) until the user fills it via the tile / picker. Skia-free, like
+// every tool factory; it renders its live preview through ctx.preview, so it
+// works on web and (via the generic tool-pan dispatch) on native.
+export const createMeasurementLineTool = (options = {}) => {
+    const minDragPx = options.minDragPx ?? 4;
+    const autoSwitchToSelect = options.autoSwitchToSelect ?? true;
+    const selectToolId = options.selectToolId ?? 'select';
+    return {
+        id: options.id ?? 'measure-line',
+        label: options.label ?? 'Measurement line',
+        cursor: 'crosshair',
+        onPointerDown(event) {
+            return {
+                kind: 'measurement-line-drawing',
+                id: makeId(),
+                startWorld: event.world,
+                startScreen: event.screen,
+                moved: false,
+            };
+        },
+        onPointerMove(event, ctx, state) {
+            const s = state;
+            if (s?.kind !== 'measurement-line-drawing')
+                return s;
+            const measurement = buildLineMeasurement({
+                id: s.id,
+                layerId: firstLayerId(ctx.document),
+                a: s.startWorld,
+                b: event.world,
+            });
+            ctx.preview({ ops: [{ op: 'addMeasurement', measurement }] });
+            return { ...s, moved: true };
+        },
+        onPointerUp(event, ctx, state) {
+            const s = state;
+            if (s?.kind !== 'measurement-line-drawing')
+                return;
+            const dx = event.screen.x - s.startScreen.x;
+            const dy = event.screen.y - s.startScreen.y;
+            if (!s.moved || dx * dx + dy * dy < minDragPx * minDragPx) {
+                // Accidental tap — discard the rubber-band, commit nothing.
+                ctx.preview({ ops: [] });
+                return;
+            }
+            const measurement = buildLineMeasurement({
+                id: s.id,
+                layerId: firstLayerId(ctx.document),
+                a: s.startWorld,
+                b: event.world,
+            });
+            ctx.commit({ ops: [{ op: 'addMeasurement', measurement }] });
+            // Leave it selected (and hand back to select) so the blank line can be
+            // filled / moved straight away — the same flow as the text tool.
+            ctx.setSelection({ ids: [measurement.id] });
+            options.onPlaced?.(measurement);
+            if (autoSwitchToSelect)
+                options.onAutoSwitch?.(selectToolId);
+        },
+        onCancel(_state, ctx) {
+            ctx.preview({ ops: [] });
+        },
+    };
+};

package/dist/calculator/categories.d.ts

@@ -0,0 +1,76 @@
+import type { CalculatorDefinition } from './schema.js';
+/**
+ * Category ids, as PERSISTED on `calculators/{id}.category`.
+ *
+ * Never rename a value — it is stored data. To retire a category, delete its
+ * entry from CALCULATOR_CATEGORIES and leave existing docs alone: they resolve
+ * to `undefined` and degrade into the "Other" bucket rather than breaking.
+ */
+export declare enum CalculatorCategoryId {
+    AreaAndVolume = "areaAndVolume",
+    Concrete = "concrete",
+    Electrical = "electrical",
+    Stairs = "stairs",
+    Framing = "framing",
+    FinishCarpentry = "finishCarpentry",
+    Hardscaping = "hardscaping",
+    Roofing = "roofing",
+    HVAC = "hvac",
+    Landscaping = "landscaping",
+    MaterialEstimator = "materialEstimator",
+    Optimizers = "optimizers",
+    Plumbing = "plumbing"
+}
+export interface CalculatorCategory {
+    id: CalculatorCategoryId;
+    /** Display label: the editor dropdown row AND the mobile category screen title. */
+    name: string;
+    /**
+     * Tile-glyph tint from the design. Uppercase 6-digit hex.
+     *
+     * This is the source of truth for the color: the icon generator bakes it
+     * into the per-app SVGs (see scripts/gen-category-icons.mjs), so a color
+     * change here needs a regenerate to reach the apps.
+     */
+    color: string;
+    /**
+     * Glyph name in the legacy ROCK app's IcoMoon set, which is where this
+     * artwork comes from. Consumed only by the icon generator — clients load the
+     * emitted SVG by category id.
+     */
+    glyph: string;
+}
+/**
+ * Canonical order, matching the design's tile grid.
+ *
+ * This array IS the ordering — there is deliberately no `sortIndex` field for
+ * it to drift out of sync with.
+ */
+export declare const CALCULATOR_CATEGORIES: readonly CalculatorCategory[];
+export declare const CALCULATOR_CATEGORY_BY_ID: Readonly<Record<CalculatorCategoryId, CalculatorCategory>>;
+/**
+ * Bucket key / route segment for calculators with no category, or with one
+ * that no longer exists. NOT a CalculatorCategoryId — guarded by a unit test,
+ * because a collision would silently swallow a real category.
+ */
+export declare const UNCATEGORIZED_CATEGORY_ID = "uncategorized";
+export declare const UNCATEGORIZED_CATEGORY_NAME = "Other";
+export type CalculatorCategoryBucketId = CalculatorCategoryId | typeof UNCATEGORIZED_CATEGORY_ID;
+export declare const isCalculatorCategoryId: (value: unknown) => value is CalculatorCategoryId;
+/**
+ * Resolve a stored category value. Returns undefined for missing, null, and
+ * retired ids — callers should treat all three as "Other" rather than trusting
+ * the raw field.
+ */
+export declare const findCalculatorCategory: (value: string | null | undefined) => CalculatorCategory | undefined;
+export declare const calculatorCategoryOf: (calculator: Pick<CalculatorDefinition, "category">) => CalculatorCategory | undefined;
+/** Display label for a stored value, falling back to "Other". */
+export declare const calculatorCategoryName: (value: string | null | undefined) => string;
+/**
+ * Group calculators by category id, collecting anything missing or
+ * unresolvable under UNCATEGORIZED_CATEGORY_ID.
+ *
+ * Keys exist only for non-empty buckets, which is what lets the mobile grid
+ * hide empty categories without a second pass.
+ */
+export declare const groupCalculatorsByCategory: <T extends Pick<CalculatorDefinition, "category">>(calculators: readonly T[]) => Map<CalculatorCategoryBucketId, T[]>;

package/dist/calculator/categories.js

@@ -0,0 +1,160 @@
+// ---------------------------------------------------------------------------
+// Calculator categories — the hard-coded taxonomy used to group published
+// calculators in the mobile catalog and to label them in the web authoring
+// tool.
+//
+// Deliberately NOT a Firestore collection: the set is authored here and ships
+// inside the package, so both clients render the same list with no extra read,
+// no rules surface, and no offline story to maintain.
+//
+// Distinct from `CalculatorDefinition.folderId`, which predates this and is
+// still unused — `folderId` implies a hierarchy, a category is flat.
+// ---------------------------------------------------------------------------
+/**
+ * Category ids, as PERSISTED on `calculators/{id}.category`.
+ *
+ * Never rename a value — it is stored data. To retire a category, delete its
+ * entry from CALCULATOR_CATEGORIES and leave existing docs alone: they resolve
+ * to `undefined` and degrade into the "Other" bucket rather than breaking.
+ */
+export var CalculatorCategoryId;
+(function (CalculatorCategoryId) {
+    CalculatorCategoryId["AreaAndVolume"] = "areaAndVolume";
+    CalculatorCategoryId["Concrete"] = "concrete";
+    CalculatorCategoryId["Electrical"] = "electrical";
+    CalculatorCategoryId["Stairs"] = "stairs";
+    CalculatorCategoryId["Framing"] = "framing";
+    CalculatorCategoryId["FinishCarpentry"] = "finishCarpentry";
+    CalculatorCategoryId["Hardscaping"] = "hardscaping";
+    CalculatorCategoryId["Roofing"] = "roofing";
+    CalculatorCategoryId["HVAC"] = "hvac";
+    CalculatorCategoryId["Landscaping"] = "landscaping";
+    CalculatorCategoryId["MaterialEstimator"] = "materialEstimator";
+    CalculatorCategoryId["Optimizers"] = "optimizers";
+    CalculatorCategoryId["Plumbing"] = "plumbing";
+})(CalculatorCategoryId || (CalculatorCategoryId = {}));
+/**
+ * Canonical order, matching the design's tile grid.
+ *
+ * This array IS the ordering — there is deliberately no `sortIndex` field for
+ * it to drift out of sync with.
+ */
+export const CALCULATOR_CATEGORIES = [
+    {
+        id: CalculatorCategoryId.AreaAndVolume,
+        name: 'Area and Volume',
+        color: '#FF3A6E',
+        glyph: 'shape_calculator',
+    },
+    {
+        id: CalculatorCategoryId.Concrete,
+        name: 'Concrete',
+        color: '#E2AB6B',
+        glyph: 'concrete',
+    },
+    {
+        id: CalculatorCategoryId.Electrical,
+        name: 'Electrical',
+        color: '#60D8FE',
+        glyph: 'electrical',
+    },
+    {
+        id: CalculatorCategoryId.Stairs,
+        name: 'Stairs',
+        color: '#D09C9C',
+        glyph: 'stair_tread',
+    },
+    {
+        id: CalculatorCategoryId.Framing,
+        name: 'Framing',
+        color: '#FABC61',
+        glyph: 'frame',
+    },
+    {
+        id: CalculatorCategoryId.FinishCarpentry,
+        name: 'Finish Carpentry',
+        color: '#2E9E82',
+        glyph: 'finish_carpentry',
+    },
+    {
+        id: CalculatorCategoryId.Hardscaping,
+        name: 'Hardscaping',
+        color: '#6B77E2',
+        glyph: 'hardscaping',
+    },
+    {
+        id: CalculatorCategoryId.Roofing,
+        name: 'Roofing',
+        color: '#E48787',
+        glyph: 'roofing',
+    },
+    {
+        id: CalculatorCategoryId.HVAC,
+        name: 'HVAC',
+        color: '#FEF260',
+        glyph: 'hvac',
+    },
+    {
+        id: CalculatorCategoryId.Landscaping,
+        name: 'Landscaping',
+        color: '#C892FF',
+        glyph: 'landscaping',
+    },
+    {
+        id: CalculatorCategoryId.MaterialEstimator,
+        name: 'Material Estimator',
+        color: '#FFAD00',
+        glyph: 'raw_materials',
+    },
+    {
+        id: CalculatorCategoryId.Optimizers,
+        name: 'Optimizers',
+        color: '#CA5726',
+        glyph: 'wall',
+    },
+    {
+        id: CalculatorCategoryId.Plumbing,
+        name: 'Plumbing',
+        color: '#008EFD',
+        glyph: 'plumbing',
+    },
+];
+export const CALCULATOR_CATEGORY_BY_ID = Object.fromEntries(CALCULATOR_CATEGORIES.map((category) => [category.id, category]));
+/**
+ * Bucket key / route segment for calculators with no category, or with one
+ * that no longer exists. NOT a CalculatorCategoryId — guarded by a unit test,
+ * because a collision would silently swallow a real category.
+ */
+export const UNCATEGORIZED_CATEGORY_ID = 'uncategorized';
+export const UNCATEGORIZED_CATEGORY_NAME = 'Other';
+export const isCalculatorCategoryId = (value) => typeof value === 'string' && value in CALCULATOR_CATEGORY_BY_ID;
+/**
+ * Resolve a stored category value. Returns undefined for missing, null, and
+ * retired ids — callers should treat all three as "Other" rather than trusting
+ * the raw field.
+ */
+export const findCalculatorCategory = (value) => isCalculatorCategoryId(value) ? CALCULATOR_CATEGORY_BY_ID[value] : undefined;
+export const calculatorCategoryOf = (calculator) => findCalculatorCategory(calculator.category);
+/** Display label for a stored value, falling back to "Other". */
+export const calculatorCategoryName = (value) => findCalculatorCategory(value)?.name ?? UNCATEGORIZED_CATEGORY_NAME;
+/**
+ * Group calculators by category id, collecting anything missing or
+ * unresolvable under UNCATEGORIZED_CATEGORY_ID.
+ *
+ * Keys exist only for non-empty buckets, which is what lets the mobile grid
+ * hide empty categories without a second pass.
+ */
+export const groupCalculatorsByCategory = (calculators) => {
+    const buckets = new Map();
+    for (const calculator of calculators) {
+        const key = isCalculatorCategoryId(calculator.category)
+            ? calculator.category
+            : UNCATEGORIZED_CATEGORY_ID;
+        const bucket = buckets.get(key);
+        if (bucket)
+            bucket.push(calculator);
+        else
+            buckets.set(key, [calculator]);
+    }
+    return buckets;
+};

package/dist/calculator/index.d.ts

@@ -1,4 +1,5 @@
 export * from './schema.js';
+export * from './categories.js';
 export * from './units.js';
 export * from './evaluate.js';
 export * from './solve.js';

package/dist/calculator/index.js

@@ -3,6 +3,7 @@
 // definition validation. Pure logic (mathjs + zod only — no Skia/React), safe
 // on web, native, and Node.
 export * from './schema.js';
+export * from './categories.js';
 export * from './units.js';
 export * from './evaluate.js';
 export * from './solve.js';

package/dist/calculator/schema.d.ts

@@ -1,5 +1,6 @@
 import { ColumnType, type ColumnConfig, type ConversionTableColumnData, type InstructionsColumnData, type SelectColumnData, type DecimalTolerance, type FractionalTolerance } from '../types/firestore.js';
 import type { AngleUnit, CalculatorUnit, FieldDimension, MeasurementDimension } from './units.js';
+import type { CalculatorCategoryId } from './categories.js';
 /**
  * Version of the definition format itself. Bumped only on breaking schema
  * changes; independent of the npm package version and of each calculator's
@@ -123,6 +124,17 @@ export interface CalculatorDefinition {
     name: string;
     description: string;
     folderId: string | null;
+    /**
+     * Hard-coded category (see categories.ts) driving the mobile category grid
+     * and the web library badge.
+     *
+     * AUTHORING METADATA ONLY — never needed to run a calculator, so it stays
+     * optional and nullable: docs authored before categories existed have no
+     * value and must keep validating. Always resolve through
+     * findCalculatorCategory() rather than comparing the raw field, so a retired
+     * id degrades to "Other" instead of vanishing.
+     */
+    category?: CalculatorCategoryId | null;
     /** Inputs + outputs in one list, discriminated by `role`. */
     fields: CalculatorField[];
     equations: CalculatorEquation[];

package/dist/calculator/schema.js

@@ -122,6 +122,9 @@ export const createEmptyCalculatorDefinition = (id) => ({
     name: '',
     description: '',
     folderId: null,
+    // `null`, never undefined — this object is spread straight into setDoc and
+    // Firestore rejects undefined field values.
+    category: null,
     fields: [],
     equations: [],
     diagramFileId: null,

package/dist/calculator/validate.d.ts

@@ -7,6 +7,7 @@ export declare const calculatorDefinitionSchema: z.ZodObject<{
     name: z.ZodString;
     description: z.ZodString;
     folderId: z.ZodNullable<z.ZodString>;
+    category: z.ZodOptional<z.ZodNullable<z.ZodString>>;
     fields: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
         kind: z.ZodLiteral<ColumnType.Number>;
         defaultValue: z.ZodOptional<z.ZodNumber>;

package/dist/calculator/validate.js

@@ -3,6 +3,7 @@ import { create, all } from 'mathjs';
 import { ColumnType, DecimalTolerance, FractionalTolerance, } from '../types/firestore.js';
 import { CALCULATOR_SCHEMA_VERSION, equationForField, isEquationTargetKind, isNumericFieldKind, } from './schema.js';
 import { CALCULATOR_UNIT_INFO, unitDimension } from './units.js';
+import { isCalculatorCategoryId } from './categories.js';
 const math = create(all);
 // ---------------------------------------------------------------------------
 // Definition validation: zod for structure, plus the cross-field invariants
@@ -101,6 +102,14 @@ export const calculatorDefinitionSchema = z.object({
     name: z.string(),
     description: z.string(),
     folderId: z.string().nullable(),
+    // Deliberately z.string(), NOT z.enum(CalculatorCategoryId): a safeParse
+    // failure returns early below, so a retired or typo'd id would suppress
+    // every other invariant and mark the whole calculator broken. Unknown ids
+    // are reported further down as an advisory warning instead.
+    //
+    // The key must be listed even though it's optional — zod strips unknown
+    // keys, so omitting it here would make the check below never fire.
+    category: z.string().nullish(),
     fields: z.array(calculatorFieldSchema),
     equations: z.array(calculatorEquationSchema),
     diagramFileId: z.string().nullable().optional(),
@@ -187,6 +196,12 @@ export const validateCalculatorDefinition = (input) => {
     if (def.schemaVersion > CALCULATOR_SCHEMA_VERSION) {
         push('schema-version-unsupported', 'schemaVersion', `schemaVersion ${def.schemaVersion} is newer than this client supports (${CALCULATOR_SCHEMA_VERSION})`);
     }
+    // A category the client doesn't know is a labelling problem, not a broken
+    // calculator — an older app build reading a newly-added category must still
+    // run it. Warning severity keeps `ok` true.
+    if (def.category != null && !isCalculatorCategoryId(def.category)) {
+        push('unknown-category', 'category', `Category "${def.category}" is not a known calculator category`, 'warning');
+    }
     // --- Unique ids ---------------------------------------------------------
     const fieldIds = new Set();
     def.fields.forEach((field, i) => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@reekon-tools/boldr-utils",
-  "version": "1.7.5",
+  "version": "1.8.0",
   "description": "Shared utilities for formulas and measurement conversion used in Reekon apps",
   "author": "REEKON Tools",
   "license": "MIT",
@@ -25,6 +25,7 @@
     "build": "tsc",
     "prepack": "yarn run build",
     "sync:local": "./scripts/sync-local.sh",
+    "gen:category-icons": "tsc && node ./scripts/gen-category-icons.mjs",
     "test": "vitest",
     "coverage": "vitest run --coverage",
     "format": "prettier --write .",

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;