@reekon-tools/boldr-utils 1.6.39 → 1.7.0

package/dist/calculator/schema.d.ts

@@ -0,0 +1,163 @@
+import { ColumnType, type ColumnConfig, type ConversionTableColumnData, type InstructionsColumnData, type SelectColumnData, type DecimalTolerance, type FractionalTolerance } from '../types/firestore.js';
+import type { AngleUnit, CalculatorUnit, FieldDimension, MeasurementDimension } from './units.js';
+/**
+ * Version of the definition format itself. Bumped only on breaking schema
+ * changes; independent of the npm package version and of each calculator's
+ * own content `version`.
+ */
+export declare const CALCULATOR_SCHEMA_VERSION = 1;
+/**
+ * Which table a field appears in (the Figma mockup's Input Fields / Output
+ * Fields split). Mostly cosmetic: an input with solve hints can be computed
+ * from outputs at runtime, and outputs are just fields targeted by equations.
+ */
+export type FieldRole = 'input' | 'output';
+/** Field kinds reuse the app-wide ColumnType enum (calculator subset). */
+export type CalculatorFieldKind = ColumnType.Number | ColumnType.Measurement | ColumnType.Angle | ColumnType.SingleSelect | ColumnType.MultiSelect | ColumnType.ConversionTable | ColumnType.Instructions;
+export declare const CALCULATOR_FIELD_KINDS: CalculatorFieldKind[];
+/**
+ * Per-field unit configuration (templates have only a global user unit).
+ * `dimension` covers the volume-calculator case: inputs in inches, output in
+ * cubic feet — each field picks its own dimension and display units.
+ */
+export interface FieldUnitConfig {
+    dimension: MeasurementDimension;
+    /** Default display unit; must belong to `dimension`. */
+    defaultUnit: CalculatorUnit;
+    /** Units the runtime lets the user toggle between; must match `dimension`. */
+    allowedUnits: CalculatorUnit[];
+    fractionalTolerance?: FractionalTolerance;
+    decimalTolerance?: DecimalTolerance;
+}
+/**
+ * The schema half of two-way solving. A solvable field can be computed by
+ * numerically inverting its governing equation when the user supplies that
+ * equation's output value instead (see solve.ts). `min`/`max` bracket the
+ * root search in CANONICAL units; when absent the solver falls back to
+ * generous per-dimension defaults, so brackets are only needed to isolate a
+ * specific root (e.g. the positive branch of a quadratic) or to speed search.
+ */
+export interface SolveHints {
+    solvable: boolean;
+    /** The ONE equation numerically inverted for this field. */
+    governingEquationId?: string;
+    min?: number;
+    max?: number;
+    /** Optional Newton seed (canonical units). */
+    guess?: number;
+}
+/**
+ * Binds a field to a diagram hotspot. `hotspotId` is the id of the placed
+ * canvas tile — the tile itself carries the reverse link by storing the field
+ * id in `PlacedMeasurementRef.columnId` (the existing template-canvas
+ * column-anchor channel, reused with field-id semantics).
+ */
+export interface DiagramBinding {
+    hotspotId: string;
+}
+interface CalculatorFieldBase {
+    id: string;
+    name: string;
+    role: FieldRole;
+    description?: string;
+    binding?: DiagramBinding;
+}
+export type CalculatorField = CalculatorFieldBase & ({
+    kind: ColumnType.Number;
+    defaultValue?: number;
+    solve?: SolveHints;
+} | {
+    kind: ColumnType.Measurement;
+    unit: FieldUnitConfig;
+    /** Canonical (µm / µm² / µm³ per unit.dimension). */
+    defaultValue?: number;
+    solve?: SolveHints;
+} | {
+    kind: ColumnType.Angle;
+    /** Display unit; canonical storage is always degrees. */
+    angleUnit?: AngleUnit;
+    defaultValue?: number;
+    solve?: SolveHints;
+} | {
+    kind: ColumnType.SingleSelect;
+    columnData: SelectColumnData;
+    defaultValue?: string;
+} | {
+    kind: ColumnType.MultiSelect;
+    columnData: SelectColumnData;
+    defaultValue?: string[];
+} | {
+    kind: ColumnType.ConversionTable;
+    columnData: ConversionTableColumnData;
+    /** The selected conversion's label. */
+    defaultValue?: string;
+} | {
+    kind: ColumnType.Instructions;
+    columnData: InstructionsColumnData;
+});
+/**
+ * A forward equation computing one output field. Mirrors the existing
+ * `Formula` shape (`expression` + variable map), but variables bind to field
+ * ids and the equation lives inside the definition rather than in the org
+ * `formulas` collection. Variables may reference other OUTPUT fields — their
+ * equations are evaluated recursively (cycles are rejected by validation).
+ */
+export interface CalculatorEquation {
+    id: string;
+    /** The output field this equation computes. */
+    targetFieldId: string;
+    /** math.js forward expression, e.g. 'A * B * C'. */
+    expression: string;
+    /** Variable letter -> field id. */
+    variableToFieldId: Record<string, string>;
+}
+/** A runtime/preview value for one field, in canonical units. */
+export type CalculatorFieldValue = number | string | string[] | null;
+export type CalculatorValues = Record<string, CalculatorFieldValue>;
+export interface CalculatorDefinition {
+    id: string;
+    /** CALCULATOR_SCHEMA_VERSION captured at author time. */
+    schemaVersion: number;
+    /** Monotonic content revision; bumped on publish. Offline-cache key with updatedAt. */
+    version: number;
+    name: string;
+    description: string;
+    folderId: string | null;
+    /** Inputs + outputs in one list, discriminated by `role`. */
+    fields: CalculatorField[];
+    equations: CalculatorEquation[];
+    /** Diagram file (files subcollection doc carrying the Skia canvas). */
+    diagramFileId?: string | null;
+    /** Public calculators are readable by everyone; rules/query key. */
+    isPublic: boolean;
+    sharedUserIds?: string[];
+    sharedOrgIds?: string[];
+    createdBy?: {
+        userId: string;
+        firstName?: string;
+        lastName?: string;
+    };
+    createdAt?: Date;
+    updatedAt?: Date;
+}
+export declare const fieldsByRole: (definition: Pick<CalculatorDefinition, "fields">, role: FieldRole) => CalculatorField[];
+export declare const findField: (definition: Pick<CalculatorDefinition, "fields">, fieldId: string) => CalculatorField | undefined;
+export declare const findEquation: (definition: Pick<CalculatorDefinition, "equations">, equationId: string) => CalculatorEquation | undefined;
+/** The equation targeting an output field, if any. */
+export declare const equationForField: (definition: Pick<CalculatorDefinition, "equations">, fieldId: string) => CalculatorEquation | undefined;
+/** The dimension a field's numeric value carries. */
+export declare const fieldDimension: (field: CalculatorField) => FieldDimension;
+/** Fields whose value participates in equations as a number. */
+export declare const isNumericFieldKind: (kind: CalculatorFieldKind) => kind is ColumnType.Number | ColumnType.Measurement | ColumnType.Angle | ColumnType.ConversionTable;
+/** Field kinds an equation may target (compute into). */
+export declare const isEquationTargetKind: (kind: CalculatorFieldKind) => kind is ColumnType.Number | ColumnType.Measurement | ColumnType.Angle;
+/**
+ * Synthesize a ColumnConfig for a field so the existing table/tile components
+ * (built around ColumnConfig) can render calculator fields unchanged.
+ */
+export declare const fieldToColumnConfig: (field: CalculatorField) => ColumnConfig;
+/** Default per-field unit config for a fresh measurement field. */
+export declare const defaultFieldUnitConfig: (dimension?: MeasurementDimension) => FieldUnitConfig;
+/** Seed for the create-new-calculator stub doc (mirrors the template flow). */
+export declare const createEmptyCalculatorDefinition: (id: string) => Omit<CalculatorDefinition, "createdAt" | "updatedAt" | "createdBy">;
+export {};

package/dist/calculator/schema.js

@@ -0,0 +1,129 @@
+import { ColumnType, Units, } from '../types/firestore.js';
+import { unitsForDimension } from './units.js';
+// ---------------------------------------------------------------------------
+// The Construction Calculator definition — the shared artifact the web
+// authoring tool produces, the mobile runtime interprets, and sync ships.
+//
+// Distinct from the loosely-typed Template/ColumnConfig model, but reuses its
+// vocabulary where it fits: field kinds ARE ColumnType values (subset) and the
+// per-kind payloads reuse the existing column-data shapes, so the table UI
+// and the runtime tiles can share components with templates.
+//
+// CANONICAL VALUES: every numeric value in a definition (defaultValue, solve
+// brackets) and every runtime field value is canonical — µm for length, µm²
+// area, µm³ volume, degrees for angle, raw for dimensionless (see units.ts).
+//
+// EXPRESSION SEMANTICS: equations are math.js expressions evaluated over a
+// canonical scope. Numeric literals inside an expression are therefore
+// canonical too (a bare `2` multiplying a length is a plain scalar; a bare
+// additive length constant would be micrometers). Authors should express
+// length constants as input fields with a defaultValue instead of literals.
+// ---------------------------------------------------------------------------
+/**
+ * Version of the definition format itself. Bumped only on breaking schema
+ * changes; independent of the npm package version and of each calculator's
+ * own content `version`.
+ */
+export const CALCULATOR_SCHEMA_VERSION = 1;
+export const CALCULATOR_FIELD_KINDS = [
+    ColumnType.Number,
+    ColumnType.Measurement,
+    ColumnType.Angle,
+    ColumnType.SingleSelect,
+    ColumnType.MultiSelect,
+    ColumnType.ConversionTable,
+    ColumnType.Instructions,
+];
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+export const fieldsByRole = (definition, role) => definition.fields.filter((f) => f.role === role);
+export const findField = (definition, fieldId) => definition.fields.find((f) => f.id === fieldId);
+export const findEquation = (definition, equationId) => definition.equations.find((e) => e.id === equationId);
+/** The equation targeting an output field, if any. */
+export const equationForField = (definition, fieldId) => definition.equations.find((e) => e.targetFieldId === fieldId);
+/** The dimension a field's numeric value carries. */
+export const fieldDimension = (field) => {
+    switch (field.kind) {
+        case ColumnType.Measurement:
+            return field.unit.dimension;
+        case ColumnType.Angle:
+            return 'angle';
+        default:
+            return 'none';
+    }
+};
+/** Fields whose value participates in equations as a number. */
+export const isNumericFieldKind = (kind) => kind === ColumnType.Number ||
+    kind === ColumnType.Measurement ||
+    kind === ColumnType.Angle ||
+    kind === ColumnType.ConversionTable;
+/** Field kinds an equation may target (compute into). */
+export const isEquationTargetKind = (kind) => kind === ColumnType.Number ||
+    kind === ColumnType.Measurement ||
+    kind === ColumnType.Angle;
+/**
+ * Synthesize a ColumnConfig for a field so the existing table/tile components
+ * (built around ColumnConfig) can render calculator fields unchanged.
+ */
+export const fieldToColumnConfig = (field) => {
+    switch (field.kind) {
+        case ColumnType.SingleSelect:
+            return {
+                id: field.id,
+                name: field.name,
+                type: ColumnType.SingleSelect,
+                columnData: field.columnData,
+            };
+        case ColumnType.MultiSelect:
+            return {
+                id: field.id,
+                name: field.name,
+                type: ColumnType.MultiSelect,
+                columnData: field.columnData,
+            };
+        case ColumnType.ConversionTable:
+            return {
+                id: field.id,
+                name: field.name,
+                type: ColumnType.ConversionTable,
+                columnData: field.columnData,
+            };
+        case ColumnType.Instructions:
+            return {
+                id: field.id,
+                name: field.name,
+                type: ColumnType.Instructions,
+                columnData: field.columnData,
+            };
+        case ColumnType.Number:
+            return { id: field.id, name: field.name, type: ColumnType.Number };
+        case ColumnType.Angle:
+            return { id: field.id, name: field.name, type: ColumnType.Angle };
+        case ColumnType.Measurement:
+            return { id: field.id, name: field.name, type: ColumnType.Measurement };
+    }
+};
+/** Default per-field unit config for a fresh measurement field. */
+export const defaultFieldUnitConfig = (dimension = 'length') => ({
+    dimension,
+    defaultUnit: dimension === 'length'
+        ? Units.FractionalInches
+        : dimension === 'area'
+            ? 'sq_ft'
+            : 'cu_ft',
+    allowedUnits: unitsForDimension(dimension),
+});
+/** Seed for the create-new-calculator stub doc (mirrors the template flow). */
+export const createEmptyCalculatorDefinition = (id) => ({
+    id,
+    schemaVersion: CALCULATOR_SCHEMA_VERSION,
+    version: 0,
+    name: '',
+    description: '',
+    folderId: null,
+    fields: [],
+    equations: [],
+    diagramFileId: null,
+    isPublic: false,
+});

package/dist/calculator/solve.d.ts

@@ -0,0 +1,46 @@
+import type { CalculatorDefinition, CalculatorValues } from './schema.js';
+export type SolveFailure = {
+    kind: 'unknown-field';
+} | {
+    kind: 'not-solvable';
+} | {
+    kind: 'no-governing-equation';
+} | {
+    kind: 'missing-target';
+    targetFieldId: string;
+} | {
+    kind: 'missing-inputs';
+    missingFieldIds: string[];
+} | {
+    kind: 'invalid-bracket';
+} | {
+    kind: 'no-sign-change';
+} | {
+    kind: 'eval-error';
+    error: string;
+} | {
+    kind: 'non-convergent';
+};
+export type SolveResult = {
+    ok: true;
+    value: number;
+} | {
+    ok: false;
+    failure: SolveFailure;
+};
+export interface SolveOptions {
+    maxIter?: number;
+    /** Points probed when the bracket endpoints don't straddle a root. */
+    scanSamples?: number;
+}
+/**
+ * Numerically solve a solvable field from its governing equation, given the
+ * equation's output value (and every other referenced value) in `values`.
+ */
+export declare const solveForField: ({ definition, fieldId, values, options, }: {
+    definition: Pick<CalculatorDefinition, "fields" | "equations">;
+    fieldId: string;
+    /** Canonical values; must include the governing equation's target value. */
+    values: CalculatorValues;
+    options?: SolveOptions;
+}) => SolveResult;

package/dist/calculator/solve.js

@@ -0,0 +1,227 @@
+import { ColumnType } from '../types/firestore.js';
+import { fieldDimension, findEquation, findField } from './schema.js';
+import { evaluateEquation, numericFieldValue } from './evaluate.js';
+// Generous: the alternating secant/bisection worst case over the widest
+// default bracket (volume, [0, 1e30]) needs ~170 halvings-equivalent.
+const DEFAULT_MAX_ITER = 256;
+const DEFAULT_SCAN_SAMPLES = 128;
+// Generous per-dimension fallback brackets so common monotonic equations
+// solve with zero authoring effort; author hints exist to isolate a specific
+// root, not as a prerequisite. Lengths/areas/volumes are non-negative (which
+// also picks the physical branch of even-power equations).
+const DEFAULT_BRACKETS = {
+    length: [0, 1e10], // 10 km in µm
+    area: [0, 1e20],
+    volume: [0, 1e30],
+    angle: [-360, 360],
+    none: [-1e12, 1e12],
+};
+// Convergence: bracket width below the dimension's absolute floor or a
+// relative epsilon of the estimate, whichever is larger.
+const ABS_TOL = {
+    length: 1e-3, // 1 nm — far below any display tolerance
+    area: 1e-3,
+    volume: 1e-3,
+    angle: 1e-9,
+    none: 1e-12,
+};
+const REL_TOL = 1e-12;
+/**
+ * Numerically solve a solvable field from its governing equation, given the
+ * equation's output value (and every other referenced value) in `values`.
+ */
+export const solveForField = ({ definition, fieldId, values, options, }) => {
+    const field = findField(definition, fieldId);
+    if (!field)
+        return { ok: false, failure: { kind: 'unknown-field' } };
+    if (field.kind !== ColumnType.Number &&
+        field.kind !== ColumnType.Measurement &&
+        field.kind !== ColumnType.Angle) {
+        return { ok: false, failure: { kind: 'not-solvable' } };
+    }
+    const hints = field.solve;
+    if (!hints?.solvable) {
+        return { ok: false, failure: { kind: 'not-solvable' } };
+    }
+    const equation = hints.governingEquationId
+        ? findEquation(definition, hints.governingEquationId)
+        : undefined;
+    if (!equation) {
+        return { ok: false, failure: { kind: 'no-governing-equation' } };
+    }
+    const targetField = findField(definition, equation.targetFieldId);
+    const targetValue = targetField
+        ? numericFieldValue(targetField, values[equation.targetFieldId])
+        : null;
+    if (targetValue == null) {
+        return {
+            ok: false,
+            failure: {
+                kind: 'missing-target',
+                targetFieldId: equation.targetFieldId,
+            },
+        };
+    }
+    // g(x) — forward value with the unknown pinned to x, minus the target.
+    // Returns null at points where the expression is undefined (e.g. a
+    // division by zero at x = 0); the search skips such points.
+    let lastError = null;
+    const g = (x) => {
+        const result = evaluateEquation({
+            definition,
+            equation,
+            values: { ...values, [fieldId]: x },
+        });
+        if (result.ok)
+            return result.value - targetValue;
+        if (result.reason === 'missing-inputs') {
+            // Missing something other than the unknown — not point-dependent, bail.
+            throw {
+                solveFailure: {
+                    kind: 'missing-inputs',
+                    missingFieldIds: result.missingFieldIds.filter((id) => id !== fieldId),
+                },
+            };
+        }
+        lastError = result.error;
+        return null;
+    };
+    const dimension = fieldDimension(field);
+    const [defaultLo, defaultHi] = DEFAULT_BRACKETS[dimension];
+    const lo0 = hints.min ?? defaultLo;
+    const hi0 = hints.max ?? defaultHi;
+    if (!Number.isFinite(lo0) || !Number.isFinite(hi0) || lo0 >= hi0) {
+        return { ok: false, failure: { kind: 'invalid-bracket' } };
+    }
+    const residualTol = Math.max(1e-9, Math.abs(targetValue) * 1e-9);
+    const absTol = ABS_TOL[dimension];
+    const converged = (lo, hi) => hi - lo <= Math.max(absTol, REL_TOL * Math.max(Math.abs(lo), Math.abs(hi)));
+    try {
+        // --- Find a sign-change bracket -------------------------------------
+        let lo = lo0;
+        let hi = hi0;
+        let gLo = g(lo);
+        let gHi = g(hi);
+        if (gLo != null && Math.abs(gLo) <= residualTol) {
+            return { ok: true, value: lo };
+        }
+        if (gHi != null && Math.abs(gHi) <= residualTol) {
+            return { ok: true, value: hi };
+        }
+        const straddles = (a, b) => a != null && b != null && Math.sign(a) !== Math.sign(b);
+        if (!straddles(gLo, gHi)) {
+            // Probe interior points (also around the Newton seed, if given) for an
+            // adjacent evaluable pair with opposite signs.
+            const samples = options?.scanSamples ?? DEFAULT_SCAN_SAMPLES;
+            let found = false;
+            let prevX = lo;
+            let prevG = gLo;
+            for (let i = 1; i <= samples; i++) {
+                const x = i === samples ? hi : lo0 + ((hi0 - lo0) * i) / samples;
+                const gx = g(x);
+                if (gx != null && Math.abs(gx) <= residualTol) {
+                    return { ok: true, value: x };
+                }
+                if (straddles(prevG, gx)) {
+                    lo = prevX;
+                    hi = x;
+                    gLo = prevG;
+                    gHi = gx;
+                    found = true;
+                    break;
+                }
+                if (gx != null) {
+                    prevX = x;
+                    prevG = gx;
+                }
+            }
+            if (!found) {
+                return lastError != null && gLo == null && gHi == null
+                    ? { ok: false, failure: { kind: 'eval-error', error: lastError } }
+                    : { ok: false, failure: { kind: 'no-sign-change' } };
+            }
+        }
+        // --- Root refinement: secant (regula falsi) fast-path guarded by ------
+        // bisection, so invertible/monotonic equations converge fast and
+        // anything pathological still halves the bracket every step.
+        const maxIter = options?.maxIter ?? DEFAULT_MAX_ITER;
+        for (let iter = 0; iter < maxIter; iter++) {
+            if (gLo == null || gHi == null)
+                break; // defensive; shouldn't happen
+            let x;
+            const denom = gHi - gLo;
+            if (denom !== 0) {
+                // Secant estimate, clamped to the interior of the bracket.
+                const secant = hi - (gHi * (hi - lo)) / denom;
+                const mid = (lo + hi) / 2;
+                x =
+                    secant > lo && secant < hi
+                        ? // Blend toward bisection to avoid regula-falsi stagnation on
+                            // one stuck endpoint.
+                            iter % 2 === 0
+                                ? secant
+                                : mid
+                        : mid;
+            }
+            else {
+                x = (lo + hi) / 2;
+            }
+            const gx = g(x);
+            if (gx == null) {
+                // Undefined interior point — fall back to plain midpoint stepping
+                // toward the evaluable side.
+                const mid = (lo + hi) / 2;
+                const gMid = x === mid ? gx : g(mid);
+                if (gMid == null) {
+                    return {
+                        ok: false,
+                        failure: {
+                            kind: 'eval-error',
+                            error: lastError ?? 'Expression undefined inside bracket',
+                        },
+                    };
+                }
+                x = mid;
+                if (Math.sign(gMid) === Math.sign(gLo)) {
+                    lo = x;
+                    gLo = gMid;
+                }
+                else {
+                    hi = x;
+                    gHi = gMid;
+                }
+            }
+            else {
+                if (Math.abs(gx) <= residualTol)
+                    return { ok: true, value: x };
+                if (Math.sign(gx) === Math.sign(gLo)) {
+                    lo = x;
+                    gLo = gx;
+                }
+                else {
+                    hi = x;
+                    gHi = gx;
+                }
+            }
+            if (converged(lo, hi)) {
+                return { ok: true, value: (lo + hi) / 2 };
+            }
+        }
+        return { ok: false, failure: { kind: 'non-convergent' } };
+    }
+    catch (err) {
+        if (err && typeof err === 'object' && 'solveFailure' in err) {
+            return {
+                ok: false,
+                failure: err.solveFailure,
+            };
+        }
+        return {
+            ok: false,
+            failure: {
+                kind: 'eval-error',
+                error: err instanceof Error ? err.message : String(err),
+            },
+        };
+    }
+};

package/dist/calculator/units.d.ts

@@ -0,0 +1,50 @@
+import { DecimalTolerance, FractionalTolerance, Units } from '../types/firestore.js';
+export type MeasurementDimension = 'length' | 'area' | 'volume';
+export type FieldDimension = MeasurementDimension | 'angle' | 'none';
+export type AreaUnit = 'sq_mm' | 'sq_cm' | 'sq_m' | 'sq_in' | 'sq_ft' | 'sq_yd';
+export type VolumeUnit = 'cu_mm' | 'cu_cm' | 'cu_m' | 'cu_in' | 'cu_ft' | 'cu_yd' | 'liter' | 'gallon';
+export type AngleUnit = 'deg' | 'rad';
+/** Every unit a calculator field may display in. Length reuses `Units`. */
+export type CalculatorUnit = Units | AreaUnit | VolumeUnit | AngleUnit;
+export interface CalculatorUnitInfo {
+    dimension: FieldDimension;
+    /**
+     * Real math.js unit token used for conversion. The fractional/composite
+     * length units (`in_frac`, `ft_in_*`) are display-only and collapse to
+     * their real unit here (mirrors normalizeUnitForMathJS in evaluateFormula).
+     */
+    mathUnit: string;
+    /** Short display label, e.g. 'ft³'. */
+    label: string;
+}
+export declare const CALCULATOR_UNIT_INFO: Record<CalculatorUnit, CalculatorUnitInfo>;
+/** The math.js token for a dimension's canonical unit. '' for dimensionless. */
+export declare const canonicalMathUnit: (dimension: FieldDimension) => string;
+export declare const unitDimension: (unit: CalculatorUnit) => FieldDimension;
+export declare const unitsForDimension: (dimension: FieldDimension) => CalculatorUnit[];
+/** Short label for a unit ('ft³', 'in', '°'). */
+export declare const calculatorUnitLabel: (unit: CalculatorUnit) => string;
+/** Convert a display-unit numeric value to the dimension's canonical unit. */
+export declare const toCanonical: (value: number, unit: CalculatorUnit) => number;
+/** Convert a canonical value to a display-unit numeric value. */
+export declare const fromCanonical: (value: number, unit: CalculatorUnit) => number;
+/**
+ * Parse user input in a display unit into a canonical value. Accepts plain
+ * numbers, fractions and mixed numbers ("12 1/2"). Length units additionally
+ * accept a trailing unit token (delegated to parseMeasurement). Returns null
+ * on unparseable input.
+ */
+export declare const parseToCanonical: (input: string, unit: CalculatorUnit) => number | null;
+export interface FormatTolerances {
+    fractionalTolerance?: FractionalTolerance;
+    decimalTolerance?: DecimalTolerance;
+}
+/**
+ * Format a canonical value for display in the given unit. Lengths delegate to
+ * convertMicrometers (the one place that renders fractional-inch / feet-inch
+ * strings); other dimensions format decimally per the decimal tolerance.
+ */
+export declare const formatCanonical: (value: number | null | undefined, unit: CalculatorUnit, tolerances?: FormatTolerances) => {
+    value: string;
+    unit: string;
+};