@reekon-tools/boldr-utils 1.10.3 → 1.12.0

package/dist/theme/semantic.d.ts

@@ -0,0 +1,136 @@
+/**
+ * Structural shape of a Tailwind `theme.extend.colors` tree.
+ *
+ * Declared locally on purpose: annotating with tailwindcss's own `Config` type
+ * would put `import type { Config } from 'tailwindcss'` into the emitted .d.ts
+ * and make tailwindcss a hard type dependency of this package.
+ */
+export type ColorTree = {
+    [key: string]: string | ColorTree;
+};
+/**
+ * Semantic design tokens — the layer apps actually consume.
+ *
+ * `colors.ts` is the palette (raw Figma variables, named by value).
+ * This file maps those values onto *roles*, and is the only color surface the
+ * apps should reference. The raw palette is deliberately NOT exposed as Tailwind
+ * classes; naming by value is how both apps accumulated hundreds of arbitrary
+ * hex classes in the first place.
+ *
+ * The shadcn/ui token names (background, card, popover, foreground, muted,
+ * accent, secondary, border, input, ring, primary, destructive) are reused
+ * rather than paralleled, so every shadcn component is re-skinned without any
+ * component edits and `shadcn add` keeps generating markup that lands on these
+ * tokens.
+ *
+ * The design is dark-only. The light calculator / form surfaces are the
+ * explicitly-named `paper.*` tokens, not a light/dark variant pair — on native
+ * NativeWind's `dark:` variant is global, and portal-rendered surfaces
+ * (bottom sheets, dialogs, selects) mount outside any scoped subtree, so a
+ * scoped override would leak dark chrome onto a light page.
+ */
+export declare const boldrColors: {
+    background: "#1D1F21";
+    foreground: {
+        DEFAULT: "#FFFFFF";
+        disabled: "#626364";
+    };
+    card: {
+        DEFAULT: "#2B2C2E";
+        foreground: "#FFFFFF";
+    };
+    popover: {
+        DEFAULT: "#2B2C2E";
+        foreground: "#FFFFFF";
+    };
+    muted: {
+        DEFAULT: "#424345";
+        foreground: "#9FA0A2";
+    };
+    accent: {
+        DEFAULT: "#424345";
+        foreground: "#FFFFFF";
+    };
+    secondary: {
+        DEFAULT: "#424345";
+        foreground: "#FFFFFF";
+    };
+    border: {
+        DEFAULT: "#424345";
+        strong: "#626364";
+    };
+    input: "#424345";
+    ring: "#FFAD00";
+    primary: {
+        DEFAULT: "#FFAD00";
+        foreground: "#1D1F21";
+    };
+    destructive: {
+        DEFAULT: "#DF6358";
+        foreground: "#1D1F21";
+    };
+    /** Chips, inset controls, thumbnail placeholders. */
+    elevated: {
+        DEFAULT: "#424345";
+        foreground: "#FFFFFF";
+    };
+    /**
+     * Steppers and other interactive fills. FILL ONLY — #0066FF as text on
+     * #2B2C2E is 2.89:1. Never `text-interactive`.
+     */
+    interactive: {
+        DEFAULT: "#0066FF";
+        foreground: "#FFFFFF";
+    };
+    /** Nav chrome (the web app's sidebar). */
+    nav: {
+        DEFAULT: "#2D3843";
+        foreground: "#FFFFFF";
+    };
+    paper: {
+        DEFAULT: "#E8EAED";
+        foreground: "#1D1F21";
+        field: "#FFFFFF";
+        line: "#BCBEC2";
+        muted: "#626364";
+    };
+    tile: {
+        /**
+         * Ink for any tile fill — `text-tile-foreground`. Shared across the
+         * measurement and formula variants because both carry white type; keeping it
+         * at the family level avoids two identical `foreground` keys that could
+         * drift apart by accident.
+         */
+        foreground: "#FFFFFF";
+        measurement: {
+            DEFAULT: "#0066FF";
+            badge: "#50A6FF";
+        };
+        formula: {
+            DEFAULT: "#BD30A8";
+            badge: "#6C155F";
+        };
+        count: {
+            DEFAULT: "#02274B";
+            foreground: "#FFFFFF";
+        };
+    };
+    diagram: {
+        1: "#2E4C6A";
+        2: "#4B6074";
+        3: "#67819A";
+    };
+    tolerance: {
+        in: {
+            DEFAULT: "#58A942";
+            warning: "#00E920";
+            muted: "#8BB380";
+        };
+        out: {
+            DEFAULT: "#E83D2F";
+            warning: "#DA1100";
+            muted: "#DF6358";
+        };
+    };
+};
+export type BoldrColors = typeof boldrColors;

package/dist/theme/semantic.js

@@ -0,0 +1,116 @@
+import { GeneralColors, SecondaryColors, FormColors, TileColors, FormulaColors, YellowColors, RedColors, GreenColors, } from './colors.js';
+/**
+ * Semantic design tokens — the layer apps actually consume.
+ *
+ * `colors.ts` is the palette (raw Figma variables, named by value).
+ * This file maps those values onto *roles*, and is the only color surface the
+ * apps should reference. The raw palette is deliberately NOT exposed as Tailwind
+ * classes; naming by value is how both apps accumulated hundreds of arbitrary
+ * hex classes in the first place.
+ *
+ * The shadcn/ui token names (background, card, popover, foreground, muted,
+ * accent, secondary, border, input, ring, primary, destructive) are reused
+ * rather than paralleled, so every shadcn component is re-skinned without any
+ * component edits and `shadcn add` keeps generating markup that lands on these
+ * tokens.
+ *
+ * The design is dark-only. The light calculator / form surfaces are the
+ * explicitly-named `paper.*` tokens, not a light/dark variant pair — on native
+ * NativeWind's `dark:` variant is global, and portal-rendered surfaces
+ * (bottom sheets, dialogs, selects) mount outside any scoped subtree, so a
+ * scoped override would leak dark chrome onto a light page.
+ */
+export const boldrColors = {
+    // ── dark app chrome — shadcn-compatible names, re-pointed ────────────────
+    background: GeneralColors.darkGrey, // screen + header
+    foreground: {
+        DEFAULT: GeneralColors.white,
+        disabled: GeneralColors.grey3, // text-foreground-disabled
+    },
+    card: { DEFAULT: GeneralColors.grey1, foreground: GeneralColors.white },
+    popover: { DEFAULT: GeneralColors.grey1, foreground: GeneralColors.white },
+    // muted / accent / secondary exist so unmodified shadcn components look
+    // right. Prefer `elevated` in new boldr components — it gives future
+    // divergence a seam.
+    muted: { DEFAULT: GeneralColors.grey2, foreground: GeneralColors.grey4 },
+    accent: { DEFAULT: GeneralColors.grey2, foreground: GeneralColors.white },
+    secondary: { DEFAULT: GeneralColors.grey2, foreground: GeneralColors.white },
+    border: { DEFAULT: GeneralColors.grey2, strong: GeneralColors.grey3 },
+    input: GeneralColors.grey2,
+    ring: YellowColors.mainYellow,
+    primary: {
+        DEFAULT: YellowColors.mainYellow,
+        // White on #FFAD00 is 1.87:1. Dark ink is 8.84:1, and matches the mockups.
+        foreground: GeneralColors.darkGrey,
+    },
+    destructive: {
+        DEFAULT: RedColors.mutedRed,
+        // Confirmed against the Settings frame: the Log Out label is dark ink.
+        // White on #DF6358 would be 3.46:1; #1D1F21 is 4.77:1.
+        foreground: GeneralColors.darkGrey,
+    },
+    // ── boldr additions the shadcn vocabulary has no word for ───────────────
+    /** Chips, inset controls, thumbnail placeholders. */
+    elevated: { DEFAULT: GeneralColors.grey2, foreground: GeneralColors.white },
+    /**
+     * Steppers and other interactive fills. FILL ONLY — #0066FF as text on
+     * #2B2C2E is 2.89:1. Never `text-interactive`.
+     */
+    interactive: {
+        DEFAULT: TileColors.activeBlue,
+        foreground: GeneralColors.white,
+    },
+    /** Nav chrome (the web app's sidebar). */
+    nav: {
+        DEFAULT: SecondaryColors.accentBlue1,
+        foreground: GeneralColors.white,
+    },
+    // ── light "paper": the calculator page and form fields ──────────────────
+    paper: {
+        DEFAULT: FormColors.lightGrey2, // bg-paper            page / canvas
+        foreground: GeneralColors.darkGrey, // text-paper-foreground
+        field: GeneralColors.white, // bg-paper-field      inputs, cards on paper
+        line: FormColors.lightGrey1, // border-paper-line   field borders, dividers
+        // grey3, not lightGrey1: #BCBEC2 on #E8EAED is 1.54:1 — invisible.
+        // lightGrey1 is a border color only, which is why it's `paper.line`.
+        muted: GeneralColors.grey3, // text-paper-muted
+    },
+    // ── product tiles ───────────────────────────────────────────────────────
+    tile: {
+        /**
+         * Ink for any tile fill — `text-tile-foreground`. Shared across the
+         * measurement and formula variants because both carry white type; keeping it
+         * at the family level avoids two identical `foreground` keys that could
+         * drift apart by accident.
+         */
+        foreground: GeneralColors.white,
+        measurement: {
+            DEFAULT: TileColors.activeBlue,
+            badge: TileColors.lightBlue1,
+        },
+        // Note the badge is DARKER than the tile here, inverting the old app-local
+        // values. Confirmed in the mockups: a magenta tile with a darker magenta
+        // label bar.
+        formula: { DEFAULT: FormulaColors.purple, badge: FormulaColors.darkPurple },
+        count: { DEFAULT: TileColors.darkBlue, foreground: GeneralColors.white },
+    },
+    // ── 3D / diagram depth ramp (ordered; the steps have no individual meaning) ─
+    diagram: {
+        1: SecondaryColors.accentBlue2,
+        2: SecondaryColors.accentBlue3,
+        3: SecondaryColors.accentBlue4,
+    },
+    // ── measurement tolerance ───────────────────────────────────────────────
+    tolerance: {
+        in: {
+            DEFAULT: GreenColors.green,
+            warning: GreenColors.warningGreen,
+            muted: GreenColors.mutedGreen,
+        },
+        out: {
+            DEFAULT: RedColors.red,
+            warning: RedColors.warningRed,
+            muted: RedColors.mutedRed,
+        },
+    },
+};

package/dist/types/annotation.d.ts

@@ -96,11 +96,27 @@ export interface AnnotationBackgroundImage {
     heightPx: number;
     format?: 'raster' | 'svg';
 }
+export interface BackgroundLayerTransform {
+    x: number;
+    y: number;
+    scaleX: number;
+    scaleY: number;
+}
+export interface AnnotationBackgroundLayer {
+    id: AnnotationElementId;
+    storagePath: string;
+    downloadUrl: string;
+    widthPx: number;
+    heightPx: number;
+    format?: 'raster' | 'svg';
+    transform: BackgroundLayerTransform;
+}
 export interface AnnotationViewport {
     width: number;
     height: number;
     backgroundImage?: AnnotationBackgroundImage;
     backgroundFit?: BackgroundFit;
+    backgroundImages?: AnnotationBackgroundLayer[];
 }
 export type TileScalePlatform = 'web' | 'mobile';
 export interface AnnotationCanvasState {
@@ -155,6 +171,17 @@ export type AnnotationPatchOp = {
 } | {
     op: 'removeMeasurement';
     id: AnnotationElementId;
+} | {
+    op: 'addBackgroundImage';
+    image: AnnotationBackgroundLayer;
+    index?: number;
+} | {
+    op: 'updateBackgroundImage';
+    id: AnnotationElementId;
+    patch: Partial<Omit<AnnotationBackgroundLayer, 'id'>>;
+} | {
+    op: 'removeBackgroundImage';
+    id: AnnotationElementId;
 } | {
     op: 'setViewport';
     patch: Partial<AnnotationViewport>;

package/dist/types/annotation.js

@@ -1,3 +1,4 @@
+import { backgroundLayersOf } from '../annotation/canvas/backgroundLayers.js';
 export const DEFAULT_LAYER_ID = 'default';
 export const createDefaultLayer = () => ({
     id: DEFAULT_LAYER_ID,
@@ -20,11 +21,40 @@ export const createEmptyCanvasState = (viewport) => ({
         ...(viewport?.backgroundFit !== undefined
             ? { backgroundFit: viewport.backgroundFit }
             : {}),
+        ...(viewport?.backgroundImages !== undefined
+            ? { backgroundImages: viewport.backgroundImages }
+            : {}),
     },
     strokes: [],
     shapes: [],
     placedMeasurements: [],
 });
+// Layer 0 projected into the legacy single-slot shape. The transform is
+// dropped — old clients draw the legacy field fit-centered, an accepted
+// degradation. `format` is included only when defined so the mirror survives
+// the write path's JSON round-trip without changing shape.
+const legacyBackgroundOf = (layer) => ({
+    storagePath: layer.storagePath,
+    downloadUrl: layer.downloadUrl,
+    widthPx: layer.widthPx,
+    heightPx: layer.heightPx,
+    ...(layer.format ? { format: layer.format } : {}),
+});
+// Every background mutation lands here: it writes the (already-normalized)
+// layer array and mirrors layer 0 into the legacy slot, so old clients —
+// which read only `backgroundImage` and rewrite the whole canvas on save —
+// keep rendering the first image instead of persisting its loss. An empty
+// stack sets BOTH fields to explicit `undefined`: the write path's JSON
+// round-trip strips those keys (Firestore rejects undefined values).
+// `backgroundFit` is left alone — it belongs to the legacy render path.
+const withBackgroundLayers = (state, layers) => ({
+    ...state,
+    viewport: {
+        ...state.viewport,
+        backgroundImages: layers.length > 0 ? layers : undefined,
+        backgroundImage: layers.length > 0 ? legacyBackgroundOf(layers[0]) : undefined,
+    },
+});
 // Apply an in-memory patch to a canvas state. Pure — returns a new object.
 // Used by the canvas reducer and by InMemoryAnnotationProvider; consumers
 // can also call this when they receive a patch from the canvas to compute
@@ -71,6 +101,22 @@ const applyOp = (state, op) => {
                 ...state,
                 placedMeasurements: state.placedMeasurements.filter((m) => m.id !== op.id),
             };
+        case 'addBackgroundImage': {
+            const layers = backgroundLayersOf(state.viewport);
+            // Clamp so a stale index (e.g. an undo replayed after a concurrent
+            // removal) can never create a sparse array — a hole becomes `null`
+            // through the write path's JSON round-trip and corrupts the doc.
+            const index = Math.max(0, Math.min(op.index ?? layers.length, layers.length));
+            return withBackgroundLayers(state, [
+                ...layers.slice(0, index),
+                op.image,
+                ...layers.slice(index),
+            ]);
+        }
+        case 'updateBackgroundImage':
+            return withBackgroundLayers(state, backgroundLayersOf(state.viewport).map((l) => l.id === op.id ? { ...l, ...op.patch } : l));
+        case 'removeBackgroundImage':
+            return withBackgroundLayers(state, backgroundLayersOf(state.viewport).filter((l) => l.id !== op.id));
         case 'setViewport':
             return { ...state, viewport: { ...state.viewport, ...op.patch } };
         case 'setTileScaleFactor':
@@ -148,6 +194,28 @@ const invertOp = (before, op) => {
             }
             return { op: 'updateMeasurement', id: op.id, patch: inversePatch };
         }
+        case 'addBackgroundImage':
+            return { op: 'removeBackgroundImage', id: op.image.id };
+        case 'removeBackgroundImage': {
+            // Invert against the NORMALIZED stack: the before-state may hold only
+            // the legacy single field (the op being inverted is what materialized
+            // the array), and undo must still restore that layer — at its index.
+            const layers = backgroundLayersOf(before.viewport);
+            const index = layers.findIndex((l) => l.id === op.id);
+            return index >= 0
+                ? { op: 'addBackgroundImage', image: layers[index], index }
+                : null;
+        }
+        case 'updateBackgroundImage': {
+            const prev = backgroundLayersOf(before.viewport).find((l) => l.id === op.id);
+            if (!prev)
+                return null;
+            const inversePatch = {};
+            for (const k of Object.keys(op.patch)) {
+                inversePatch[k] = prev[k];
+            }
+            return { op: 'updateBackgroundImage', id: op.id, patch: inversePatch };
+        }
         case 'setViewport': {
             const inversePatch = {};
             for (const k of Object.keys(op.patch)) {

package/package.json

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

package/dist/canvas/AnnotationCanvas.d.ts

@@ -1,11 +0,0 @@
-import { type ReactNode } from 'react';
-import type { AnnotationCanvasInnerProps } from './AnnotationCanvasInner.js';
-export type { AnnotationCanvasHandle, GestureConfig, PanTrigger, } from './AnnotationCanvasInner.js';
-export interface CanvasKitOpts {
-    locateFile?: (file: string) => string;
-}
-export type AnnotationCanvasProps = AnnotationCanvasInnerProps & {
-    fallback?: ReactNode;
-    canvasKitOpts?: CanvasKitOpts;
-};
-export declare const AnnotationCanvas: ({ fallback, canvasKitOpts, ...rest }: AnnotationCanvasProps) => import("react/jsx-runtime").JSX.Element;

package/dist/canvas/AnnotationCanvas.js

@@ -1,10 +0,0 @@
-import { jsx as _jsx } from "react/jsx-runtime";
-import { WithSkiaWeb } from '@shopify/react-native-skia/lib/module/web/index.js';
-// Web-only entry point: lazy-loads CanvasKit wasm via WithSkiaWeb. Imperative
-// API (undo/redo/zoom) is exposed through the `imperativeRef` prop rather
-// than React refs, since WithSkiaWeb can't forward refs through its lazy
-// component boundary. The native build sits in `AnnotationCanvas.native.tsx`
-// and skips WithSkiaWeb entirely (no wasm to load).
-export const AnnotationCanvas = ({ fallback, canvasKitOpts, ...rest }) => (_jsx(WithSkiaWeb, { getComponent: () => import('./AnnotationCanvasInner.js').then((m) => ({
-        default: m.AnnotationCanvasInner,
-    })), fallback: fallback ?? null, componentProps: rest, opts: canvasKitOpts }));

package/dist/canvas/AnnotationCanvas.native.d.ts

@@ -1,8 +0,0 @@
-import type { AnnotationCanvasInnerProps } from './AnnotationCanvasInner.native.js';
-export type { AnnotationCanvasHandle, } from './useAnnotationCanvasState.js';
-export type { GestureConfig, PanTrigger, } from './AnnotationCanvasInner.js';
-export type AnnotationCanvasProps = AnnotationCanvasInnerProps & {
-    fallback?: unknown;
-    canvasKitOpts?: unknown;
-};
-export declare const AnnotationCanvas: (props: AnnotationCanvasProps) => import("react/jsx-runtime").JSX.Element;

package/dist/canvas/AnnotationCanvas.native.js

@@ -1,6 +0,0 @@
-import { jsx as _jsx } from "react/jsx-runtime";
-import { AnnotationCanvasInner } from './AnnotationCanvasInner.native.js';
-export const AnnotationCanvas = (props) => {
-    const { fallback: _f, canvasKitOpts: _o, ...rest } = props;
-    return _jsx(AnnotationCanvasInner, { ...rest });
-};

package/dist/canvas/AnnotationCanvasInner.d.ts

@@ -1,39 +0,0 @@
-import { type CSSProperties, type MutableRefObject } from 'react';
-import type { DecimalTolerance, FractionalTolerance, Measurement, Units } from '../types/firestore.js';
-import type { AnnotationCanvasState, AnnotationDocumentPatch, Selection } from '../types/annotation.js';
-import type { MeasurementRef } from './measurementPicker.js';
-import type { Tool } from './Tool.js';
-import { type AnnotationCanvasHandle } from './useAnnotationCanvasState.js';
-import { type ViewportState } from './viewport.js';
-import type { RenderMeasurementStamp } from './measurementStampOverlay.js';
-export type { AnnotationCanvasHandle };
-export interface AnnotationCanvasInnerProps {
-    canvas: AnnotationCanvasState;
-    onCommit(patch: AnnotationDocumentPatch): void;
-    tools: Tool[];
-    activeToolId: string;
-    selection: Selection | null;
-    onSelectionChange(selection: Selection | null): void;
-    measurements?: Measurement[];
-    fallbackUnit?: Units;
-    fractionalTolerance?: FractionalTolerance;
-    decimalTolerance?: DecimalTolerance;
-    resolveImageUrl?: (storagePath: string) => Promise<string>;
-    pickMeasurement?: () => Promise<MeasurementRef | null>;
-    renderMeasurementStamp?: RenderMeasurementStamp;
-    stampFontSource?: unknown;
-    stampValueFontSize?: number;
-    stampLabelFontSize?: number;
-    gestures?: GestureConfig;
-    width: number;
-    height: number;
-    initialViewport?: ViewportState;
-    style?: CSSProperties;
-    imperativeRef?: MutableRefObject<AnnotationCanvasHandle | null>;
-}
-export type PanTrigger = 'middleMouse' | 'rightMouse' | 'space';
-export interface GestureConfig {
-    wheel?: 'zoom' | 'pan' | 'auto';
-    panTriggers?: PanTrigger[];
-}
-export declare const AnnotationCanvasInner: (props: AnnotationCanvasInnerProps) => import("react/jsx-runtime").JSX.Element;