@reekon-tools/boldr-utils 1.6.4 → 1.6.6

package/dist/types/annotation.d.ts

@@ -0,0 +1,139 @@
+import type { Units } from './firestore.js';
+export type AnnotationElementId = string;
+export type AnnotationLayerId = string;
+export interface Vec2 {
+    x: number;
+    y: number;
+}
+export interface AnnotationStroke {
+    id: AnnotationElementId;
+    layerId: AnnotationLayerId;
+    tool: 'pen' | 'marker' | 'highlighter';
+    color: string;
+    width: number;
+    points: number[];
+    pressure?: number[];
+    createdAt: number;
+}
+export type AnnotationShapeKind = 'rect' | 'ellipse' | 'line' | 'arrow' | 'polygon' | 'text';
+export interface AnnotationShapeStyle {
+    stroke?: string;
+    fill?: string;
+    strokeWidth?: number;
+    fontSize?: number;
+    fontFamily?: string;
+}
+export interface AnnotationShape {
+    id: AnnotationElementId;
+    layerId: AnnotationLayerId;
+    kind: AnnotationShapeKind;
+    geometry: {
+        points: Vec2[];
+        rotation?: number;
+    };
+    style: AnnotationShapeStyle;
+    text?: string;
+    createdAt: number;
+}
+export interface PlacedMeasurementRef {
+    id: AnnotationElementId;
+    layerId: AnnotationLayerId;
+    measurementPath: string;
+    measurementId: string;
+    groupId: string;
+    anchor: Vec2;
+    leader?: {
+        from: Vec2;
+        to: Vec2;
+    };
+    labelOverride?: string;
+    showValue?: boolean;
+    showLabel?: boolean;
+    scale?: number;
+    unitOverride?: Units;
+    createdAt: number;
+}
+export interface AnnotationLayer {
+    id: AnnotationLayerId;
+    name: string;
+    index: number;
+    visible: boolean;
+    locked: boolean;
+}
+export type BackgroundFit = 'contain' | 'cover' | 'stretch';
+export interface AnnotationBackgroundImage {
+    storagePath: string;
+    downloadUrl: string;
+    widthPx: number;
+    heightPx: number;
+}
+export interface AnnotationViewport {
+    width: number;
+    height: number;
+    backgroundImage?: AnnotationBackgroundImage;
+    backgroundFit?: BackgroundFit;
+}
+export interface AnnotationCanvasState {
+    schemaVersion: 1;
+    layers: AnnotationLayer[];
+    viewport: AnnotationViewport;
+    strokes: AnnotationStroke[];
+    shapes: AnnotationShape[];
+    placedMeasurements: PlacedMeasurementRef[];
+    externalPayloadPath?: string;
+}
+export type AnnotationElement = (AnnotationStroke & {
+    kind: 'stroke';
+}) | (AnnotationShape & {
+    kind: 'shape';
+}) | (PlacedMeasurementRef & {
+    kind: 'measurement';
+});
+export interface Selection {
+    ids: AnnotationElementId[];
+}
+export type AnnotationPatchOp = {
+    op: 'addStroke';
+    stroke: AnnotationStroke;
+} | {
+    op: 'updateStroke';
+    id: AnnotationElementId;
+    patch: Partial<AnnotationStroke>;
+} | {
+    op: 'removeStroke';
+    id: AnnotationElementId;
+} | {
+    op: 'addShape';
+    shape: AnnotationShape;
+} | {
+    op: 'updateShape';
+    id: AnnotationElementId;
+    patch: Partial<AnnotationShape>;
+} | {
+    op: 'removeShape';
+    id: AnnotationElementId;
+} | {
+    op: 'addMeasurement';
+    measurement: PlacedMeasurementRef;
+} | {
+    op: 'updateMeasurement';
+    id: AnnotationElementId;
+    patch: Partial<PlacedMeasurementRef>;
+} | {
+    op: 'removeMeasurement';
+    id: AnnotationElementId;
+} | {
+    op: 'setViewport';
+    patch: Partial<AnnotationViewport>;
+} | {
+    op: 'setLayers';
+    layers: AnnotationLayer[];
+};
+export interface AnnotationDocumentPatch {
+    ops: AnnotationPatchOp[];
+}
+export declare const DEFAULT_LAYER_ID = "default";
+export declare const createDefaultLayer: () => AnnotationLayer;
+export declare const createEmptyCanvasState: (viewport?: Partial<AnnotationViewport>) => AnnotationCanvasState;
+export declare const applyPatch: (state: AnnotationCanvasState, patch: AnnotationDocumentPatch) => AnnotationCanvasState;
+export declare const invertPatch: (before: AnnotationCanvasState, patch: AnnotationDocumentPatch) => AnnotationDocumentPatch;

package/dist/types/annotation.js

@@ -0,0 +1,147 @@
+export const DEFAULT_LAYER_ID = 'default';
+export const createDefaultLayer = () => ({
+    id: DEFAULT_LAYER_ID,
+    name: 'Layer 1',
+    index: 0,
+    visible: true,
+    locked: false,
+});
+export const createEmptyCanvasState = (viewport) => ({
+    schemaVersion: 1,
+    layers: [createDefaultLayer()],
+    viewport: {
+        width: viewport?.width ?? 1000,
+        height: viewport?.height ?? 1000,
+        backgroundImage: viewport?.backgroundImage,
+        backgroundFit: viewport?.backgroundFit,
+    },
+    strokes: [],
+    shapes: [],
+    placedMeasurements: [],
+});
+// 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
+// the next document to persist.
+export const applyPatch = (state, patch) => {
+    let next = state;
+    for (const op of patch.ops) {
+        next = applyOp(next, op);
+    }
+    return next;
+};
+const applyOp = (state, op) => {
+    switch (op.op) {
+        case 'addStroke':
+            return { ...state, strokes: [...state.strokes, op.stroke] };
+        case 'updateStroke':
+            return {
+                ...state,
+                strokes: state.strokes.map((s) => s.id === op.id ? { ...s, ...op.patch } : s),
+            };
+        case 'removeStroke':
+            return { ...state, strokes: state.strokes.filter((s) => s.id !== op.id) };
+        case 'addShape':
+            return { ...state, shapes: [...state.shapes, op.shape] };
+        case 'updateShape':
+            return {
+                ...state,
+                shapes: state.shapes.map((s) => s.id === op.id ? { ...s, ...op.patch } : s),
+            };
+        case 'removeShape':
+            return { ...state, shapes: state.shapes.filter((s) => s.id !== op.id) };
+        case 'addMeasurement':
+            return {
+                ...state,
+                placedMeasurements: [...state.placedMeasurements, op.measurement],
+            };
+        case 'updateMeasurement':
+            return {
+                ...state,
+                placedMeasurements: state.placedMeasurements.map((m) => m.id === op.id ? { ...m, ...op.patch } : m),
+            };
+        case 'removeMeasurement':
+            return {
+                ...state,
+                placedMeasurements: state.placedMeasurements.filter((m) => m.id !== op.id),
+            };
+        case 'setViewport':
+            return { ...state, viewport: { ...state.viewport, ...op.patch } };
+        case 'setLayers':
+            return { ...state, layers: op.layers };
+    }
+};
+// Inverse of a patch, for undo stacks. Needs the pre-patch state to find
+// the previous values for update/remove ops. Returns null if the patch
+// cannot be inverted (e.g. an addX with no matching element to remove).
+export const invertPatch = (before, patch) => {
+    const ops = [];
+    for (let i = patch.ops.length - 1; i >= 0; i--) {
+        const op = patch.ops[i];
+        const inverse = invertOp(before, op);
+        if (inverse)
+            ops.push(inverse);
+    }
+    return { ops };
+};
+const invertOp = (before, op) => {
+    switch (op.op) {
+        case 'addStroke':
+            return { op: 'removeStroke', id: op.stroke.id };
+        case 'removeStroke': {
+            const prev = before.strokes.find((s) => s.id === op.id);
+            return prev ? { op: 'addStroke', stroke: prev } : null;
+        }
+        case 'updateStroke': {
+            const prev = before.strokes.find((s) => s.id === op.id);
+            if (!prev)
+                return null;
+            const inversePatch = {};
+            for (const k of Object.keys(op.patch)) {
+                inversePatch[k] = prev[k];
+            }
+            return { op: 'updateStroke', id: op.id, patch: inversePatch };
+        }
+        case 'addShape':
+            return { op: 'removeShape', id: op.shape.id };
+        case 'removeShape': {
+            const prev = before.shapes.find((s) => s.id === op.id);
+            return prev ? { op: 'addShape', shape: prev } : null;
+        }
+        case 'updateShape': {
+            const prev = before.shapes.find((s) => s.id === op.id);
+            if (!prev)
+                return null;
+            const inversePatch = {};
+            for (const k of Object.keys(op.patch)) {
+                inversePatch[k] = prev[k];
+            }
+            return { op: 'updateShape', id: op.id, patch: inversePatch };
+        }
+        case 'addMeasurement':
+            return { op: 'removeMeasurement', id: op.measurement.id };
+        case 'removeMeasurement': {
+            const prev = before.placedMeasurements.find((m) => m.id === op.id);
+            return prev ? { op: 'addMeasurement', measurement: prev } : null;
+        }
+        case 'updateMeasurement': {
+            const prev = before.placedMeasurements.find((m) => m.id === op.id);
+            if (!prev)
+                return null;
+            const inversePatch = {};
+            for (const k of Object.keys(op.patch)) {
+                inversePatch[k] = prev[k];
+            }
+            return { op: 'updateMeasurement', id: op.id, patch: inversePatch };
+        }
+        case 'setViewport': {
+            const inversePatch = {};
+            for (const k of Object.keys(op.patch)) {
+                inversePatch[k] = before.viewport[k];
+            }
+            return { op: 'setViewport', patch: inversePatch };
+        }
+        case 'setLayers':
+            return { op: 'setLayers', layers: before.layers };
+    }
+};

package/dist/types/firestore.d.ts

@@ -1,3 +1,4 @@
+import type { AnnotationCanvasState } from './annotation.js';
 interface FirestoreDoc {
     id: string;
 }
@@ -104,12 +105,12 @@ export declare enum FileUploadType {
     LayoutGroup = "layoutGroup",
     Calculator = "calculator",
     Conversion = "conversion",
-    Note = "note",
-    Label = "label"
+    Note = "note"
 }
 export interface AnnotationFileData {
     fileType: 'sketch' | 'document';
     isLabel?: boolean;
+    canvas?: AnnotationCanvasState;
 }
 export interface CalculatorFileData {
     templateId: string;
@@ -174,9 +175,6 @@ export type FileUpload = FileUploadBase & ({
 } | {
     type: FileUploadType.Template;
     fileData?: undefined;
-} | {
-    type: FileUploadType.Label;
-    fileData: Label;
 });
 export interface Folder extends FirestoreDoc, Timestamps {
     name: string;
@@ -249,8 +247,7 @@ export declare enum ColumnType {
     SingleSelect = "singleSelect",
     MultiSelect = "multiSelect",
     Angle = "angle",
-    ConversionTable = "conversionTable",
-    Instructions = "instructions"
+    ConversionTable = "conversionTable"
 }
 export interface Formula extends FirestoreDoc, Timestamps {
     expression: string;
@@ -272,11 +269,6 @@ export interface SelectColumnData {
 export interface ConversionTableColumnData {
     conversions: Conversion[];
 }
-export interface InstructionsColumnData {
-    text: string;
-    textColor: string;
-    backgroundColor: string;
-}
 interface ColumnConfigBase {
     id: string;
     name: string;
@@ -308,9 +300,6 @@ export type ColumnConfig = ColumnConfigBase & ({
 } | {
     type: ColumnType.Angle;
     columnData?: undefined;
-} | {
-    type: ColumnType.Instructions;
-    columnData: InstructionsColumnData;
 });
 export interface Row {
     [key: string]: any;

package/dist/types/firestore.js

@@ -24,7 +24,6 @@ export var FileUploadType;
     FileUploadType["Calculator"] = "calculator";
     FileUploadType["Conversion"] = "conversion";
     FileUploadType["Note"] = "note";
-    FileUploadType["Label"] = "label";
 })(FileUploadType || (FileUploadType = {}));
 export var GroupType;
 (function (GroupType) {
@@ -42,7 +41,6 @@ export var ColumnType;
     ColumnType["MultiSelect"] = "multiSelect";
     ColumnType["Angle"] = "angle";
     ColumnType["ConversionTable"] = "conversionTable";
-    ColumnType["Instructions"] = "instructions";
 })(ColumnType || (ColumnType = {}));
 export var MeasurementType;
 (function (MeasurementType) {

package/dist/utils/groups.d.ts

@@ -0,0 +1,4 @@
+import type { Group } from '../types/firestore.js';
+export declare const DEFAULT_GROUP_INDEX = 0;
+export declare const isDefaultGroup: (group: Pick<Group, "groupIndex"> | null | undefined) => boolean;
+export declare const findDefaultGroup: <T extends Pick<Group, "groupIndex">>(groups: T[] | null | undefined) => T | null;

package/dist/utils/groups.js

@@ -0,0 +1,3 @@
+export const DEFAULT_GROUP_INDEX = 0;
+export const isDefaultGroup = (group) => group?.groupIndex === DEFAULT_GROUP_INDEX;
+export const findDefaultGroup = (groups) => groups?.find((g) => g.groupIndex === DEFAULT_GROUP_INDEX) ?? null;

package/dist/utils/micrometersToUnit.d.ts

@@ -1,5 +1,4 @@
 import { DecimalTolerance, FractionalTolerance, Units } from '../types/firestore.js';
-export declare const roundToT1Values: (value: number, u: Units) => number;
 export declare const convertMicrometers: (micrometers: number | null | undefined, unit: Units, fractionalTolerance: FractionalTolerance, decimalTolerance: DecimalTolerance) => {
     value: string;
     unit: string;

package/dist/utils/micrometersToUnit.js

@@ -1,35 +1,12 @@
 import { Units, convertUnitsToReadable, } from '../types/firestore.js';
 import { create, all } from 'mathjs';
 const math = create(all);
-// The T1 rounds differently depending on the selected measurement unit.
-// This function mirrors the rounding behavior implemented on the firmware.
-// The value being rounded is in microns.
-export const roundToT1Values = (value, u) => {
-    switch (u) {
-        case Units.Millimeters:
-        case Units.Centimeters:
-            return Math.round(value / 500) * 500;
-        case Units.Meters:
-            return Math.round(value / 1000) * 1000;
-        case Units.Inches:
-            return Math.round(value / 508) * 508;
-        case Units.Feet:
-            return Math.round(value / 304.8) * 304.8;
-        case Units.FeetInchesDecimal:
-            return Math.round(value / 508) * 508;
-        case Units.FractionalInches:
-        case Units.FeetInchesFractional:
-            return value;
-        default:
-            return Math.round(value / 500) * 500;
-    }
-};
 export const convertMicrometers = (micrometers, unit, fractionalTolerance, decimalTolerance) => {
     if (micrometers == null || isNaN(micrometers)) {
         return { value: 'NaN', unit: '' };
     }
     try {
-        const converted = math.unit(roundToT1Values(micrometers, unit), 'um');
+        const converted = math.unit(micrometers, 'um');
         let value = 0;
         let displayUnit = '';
         switch (unit) {

package/dist/utils/tolerance.d.ts

@@ -16,10 +16,6 @@ export declare const DEFAULT_TOLERANCE_COLORS: {
     readonly IN_TOLERANCE: "#22c55e";
     readonly OUT_OF_TOLERANCE: "#ef4444";
 };
-export declare const DEFAULT_TOLERANCE_SECONDARY_COLORS: {
-    readonly IN_TOLERANCE: "#268F0A";
-    readonly OUT_OF_TOLERANCE: "#A91507";
-};
 /**
  * Calculates the appropriate color for a measurement based on tolerance thresholds
  *
@@ -31,17 +27,6 @@ export declare const DEFAULT_TOLERANCE_SECONDARY_COLORS: {
  * @returns The color hex string to use for the measurement
  */
 export declare function getToleranceColor(actualValue: number, target: number, min: number, max: number, toleranceConfig?: ToleranceConfig | null): string;
-/**
- * Calculates the appropriate color for a measurement based on tolerance thresholds
- *
- * @param actualValue - The measured value
- * @param target - The target/nominal value
- * @param min - The minimum acceptable value (used as negative tolerance from target)
- * @param max - The maximum acceptable value (used as positive tolerance from target)
- * @param toleranceConfig - Optional tolerance configuration with custom thresholds
- * @returns The color hex string to use for the measurement
- */
-export declare function getToleranceSecondaryColor(actualValue: number, target: number, min: number, max: number, toleranceConfig?: ToleranceConfig | null): string;
 /**
  * Calculates the deviation percentage of a measurement from its target
  *

package/dist/utils/tolerance.js

@@ -5,10 +5,6 @@ export const DEFAULT_TOLERANCE_COLORS = {
     IN_TOLERANCE: '#22c55e', // Green
     OUT_OF_TOLERANCE: '#ef4444', // Red
 };
-export const DEFAULT_TOLERANCE_SECONDARY_COLORS = {
-    IN_TOLERANCE: '#268F0A', // Green
-    OUT_OF_TOLERANCE: '#A91507', // Red
-};
 /**
  * Calculates the appropriate color for a measurement based on tolerance thresholds
  *
@@ -46,43 +42,6 @@ export function getToleranceColor(actualValue, target, min, max, toleranceConfig
     }
     return applicableColor;
 }
-/**
- * Calculates the appropriate color for a measurement based on tolerance thresholds
- *
- * @param actualValue - The measured value
- * @param target - The target/nominal value
- * @param min - The minimum acceptable value (used as negative tolerance from target)
- * @param max - The maximum acceptable value (used as positive tolerance from target)
- * @param toleranceConfig - Optional tolerance configuration with custom thresholds
- * @returns The color hex string to use for the measurement
- */
-export function getToleranceSecondaryColor(actualValue, target, min, max, toleranceConfig) {
-    // If no tolerance config provided, use simple green/red logic
-    if (!toleranceConfig?.thresholds || toleranceConfig.thresholds.length === 0) {
-        const isWithinTolerance = actualValue >= target - min && actualValue <= target + max;
-        return isWithinTolerance
-            ? DEFAULT_TOLERANCE_SECONDARY_COLORS.IN_TOLERANCE
-            : DEFAULT_TOLERANCE_SECONDARY_COLORS.OUT_OF_TOLERANCE;
-    }
-    // Calculate deviation percentage
-    const deviation = Math.abs(actualValue - target);
-    const toleranceRange = max + min; // Fixed: total tolerance range
-    const deviationPercentage = toleranceRange > 0 ? (deviation / toleranceRange) * 100 : 0;
-    // Sort thresholds by percentage to ensure correct evaluation order
-    const sortedThresholds = toleranceConfig.thresholds.sort((a, b) => a.percentage - b.percentage);
-    // If deviation is below the first threshold, it's in tolerance (green)
-    if (deviationPercentage < sortedThresholds[0].percentage) {
-        return DEFAULT_TOLERANCE_SECONDARY_COLORS.IN_TOLERANCE;
-    }
-    // Find the highest threshold that the deviation exceeds
-    let applicableColor = sortedThresholds[0].color;
-    for (const threshold of sortedThresholds) {
-        if (deviationPercentage >= threshold.percentage) {
-            applicableColor = threshold.color;
-        }
-    }
-    return applicableColor;
-}
 /**
  * Calculates the deviation percentage of a measurement from its target
  *

package/package.json

@@ -1,15 +1,26 @@
 {
   "name": "@reekon-tools/boldr-utils",
-  "version": "1.6.4",
+  "version": "1.6.6",
   "description": "Shared utilities for formulas and measurement conversion used in Reekon apps",
   "author": "REEKON Tools",
   "license": "MIT",
   "type": "module",
+  "sideEffects": false,
   "files": [
     "dist"
   ],
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
+  "react-native": "dist/index.native.js",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "react-native": "./dist/index.native.js",
+      "import": "./dist/index.js",
+      "default": "./dist/index.js"
+    },
+    "./package.json": "./package.json"
+  },
   "scripts": {
     "build": "tsc",
     "test": "vitest",
@@ -25,14 +36,34 @@
     "mathjs": "^11.11.0"
   },
   "peerDependencies": {
-    "react": "^18.0.0"
+    "@shopify/react-native-skia": ">=2.5.0",
+    "react": "^18.0.0 || ^19.0.0",
+    "react-native": ">=0.74.0",
+    "react-native-gesture-handler": ">=2.0.0",
+    "react-native-reanimated": ">=3.0.0"
+  },
+  "peerDependenciesMeta": {
+    "react-native": {
+      "optional": true
+    },
+    "react-native-gesture-handler": {
+      "optional": true
+    },
+    "react-native-reanimated": {
+      "optional": true
+    }
   },
   "devDependencies": {
     "@arethetypeswrong/cli": "^0.18.1",
+    "@shopify/react-native-skia": "^2.6.2",
     "@types/node": "^22.15.18",
     "@types/react": "^19.0.8",
     "@vitest/coverage-v8": "3.1.3",
     "prettier": "^3.5.3",
+    "react": "^19.0.0",
+    "react-native": "0.83.2",
+    "react-native-gesture-handler": "~2.30.0",
+    "react-native-reanimated": "4.2.1",
     "ts-node": "^10.9.2",
     "typescript": "^5.8.3",
     "vitest": "^3.1.3"