@reekon-tools/boldr-utils 1.8.4 → 1.9.0

package/dist/calculator/validate.js

@@ -1,10 +1,9 @@
 import { z } from 'zod';
-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 { CALCULATOR_SCHEMA_VERSION, equationForField, fieldDimension, isEquationTargetKind, isNumericFieldKind, } from './schema.js';
+import { CALCULATOR_UNIT_INFO, unitDimension, } from './units.js';
+import { MATHJS_CONSTANTS, inferExpressionUnit, isEquivalentUnit, parseExpression, producesCanonicalValue, unitScaleRatio, } from './expressionUnits.js';
 import { isCalculatorCategoryId } from './categories.js';
-const math = create(all);
 // ---------------------------------------------------------------------------
 // Definition validation: zod for structure, plus the cross-field invariants
 // zod can't express (reference resolution, cycles, solve wiring). Callable
@@ -94,6 +93,8 @@ const calculatorEquationSchema = z.object({
     targetFieldId: z.string().min(1),
     expression: z.string().min(1),
     variableToFieldId: z.record(z.string(), z.string()),
+    variableUnits: z.record(z.string(), calculatorUnitSchema).optional(),
+    resultUnit: calculatorUnitSchema.optional(),
 });
 export const calculatorDefinitionSchema = z.object({
     id: z.string().min(1),
@@ -127,45 +128,43 @@ export const calculatorDefinitionSchema = z.object({
     createdAt: z.unknown().optional(),
     updatedAt: z.unknown().optional(),
 });
-// Constants mathjs resolves without a scope entry.
-const KNOWN_SYMBOLS = new Set([
-    'pi',
-    'PI',
-    'e',
-    'E',
-    'tau',
-    'phi',
-    'i',
-    'true',
-    'false',
-    'Infinity',
-    'NaN',
-    'null',
-]);
-/** Free variables of an expression (function names and constants excluded). */
-export const expressionSymbols = (expression) => {
-    try {
-        const node = math.parse(expression);
-        const symbols = new Set();
-        node.traverse((n, path, parent) => {
-            const sym = n;
-            const par = parent;
-            if (sym.isSymbolNode &&
-                sym.name &&
-                !(par?.isFunctionNode && path === 'fn') &&
-                !KNOWN_SYMBOLS.has(sym.name)) {
-                symbols.add(sym.name);
-            }
-        });
-        return { ok: true, symbols: [...symbols] };
-    }
-    catch (err) {
-        return {
-            ok: false,
-            error: err instanceof Error ? err.message : String(err),
-        };
-    }
+/**
+ * Free variables of an expression (function names and constants excluded).
+ *
+ * `knownVariables` are treated as variables even when mathjs would resolve
+ * them as constants: the authoring UI names variables A, B, C… and `E` is
+ * Euler's number, so without this a mapped `E` reads as a constant and gets
+ * reported as an unused variable. Evaluation is unaffected — a scope entry
+ * shadows the constant — so this only realigns validation with reality.
+ */
+export const expressionSymbols = (expression, knownVariables) => {
+    const parsed = parseExpression(expression);
+    if (!parsed.ok)
+        return { ok: false, error: parsed.error };
+    const known = new Set(knownVariables ?? []);
+    const symbols = new Set();
+    parsed.node.traverse((n, path, parent) => {
+        const sym = n;
+        const par = parent;
+        if (sym.isSymbolNode &&
+            sym.name &&
+            !(par?.isFunctionNode && path === 'fn') &&
+            (!MATHJS_CONSTANTS.has(sym.name) || known.has(sym.name))) {
+            symbols.add(sym.name);
+        }
+    });
+    return { ok: true, symbols: [...symbols] };
 };
+const DIMENSION_LABELS = {
+    length: 'a length',
+    area: 'an area',
+    volume: 'a volume',
+    angle: 'an angle',
+    none: 'a plain number',
+};
+const describeDimension = (dimension) => DIMENSION_LABELS[dimension];
+// 1728 stays 1728; 57.29577951308232 becomes 57.3.
+const trimRatio = (ratio) => Number.isInteger(ratio) ? String(ratio) : ratio.toFixed(1);
 // Does `equation` depend on `fieldId`, directly or through the equations of
 // output fields it references? (Chained solving: the unknown may reach the
 // governing equation through intermediate outputs.)
@@ -303,7 +302,81 @@ export const validateCalculatorDefinition = (input) => {
                 push('self-referencing-equation', `${path}.variableToFieldId.${variable}`, `Equation for "${eq.targetFieldId}" references its own target`);
             }
         }
-        const symbols = expressionSymbols(eq.expression);
+        // --- Unit annotations --------------------------------------------------
+        for (const [variable, unit] of Object.entries(eq.variableUnits ?? {})) {
+            const unitPath = `${path}.variableUnits.${variable}`;
+            const mappedId = eq.variableToFieldId[variable];
+            if (mappedId == null) {
+                push('unit-for-unmapped-variable', unitPath, `Variable ${variable} has a unit but no field mapping`, 'warning');
+                continue;
+            }
+            const mapped = fieldById.get(mappedId);
+            if (!mapped)
+                continue; // unknown-mapped-field already reported above
+            const dim = fieldDimension(mapped);
+            if (dim === 'none') {
+                push('variable-unit-on-dimensionless-field', unitPath, `Variable ${variable} maps to "${mapped.name}", which has no unit dimension`);
+            }
+            else if (unitDimension(unit) !== dim) {
+                push('variable-unit-dimension-mismatch', unitPath, `Unit "${unit}" is not a ${dim} unit (variable ${variable} maps to "${mapped.name}")`);
+            }
+        }
+        if (target) {
+            const dim = fieldDimension(target);
+            if (eq.resultUnit != null) {
+                if (dim === 'none') {
+                    push('result-unit-on-number-target', `${path}.resultUnit`, `Equation target "${target.name}" is a number field and takes the result as-is; remove the result unit`);
+                }
+                else if (unitDimension(eq.resultUnit) !== dim) {
+                    push('result-unit-dimension-mismatch', `${path}.resultUnit`, `Result unit "${eq.resultUnit}" is not a ${dim} unit (target "${target.name}")`);
+                }
+            }
+            // The unit the EXPRESSION produces, which is what `resultUnit` claims to
+            // be. Dimension checks against the target field can't see a same-
+            // dimension scale error: three inch variables multiplied are in³, so
+            // `cu_ft` passes every check above while reporting 1728× the truth.
+            const inferred = inferExpressionUnit(def.fields, eq);
+            if (inferred.ok && dim !== 'none') {
+                if (inferred.dimension !== dim) {
+                    push('expression-dimension-mismatch', `${path}.expression`, `Expression produces ${describeDimension(inferred.dimension)} but "${target.name}" is ${describeDimension(dim)} — check the variable units and the expression`);
+                }
+                else if (eq.resultUnit == null) {
+                    if (!producesCanonicalValue(inferred)) {
+                        push('missing-result-unit', `${path}.resultUnit`, `Expression produces a value in ${inferred.unit ? `"${inferred.unit}"` : inferred.bases.join('/')} but no result unit is set, so it will be stored as a canonical value. Set the result unit${inferred.unit ? ` to "${inferred.unit}"` : ''}.`);
+                    }
+                }
+                else if (inferred.unit != null &&
+                    // A result unit from the wrong dimension is already reported above;
+                    // quoting a scale factor across dimensions would be meaningless.
+                    unitDimension(eq.resultUnit) === inferred.dimension &&
+                    !isEquivalentUnit(eq.resultUnit, inferred.unit)) {
+                    const ratio = unitScaleRatio(eq.resultUnit, inferred.unit);
+                    const off = ratio > 1
+                        ? `${trimRatio(ratio)}× too large`
+                        : `${trimRatio(1 / ratio)}× too small`;
+                    push('result-unit-scale-mismatch', `${path}.resultUnit`, `Expression produces "${inferred.unit}" but the result unit is "${eq.resultUnit}" — computed values will be ${off}. Use "${inferred.unit}", or change the variable units to match.`);
+                }
+            }
+            if (inferred.ok && inferred.bases.length > 1) {
+                push('mixed-base-units', `${path}.variableUnits`, `Variables mix ${inferred.bases.join(' and ')} in one expression, so the result has no single unit. Put them all in the same unit.`, 'warning');
+            }
+            if (!inferred.ok && inferred.reason === 'inconsistent-terms') {
+                push('expression-mixed-dimensions', `${path}.expression`, 'Expression adds or compares terms of different dimensions (a length and an area, say) — one of them is probably the wrong field', 'warning');
+            }
+        }
+        // The canonical-leak trap: a number target consuming a unit-carrying
+        // field without a variable unit receives raw µm-scale values.
+        if (target?.kind === ColumnType.Number) {
+            for (const [variable, fieldId] of Object.entries(eq.variableToFieldId)) {
+                const mapped = fieldById.get(fieldId);
+                if (!mapped || fieldDimension(mapped) === 'none')
+                    continue;
+                if (eq.variableUnits?.[variable] == null) {
+                    push('canonical-value-into-number-target', `${path}.variableToFieldId.${variable}`, `"${target.name}" is a number field but variable ${variable} ("${mapped.name}") has no display unit — its canonical (µm-scale) value will be used. Pick a unit for ${variable}.`, 'warning');
+                }
+            }
+        }
+        const symbols = expressionSymbols(eq.expression, Object.keys(eq.variableToFieldId));
         if (!symbols.ok) {
             push('expression-invalid', `${path}.expression`, `Expression does not parse: ${symbols.error}`);
         }

package/dist/theme/index.d.ts

@@ -0,0 +1,3 @@
+export * from './colors.js';
+export * from './semantic.js';
+export * from './preset.js';

package/dist/theme/index.js

@@ -0,0 +1,3 @@
+export * from './colors.js';
+export * from './semantic.js';
+export * from './preset.js';

package/dist/theme/preset.d.ts

@@ -0,0 +1,120 @@
+/**
+ * Shared Tailwind preset. COLORS ONLY, by design.
+ *
+ * Must never define `content`, `plugins`, `presets`, or `darkMode`:
+ * NativeWind recurses `config.presets[].presets` hunting for its own marker
+ * preset, and a `content` key here would silently narrow the consuming app's
+ * globs.
+ *
+ * Consumed from CJS Tailwind configs, so this is a NAMED export with no
+ * default — that keeps ESM/CJS interop semantics irrelevant:
+ *
+ *   const { boldrPreset } = require('@reekon-tools/boldr-utils/theme/preset');
+ *   module.exports = { presets: [require('nativewind/preset'), boldrPreset] };
+ *
+ * Tailwind loads configs through jiti + sucrase, so requiring this ESM file
+ * from a CJS config works regardless of Node version.
+ *
+ * Note that Tailwind merges `theme.extend` per key with the *app* winning, and
+ * replaces a color key wholesale rather than deep-merging. An app that keeps
+ * its own `colors.background` will silently shadow this preset.
+ */
+export declare const boldrPreset: {
+    theme: {
+        extend: {
+            colors: {
+                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";
+                };
+                elevated: {
+                    DEFAULT: "#424345";
+                    foreground: "#FFFFFF";
+                };
+                interactive: {
+                    DEFAULT: "#0066FF";
+                    foreground: "#FFFFFF";
+                };
+                nav: {
+                    DEFAULT: "#2D3843";
+                    foreground: "#FFFFFF";
+                };
+                paper: {
+                    DEFAULT: "#E8EAED";
+                    foreground: "#1D1F21";
+                    field: "#FFFFFF";
+                    line: "#BCBEC2";
+                    muted: "#626364";
+                };
+                tile: {
+                    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 BoldrPreset = typeof boldrPreset;

package/dist/theme/preset.js

@@ -0,0 +1,25 @@
+import { boldrColors } from './semantic.js';
+/**
+ * Shared Tailwind preset. COLORS ONLY, by design.
+ *
+ * Must never define `content`, `plugins`, `presets`, or `darkMode`:
+ * NativeWind recurses `config.presets[].presets` hunting for its own marker
+ * preset, and a `content` key here would silently narrow the consuming app's
+ * globs.
+ *
+ * Consumed from CJS Tailwind configs, so this is a NAMED export with no
+ * default — that keeps ESM/CJS interop semantics irrelevant:
+ *
+ *   const { boldrPreset } = require('@reekon-tools/boldr-utils/theme/preset');
+ *   module.exports = { presets: [require('nativewind/preset'), boldrPreset] };
+ *
+ * Tailwind loads configs through jiti + sucrase, so requiring this ESM file
+ * from a CJS config works regardless of Node version.
+ *
+ * Note that Tailwind merges `theme.extend` per key with the *app* winning, and
+ * replaces a color key wholesale rather than deep-merging. An app that keeps
+ * its own `colors.background` will silently shadow this preset.
+ */
+export const boldrPreset = {
+    theme: { extend: { colors: boldrColors } },
+};

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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@reekon-tools/boldr-utils",
-  "version": "1.8.4",
+  "version": "1.9.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 });
-};