@reekon-tools/boldr-utils 1.6.39 → 1.7.1

package/dist/calculator/validate.js

@@ -0,0 +1,370 @@
+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';
+const math = create(all);
+// ---------------------------------------------------------------------------
+// Definition validation: zod for structure, plus the cross-field invariants
+// zod can't express (reference resolution, cycles, solve wiring). Callable
+// from the authoring UI, the runtime, and (later) a server-side publish
+// function — keep it platform-neutral.
+// ---------------------------------------------------------------------------
+const calculatorUnitSchema = z
+    .string()
+    .refine((u) => u in CALCULATOR_UNIT_INFO, { message: 'Unknown unit' });
+const solveHintsSchema = z.object({
+    solvable: z.boolean(),
+    governingEquationId: z.string().optional(),
+    min: z.number().finite().optional(),
+    max: z.number().finite().optional(),
+    guess: z.number().finite().optional(),
+});
+const fieldUnitConfigSchema = z.object({
+    dimension: z.enum(['length', 'area', 'volume']),
+    defaultUnit: calculatorUnitSchema,
+    allowedUnits: z.array(calculatorUnitSchema).min(1),
+    fractionalTolerance: z.enum(FractionalTolerance).optional(),
+    decimalTolerance: z.enum(DecimalTolerance).optional(),
+});
+const fieldBase = {
+    id: z.string().min(1),
+    name: z.string(),
+    role: z.enum(['input', 'output']),
+    description: z.string().optional(),
+    binding: z.object({ hotspotId: z.string().min(1) }).optional(),
+};
+const selectColumnDataSchema = z.object({ options: z.array(z.string()) });
+const conversionTableColumnDataSchema = z.object({
+    conversions: z.array(z.object({ label: z.string(), value: z.string() })),
+});
+const instructionsColumnDataSchema = z.object({
+    text: z.string(),
+    textColor: z.string(),
+    backgroundColor: z.string(),
+});
+const calculatorFieldSchema = z.discriminatedUnion('kind', [
+    z.object({
+        ...fieldBase,
+        kind: z.literal(ColumnType.Number),
+        defaultValue: z.number().optional(),
+        solve: solveHintsSchema.optional(),
+    }),
+    z.object({
+        ...fieldBase,
+        kind: z.literal(ColumnType.Measurement),
+        unit: fieldUnitConfigSchema,
+        defaultValue: z.number().optional(),
+        solve: solveHintsSchema.optional(),
+    }),
+    z.object({
+        ...fieldBase,
+        kind: z.literal(ColumnType.Angle),
+        angleUnit: z.enum(['deg', 'rad']).optional(),
+        defaultValue: z.number().optional(),
+        solve: solveHintsSchema.optional(),
+    }),
+    z.object({
+        ...fieldBase,
+        kind: z.literal(ColumnType.SingleSelect),
+        columnData: selectColumnDataSchema,
+        defaultValue: z.string().optional(),
+    }),
+    z.object({
+        ...fieldBase,
+        kind: z.literal(ColumnType.MultiSelect),
+        columnData: selectColumnDataSchema,
+        defaultValue: z.array(z.string()).optional(),
+    }),
+    z.object({
+        ...fieldBase,
+        kind: z.literal(ColumnType.ConversionTable),
+        columnData: conversionTableColumnDataSchema,
+        defaultValue: z.string().optional(),
+    }),
+    z.object({
+        ...fieldBase,
+        kind: z.literal(ColumnType.Instructions),
+        columnData: instructionsColumnDataSchema,
+    }),
+]);
+const calculatorEquationSchema = z.object({
+    id: z.string().min(1),
+    targetFieldId: z.string().min(1),
+    expression: z.string().min(1),
+    variableToFieldId: z.record(z.string(), z.string()),
+});
+export const calculatorDefinitionSchema = z.object({
+    id: z.string().min(1),
+    schemaVersion: z.number().int(),
+    version: z.number().int(),
+    name: z.string(),
+    description: z.string(),
+    folderId: z.string().nullable(),
+    fields: z.array(calculatorFieldSchema),
+    equations: z.array(calculatorEquationSchema),
+    diagramFileId: z.string().nullable().optional(),
+    isPublic: z.boolean(),
+    sharedUserIds: z.array(z.string()).optional(),
+    sharedOrgIds: z.array(z.string()).optional(),
+    createdBy: z
+        .object({
+        userId: z.string(),
+        firstName: z.string().optional(),
+        lastName: z.string().optional(),
+    })
+        .optional(),
+    // Firestore Timestamps / Dates — shape-checked upstream, not here.
+    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),
+        };
+    }
+};
+// 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.)
+const equationReaches = (definition, equation, fieldId, seen = new Set()) => {
+    if (seen.has(equation.id))
+        return false;
+    seen.add(equation.id);
+    for (const mappedId of Object.values(equation.variableToFieldId)) {
+        if (mappedId === fieldId)
+            return true;
+        const sub = equationForField(definition, mappedId);
+        if (sub && equationReaches(definition, sub, fieldId, seen))
+            return true;
+    }
+    return false;
+};
+export const validateCalculatorDefinition = (input) => {
+    const issues = [];
+    const push = (code, path, message, severity = 'error') => issues.push({ code, path, message, severity });
+    const parsed = calculatorDefinitionSchema.safeParse(input);
+    if (!parsed.success) {
+        for (const issue of parsed.error.issues) {
+            push('structure', issue.path.join('.'), issue.message);
+        }
+        return { ok: false, issues };
+    }
+    const def = parsed.data;
+    if (def.schemaVersion > CALCULATOR_SCHEMA_VERSION) {
+        push('schema-version-unsupported', 'schemaVersion', `schemaVersion ${def.schemaVersion} is newer than this client supports (${CALCULATOR_SCHEMA_VERSION})`);
+    }
+    // --- Unique ids ---------------------------------------------------------
+    const fieldIds = new Set();
+    def.fields.forEach((field, i) => {
+        if (fieldIds.has(field.id)) {
+            push('duplicate-field-id', `fields.${i}.id`, `Duplicate field id "${field.id}"`);
+        }
+        fieldIds.add(field.id);
+    });
+    const equationIds = new Set();
+    def.equations.forEach((eq, i) => {
+        if (equationIds.has(eq.id)) {
+            push('duplicate-equation-id', `equations.${i}.id`, `Duplicate equation id "${eq.id}"`);
+        }
+        equationIds.add(eq.id);
+    });
+    const fieldById = new Map(def.fields.map((f) => [f.id, f]));
+    // --- Per-field integrity --------------------------------------------------
+    def.fields.forEach((field, i) => {
+        const path = `fields.${i}`;
+        if (field.kind === ColumnType.Measurement) {
+            const { dimension, defaultUnit, allowedUnits } = field.unit;
+            if (unitDimension(defaultUnit) !== dimension) {
+                push('unit-dimension-mismatch', `${path}.unit.defaultUnit`, `Default unit "${defaultUnit}" is not a ${dimension} unit`);
+            }
+            allowedUnits.forEach((u, j) => {
+                if (unitDimension(u) !== dimension) {
+                    push('unit-dimension-mismatch', `${path}.unit.allowedUnits.${j}`, `Unit "${u}" is not a ${dimension} unit`);
+                }
+            });
+            if (!allowedUnits.includes(defaultUnit)) {
+                push('default-unit-not-allowed', `${path}.unit.defaultUnit`, `Default unit "${defaultUnit}" is not in allowedUnits`);
+            }
+        }
+        if (field.kind === ColumnType.SingleSelect ||
+            field.kind === ColumnType.MultiSelect) {
+            if (field.columnData.options.length === 0) {
+                push('empty-options', `${path}.columnData.options`, 'Select field has no options');
+            }
+            const dupes = field.columnData.options.filter((o, j) => field.columnData.options.indexOf(o) !== j);
+            if (dupes.length > 0) {
+                push('duplicate-options', `${path}.columnData.options`, `Duplicate options: ${[...new Set(dupes)].join(', ')}`, 'warning');
+            }
+            const defaults = field.kind === ColumnType.MultiSelect
+                ? (field.defaultValue ?? [])
+                : field.defaultValue != null
+                    ? [field.defaultValue]
+                    : [];
+            for (const d of defaults) {
+                if (!field.columnData.options.includes(d)) {
+                    push('default-not-an-option', `${path}.defaultValue`, `Default "${d}" is not one of the options`);
+                }
+            }
+        }
+        if (field.kind === ColumnType.ConversionTable) {
+            const { conversions } = field.columnData;
+            if (conversions.length === 0) {
+                push('empty-conversions', `${path}.columnData.conversions`, 'Conversion table is empty');
+            }
+            conversions.forEach((c, j) => {
+                if (!Number.isFinite(parseFloat(c.value))) {
+                    push('conversion-value-not-numeric', `${path}.columnData.conversions.${j}.value`, `Conversion "${c.label}" has non-numeric value "${c.value}"`);
+                }
+            });
+            const labels = conversions.map((c) => c.label);
+            if (new Set(labels).size !== labels.length) {
+                push('duplicate-conversion-labels', `${path}.columnData.conversions`, 'Conversion labels must be unique');
+            }
+            if (field.defaultValue != null && !labels.includes(field.defaultValue)) {
+                push('default-not-an-option', `${path}.defaultValue`, `Default "${field.defaultValue}" is not a conversion label`);
+            }
+        }
+    });
+    // --- Equations -----------------------------------------------------------
+    const targetCounts = new Map();
+    def.equations.forEach((eq) => {
+        targetCounts.set(eq.targetFieldId, (targetCounts.get(eq.targetFieldId) ?? 0) + 1);
+    });
+    def.equations.forEach((eq, i) => {
+        const path = `equations.${i}`;
+        const target = fieldById.get(eq.targetFieldId);
+        if (!target) {
+            push('unknown-target-field', `${path}.targetFieldId`, `Equation targets unknown field "${eq.targetFieldId}"`);
+        }
+        else if (!isEquationTargetKind(target.kind)) {
+            push('invalid-target-kind', `${path}.targetFieldId`, `Equation target "${target.name}" must be a number, measurement, or angle field`);
+        }
+        if ((targetCounts.get(eq.targetFieldId) ?? 0) > 1) {
+            push('multiple-equations-for-field', `${path}.targetFieldId`, `Field "${eq.targetFieldId}" is computed by more than one equation`);
+        }
+        for (const [variable, fieldId] of Object.entries(eq.variableToFieldId)) {
+            const mapped = fieldById.get(fieldId);
+            if (!mapped) {
+                push('unknown-mapped-field', `${path}.variableToFieldId.${variable}`, `Variable ${variable} maps to unknown field "${fieldId}"`);
+            }
+            else if (!isNumericFieldKind(mapped.kind)) {
+                push('non-numeric-mapped-field', `${path}.variableToFieldId.${variable}`, `Variable ${variable} maps to "${mapped.name}", which has no numeric value`);
+            }
+            if (fieldId === eq.targetFieldId) {
+                push('self-referencing-equation', `${path}.variableToFieldId.${variable}`, `Equation for "${eq.targetFieldId}" references its own target`);
+            }
+        }
+        const symbols = expressionSymbols(eq.expression);
+        if (!symbols.ok) {
+            push('expression-invalid', `${path}.expression`, `Expression does not parse: ${symbols.error}`);
+        }
+        else {
+            const mappedVars = new Set(Object.keys(eq.variableToFieldId));
+            for (const s of symbols.symbols) {
+                if (!mappedVars.has(s)) {
+                    push('unmapped-symbol', `${path}.expression`, `Expression uses "${s}" but no variable mapping defines it`);
+                }
+            }
+            for (const v of mappedVars) {
+                if (!symbols.symbols.includes(v)) {
+                    push('unused-variable', `${path}.variableToFieldId.${v}`, `Variable ${v} is mapped but never used in the expression`, 'warning');
+                }
+            }
+        }
+    });
+    // --- Cycles across equations ----------------------------------------------
+    const eqByTarget = new Map(def.equations.map((e) => [e.targetFieldId, e]));
+    const visiting = new Set();
+    const done = new Set();
+    const hasCycle = (eq) => {
+        if (done.has(eq.id))
+            return false;
+        if (visiting.has(eq.id))
+            return true;
+        visiting.add(eq.id);
+        for (const fieldId of Object.values(eq.variableToFieldId)) {
+            const sub = eqByTarget.get(fieldId);
+            if (sub && hasCycle(sub))
+                return true;
+        }
+        visiting.delete(eq.id);
+        done.add(eq.id);
+        return false;
+    };
+    def.equations.forEach((eq, i) => {
+        if (!done.has(eq.id) && hasCycle(eq)) {
+            push('circular-equations', `equations.${i}`, `Equation "${eq.id}" participates in a circular dependency`);
+            visiting.clear();
+        }
+    });
+    // --- Solve wiring -----------------------------------------------------------
+    def.fields.forEach((field, i) => {
+        if ((field.kind === ColumnType.Number ||
+            field.kind === ColumnType.Measurement ||
+            field.kind === ColumnType.Angle) &&
+            field.solve?.solvable) {
+            const path = `fields.${i}.solve`;
+            const { governingEquationId, min, max } = field.solve;
+            if (!governingEquationId) {
+                push('solvable-without-equation', `${path}.governingEquationId`, `Solvable field "${field.name}" has no governing equation`);
+            }
+            else {
+                const eq = def.equations.find((e) => e.id === governingEquationId);
+                if (!eq) {
+                    push('unknown-governing-equation', `${path}.governingEquationId`, `Governing equation "${governingEquationId}" does not exist`);
+                }
+                else if (!equationReaches(def, eq, field.id)) {
+                    push('equation-does-not-reference-field', `${path}.governingEquationId`, `Equation "${governingEquationId}" never references "${field.name}", so it cannot be solved for it`);
+                }
+            }
+            if (min != null && max != null && min >= max) {
+                push('invalid-bracket', `${path}.min`, 'Bracket min must be below max');
+            }
+        }
+    });
+    // --- Diagram binding integrity ----------------------------------------------
+    const hotspotIds = new Set();
+    def.fields.forEach((field, i) => {
+        if (field.binding) {
+            if (hotspotIds.has(field.binding.hotspotId)) {
+                push('duplicate-hotspot', `fields.${i}.binding.hotspotId`, `Hotspot "${field.binding.hotspotId}" is bound to more than one field`);
+            }
+            hotspotIds.add(field.binding.hotspotId);
+        }
+    });
+    return { ok: !issues.some((i) => i.severity === 'error'), issues };
+};

package/dist/exports.d.ts

@@ -10,7 +10,8 @@ export { getToleranceColor, calculateDeviationPercentage, isWithinTolerance, gen
 export { DEFAULT_GROUP_INDEX, isDefaultGroup, findDefaultGroup, } from './utils/groups.js';
 export { numberToLetterIndex, formGroupInputLabel, listGroupMeasurementLabel, } from './utils/indexLabels.js';
 export { toSelectedValues, formatSelectedValues, toStoredValue, } from './utils/selectValues.js';
-export { annotationScopeKey, isFieldOp, isTemplateScope, type AnnotationDataProvider, type AnnotationFile, type AnnotationFilePatch, type AnnotationFileSummary, type AnnotationScope, type FieldOp, type ImageBlob, type JobGroupScope, type JobScope, type Patch, type TemplateScope, type Unsubscribe, type UploadedImageRef, } from './annotation/data/AnnotationDataProvider.js';
+export * from './calculator/index.js';
+export { annotationScopeKey, isFieldOp, isTemplateScope, isCalculatorScope, type AnnotationDataProvider, type AnnotationFile, type AnnotationFilePatch, type AnnotationFileSummary, type AnnotationScope, type CalculatorScope, type FieldOp, type ImageBlob, type JobGroupScope, type JobScope, type Patch, type TemplateScope, type Unsubscribe, type UploadedImageRef, } from './annotation/data/AnnotationDataProvider.js';
 export { AnnotationDataProviderContext, useAnnotationData, type AnnotationDataProviderProps, } from './annotation/data/AnnotationDataContext.js';
 export { useAnnotationDoc, type UseAnnotationDocResult, } from './annotation/data/hooks/useAnnotationDoc.js';
 export { useAnnotationList, type UseAnnotationListResult, } from './annotation/data/hooks/useAnnotationList.js';

package/dist/exports.js

@@ -14,8 +14,11 @@ export { getToleranceColor, calculateDeviationPercentage, isWithinTolerance, gen
 export { DEFAULT_GROUP_INDEX, isDefaultGroup, findDefaultGroup, } from './utils/groups.js';
 export { numberToLetterIndex, formGroupInputLabel, listGroupMeasurementLabel, } from './utils/indexLabels.js';
 export { toSelectedValues, formatSelectedValues, toStoredValue, } from './utils/selectValues.js';
+// Construction Calculator shared module (schema, units, evaluator, solver,
+// validation).
+export * from './calculator/index.js';
 // Annotation data layer (SDK-neutral; apps provide their own provider).
-export { annotationScopeKey, isFieldOp, isTemplateScope, } from './annotation/data/AnnotationDataProvider.js';
+export { annotationScopeKey, isFieldOp, isTemplateScope, isCalculatorScope, } from './annotation/data/AnnotationDataProvider.js';
 export { AnnotationDataProviderContext, useAnnotationData, } from './annotation/data/AnnotationDataContext.js';
 export { useAnnotationDoc, } from './annotation/data/hooks/useAnnotationDoc.js';
 export { useAnnotationList, } from './annotation/data/hooks/useAnnotationList.js';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@reekon-tools/boldr-utils",
-  "version": "1.6.39",
+  "version": "1.7.1",
   "description": "Shared utilities for formulas and measurement conversion used in Reekon apps",
   "author": "REEKON Tools",
   "license": "MIT",
@@ -35,7 +35,8 @@
   "keywords": [],
   "repository": "https://gitlab.com/reekon-tools/software/rock-pro/boldr-utils#",
   "dependencies": {
-    "mathjs": "^11.11.0"
+    "mathjs": "^11.11.0",
+    "zod": "^4.4.3"
   },
   "peerDependencies": {
     "@shopify/react-native-skia": ">=2.5.0",

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;