@reekon-tools/boldr-utils 1.21.1 → 1.23.0

package/dist/export/pdf/types.d.ts

@@ -0,0 +1,112 @@
+import type { GroupHeaderDescriptor } from '../../annotation/canvas/groupHeaderLayout.js';
+import type { AnnotationCanvasState, PlacedMeasurementRef } from '../../types/annotation.js';
+export interface EmbeddedImage {
+    bytes: Uint8Array;
+    mime: 'image/png' | 'image/jpeg';
+}
+/**
+ * Doc-space edge length (PDF points) a scale-1 measurement tile covers, and
+ * the same for header chips and object tiles. Tile footprints on screen are
+ * zoom-relative, so only the client that is exporting knows how large its
+ * tiles are against the drawing; it computes these with
+ * `tileDocSizeForFactor(resolvedFactor, baseFitZoom)` (stampLayout.ts) and
+ * sends them along. Absent fields fall back to the persisted `tileDocSize`,
+ * then to a default derived from the first page.
+ */
+export interface PdfExportCalibration {
+    tileDocSize?: number;
+    headerTileDocSize?: number;
+    fileTileDocSize?: number;
+}
+/** What a measurement / angle / formula tile displays. */
+export interface MeasurementTileContent {
+    kind: 'measurement';
+    /** Converted display string, e.g. "12 3/16", "5' 6 1/2\"", "45.2°". */
+    value: string;
+    /** Unit column text ("in", "mm", "ft"); empty for scalars. */
+    unit: string;
+    /** Header-row identifier ("A3", "B12"); empty hides it. */
+    positionLabel?: string;
+    /** Bottom label (measurement label / column name / override). */
+    label?: string;
+    /** Card fill (measurementTileFill precedence already applied). */
+    fill: string;
+    /** Formula tiles carry their label on a dark-magenta bar. */
+    formulaBar?: boolean;
+    negative?: boolean;
+}
+/** A FORM column holding a literal (text / number / select / boolean). */
+export interface LiteralTileContent {
+    kind: 'literal';
+    value: string;
+    topLeftLabel: string;
+    topRightLabel: string;
+    bottomLabel: string;
+}
+/** The blank "+" input tile. */
+export interface EmptyTileContent {
+    kind: 'empty';
+    topLeftLabel?: string;
+    topRightLabel?: string;
+    bottomLabel?: string;
+}
+export interface HeaderTileContent {
+    kind: 'header';
+    descriptor: GroupHeaderDescriptor;
+}
+export interface ObjectTileContent {
+    kind: 'object';
+    name: string;
+    /** FileUploadType value; decides the footer bar treatment. */
+    fileType?: string;
+    thumbnail?: EmbeddedImage;
+}
+export interface PlaneDimensionTileContent {
+    kind: 'planeDimension';
+    value: string;
+    unit: string;
+}
+export interface InstructionsTileContent {
+    kind: 'instructions';
+    text: string;
+    textColor?: string;
+    backgroundColor?: string;
+}
+export type ResolvedTileContent = MeasurementTileContent | LiteralTileContent | EmptyTileContent | HeaderTileContent | ObjectTileContent | PlaneDimensionTileContent | InstructionsTileContent;
+export interface SkippedItem {
+    id: string;
+    kind: 'layer' | 'tile' | 'shape' | 'stroke' | 'text';
+    reason: string;
+}
+export interface RenderCanvasToPdfInput {
+    /** The original PDF the canvas is drawn over. */
+    sourcePdf: Uint8Array;
+    canvas: AnnotationCanvasState;
+    /** Content for each placed tile; `undefined` renders the blank tile. */
+    resolveTile: (ref: PlacedMeasurementRef) => ResolvedTileContent | undefined;
+    /** Decoded bytes per raster background layer id. Missing → skipped. */
+    layerImages: Record<string, EmbeddedImage>;
+    calibration?: PdfExportCalibration;
+    /** TTF/OTF bytes of the primary font (Metropolis Bold in the apps). */
+    primaryFont: Uint8Array;
+    /**
+     * 'annotations' (default): every layer, mark and tile becomes a PDF
+     * annotation object — selectable, movable and deletable in Preview /
+     * Acrobat, with the element's exact drawing as its appearance. 'flatten':
+     * everything is appended to the page content stream and cannot be edited.
+     */
+    mode?: 'annotations' | 'flatten';
+}
+export interface RenderCanvasToPdfResult {
+    pdf: Uint8Array;
+    pageCount: number;
+    /** Annotations written across all pages (0 in flatten mode). */
+    annotationCount: number;
+    skipped: SkippedItem[];
+}
+export declare class PdfExportError extends Error {
+    readonly code: 'no-pdf-document' | 'page-count-mismatch' | 'page-geometry-mismatch'
+    /** The renderer was handed an encrypted PDF — run stripPdfEncryption first. */
+     | 'encrypted' | 'password-required' | 'password-incorrect' | 'unsupported' | 'corrupt';
+    constructor(code: PdfExportError['code'], message: string);
+}

package/dist/export/pdf/types.js

@@ -0,0 +1,10 @@
+// Public types of the canvas → PDF exporter. The renderer is PURE: it never
+// touches Firestore or Storage. Whoever calls it (the Cloud Function) resolves
+// every tile's content and every layer's bytes first and hands them in.
+export class PdfExportError extends Error {
+    constructor(code, message) {
+        super(message);
+        this.name = 'PdfExportError';
+        this.code = code;
+    }
+}

package/dist/exports.d.ts

@@ -1,4 +1,4 @@
-export { evaluateFormula, createFormulaScope, createEnhancedFormulaScope, clearFormulaCache, micrometersToUnitNumber, type EnhancedMapping, type FormulaDefinition, type FormulaEvaluationOptions, } from './formulas/evaluateFormula.js';
+export { evaluateFormula, createFormulaScope, createEnhancedFormulaScope, clearFormulaCache, type EnhancedMapping, type FormulaDefinition, type FormulaEvaluationOptions, } from './formulas/evaluateFormula.js';
 export { calculateFormula } from './formulas/calculateFormula.js';
 export { convertMicrometers } from './utils/micrometersToUnit.js';
 export { parseMeasurement } from './utils/parseMeasurement.js';

package/dist/exports.js

@@ -2,7 +2,7 @@
 // platform-specific `AnnotationCanvas` wrapper lives here. The two index
 // files (index.ts, index.native.ts) re-export from this and add their own
 // AnnotationCanvas import.
-export { evaluateFormula, createFormulaScope, createEnhancedFormulaScope, clearFormulaCache, micrometersToUnitNumber, } from './formulas/evaluateFormula.js';
+export { evaluateFormula, createFormulaScope, createEnhancedFormulaScope, clearFormulaCache, } from './formulas/evaluateFormula.js';
 export { calculateFormula } from './formulas/calculateFormula.js';
 export { convertMicrometers } from './utils/micrometersToUnit.js';
 export { parseMeasurement } from './utils/parseMeasurement.js';

package/dist/formulas/calculateFormula.d.ts

@@ -1,2 +1,2 @@
 import { ColumnConfig, DecimalTolerance, FractionalTolerance, Formula, Measurement, Units } from '../types/firestore.js';
-export declare const calculateFormula: (formula: Formula, formulas: Formula[], columns: Record<string, string>, tableConfig: ColumnConfig[], measurements: Measurement[], unit: Units, _fractionalTolerance?: FractionalTolerance, _decimalTolerance?: DecimalTolerance) => string | number | null;
+export declare const calculateFormula: (formula: Formula, formulas: Formula[], columns: Record<string, string>, tableConfig: ColumnConfig[], measurements: Measurement[], unit: Units, fractionalTolerance: FractionalTolerance, decimalTolerance: DecimalTolerance) => string | number | null;

package/dist/formulas/calculateFormula.js

@@ -1,9 +1,25 @@
 import { ColumnType, } from '../types/firestore.js';
-import { evaluateFormula, micrometersToUnitNumber, } from './evaluateFormula.js';
-export const calculateFormula = (formula, formulas, columns, tableConfig, measurements, unit, 
-// Unused since measurement values stopped round-tripping through the display
-// string — kept so the 8-arg call sites in the apps don't break.
-_fractionalTolerance, _decimalTolerance) => {
+import { evaluateFormula } from './evaluateFormula.js';
+import { convertMicrometers } from '../utils/micrometersToUnit.js';
+function parseMixedNumber(str) {
+    const parts = str.trim().split(' ');
+    let whole = 0;
+    let fraction = 0;
+    if (parts.length === 2) {
+        whole = parseFloat(parts[0]);
+        const [num, den] = parts[1].split('/').map(Number);
+        fraction = num / den;
+    }
+    else if (parts[0].includes('/')) {
+        const [num, den] = parts[0].split('/').map(Number);
+        fraction = num / den;
+    }
+    else {
+        whole = parseFloat(parts[0]);
+    }
+    return whole + fraction;
+}
+export const calculateFormula = (formula, formulas, columns, tableConfig, measurements, unit, fractionalTolerance, decimalTolerance) => {
     // Convert Firestore Map to plain object if necessary
     let variableToColumnMap = {};
     if (formula.variableToColumnMap) {
@@ -29,11 +45,8 @@ _fractionalTolerance, _decimalTolerance) => {
             const measurement = measurements.find((m) => m.id === measurementId);
             if (!measurement)
                 continue;
-            // Straight um -> display-unit number. The old path rendered the display
-            // STRING (convertMicrometers) and re-parsed it, which rounded the value
-            // to the display tolerance and returned NaN / dropped the inches for the
-            // composite feet-inches formats (`5' 3 1/2"`).
-            valueMap[columnId] = micrometersToUnitNumber(measurement.value, unit);
+            const { value, unit: displayUnit } = convertMicrometers(measurement.value, unit, fractionalTolerance, decimalTolerance);
+            valueMap[columnId] = parseMixedNumber(value);
         }
         else if (column.type === ColumnType.Angle) {
             const measurement = measurements.find((m) => m.id === measurementId);

package/dist/formulas/evaluateFormula.d.ts

@@ -17,16 +17,6 @@ export interface FormulaEvaluationOptions {
     formulas?: FormulaDefinition[];
     scope?: Record<string, number>;
 }
-export declare function normalizeUnitForMathJS(unit: Units | string): string;
-/**
- * Convert a stored micrometer value to the number the formula scope expects
- * for `unit` — the same conversion nested-formula results go through. This is
- * the ONLY sanctioned way to put a measurement into a valueMap: converting via
- * the display STRING (convertMicrometers + a string parser) both rounds the
- * value to the display tolerance and falls apart on composite formats like
- * `5' 3 1/2"`.
- */
-export declare function micrometersToUnitNumber(micrometers: number, unit: Units): number;
 export declare function evaluateFormula({ expression, mappings, valueMap, unit, formulas, scope, }: FormulaEvaluationOptions): number | string | null;
 export declare function createFormulaScope({ mappings, valueMap, unit, }: {
     mappings: Record<string, string>;

package/dist/formulas/evaluateFormula.js

@@ -7,7 +7,7 @@ const compile = math.compile.bind(math);
 const mathUnit = math.unit.bind(math);
 // Cache for evaluated formulas to improve performance
 const formulaCache = new Map();
-export function normalizeUnitForMathJS(unit) {
+function normalizeUnitForMathJS(unit) {
     switch (unit) {
         case Units.Centimeters:
         case 'cm':
@@ -30,17 +30,6 @@ export function normalizeUnitForMathJS(unit) {
             return 'mm'; // fallback
     }
 }
-/**
- * Convert a stored micrometer value to the number the formula scope expects
- * for `unit` — the same conversion nested-formula results go through. This is
- * the ONLY sanctioned way to put a measurement into a valueMap: converting via
- * the display STRING (convertMicrometers + a string parser) both rounds the
- * value to the display tolerance and falls apart on composite formats like
- * `5' 3 1/2"`.
- */
-export function micrometersToUnitNumber(micrometers, unit) {
-    return mathUnit(micrometers, 'um').toNumber(normalizeUnitForMathJS(unit));
-}
 // Normalize mapping to EnhancedMapping format
 function normalizeMapping(mapping) {
     if (typeof mapping === 'string') {

package/dist/formulas/groupFormula.d.ts

@@ -0,0 +1,43 @@
+import { Units } from '../types/firestore.js';
+/** Frame types of the stack-expression formula the apps persist. */
+export declare enum GroupFormulaFrameType {
+    Operator = "operator",
+    Number = "number",
+    Paren = "paren",
+    Fraction = "fraction",
+    FeetInches = "feetInches",
+    MeasurementObj = "measurement",
+    InspectionInput = "InspectionInput",
+    Func = "func",
+    Output = "output"
+}
+export interface GroupFormulaFraction {
+    int: string;
+    numerator: string;
+    denominator: string;
+}
+export interface GroupFormulaFeetInches {
+    feet: string;
+    int: string;
+    numerator: string;
+    denominator: string;
+}
+export interface GroupFormulaFrame {
+    type: GroupFormulaFrameType | string;
+    value: unknown;
+    measurement?: {
+        value: number;
+    };
+    func?: string;
+}
+export declare const micrometersToUnitNumber: (um: number, unit: Units) => number;
+export declare const unitNumberToMicrometers: (value: number, unit: Units) => number;
+/** The mathjs expression string a stack formula evaluates to, for `valueUm`. */
+export declare const groupFormulaExpression: (frames: GroupFormulaFrame[], valueUm: number, unit: Units | undefined) => string;
+/**
+ * Apply a group's stored `formula` to a measurement value (micrometers) and
+ * return the result in micrometers, or null when the group has no formula or
+ * the expression does not evaluate to a finite number (the caller falls back
+ * to the raw value, exactly like the tiles do).
+ */
+export declare const applyGroupFormulaUm: (formula: unknown, valueUm: number, unit: Units | undefined) => number | null;

package/dist/formulas/groupFormula.js

@@ -0,0 +1,168 @@
+// A LIST group's batch formula, applied to one measurement value — the
+// evaluation every tile that shows a group-formula'd measurement performs.
+//
+// Ported from the two apps' `lib/calculator.ts` (`applyFormulaToMeasurement` +
+// `arrayToExpression`), which are byte-for-byte duplicates of each other, so
+// the server-side PDF export shows the same value the screens do. Kept
+// deliberately narrow: only the frame kinds a GROUP formula can hold. The
+// calculator's inspection-input frames are not group-formula content and are
+// emitted as an empty token here, exactly as the apps' `default:` branch does.
+import { create, all } from 'mathjs';
+import { Units } from '../types/firestore.js';
+const math = create(all);
+const MICROMETERS_PER_IN = 25400;
+const MICROMETERS_PER_FT = 304800;
+const MICROMETERS_PER_MM = 1000;
+const MICROMETERS_PER_CM = 10000;
+const MICROMETERS_PER_M = 1000000;
+/** Frame types of the stack-expression formula the apps persist. */
+export var GroupFormulaFrameType;
+(function (GroupFormulaFrameType) {
+    GroupFormulaFrameType["Operator"] = "operator";
+    GroupFormulaFrameType["Number"] = "number";
+    GroupFormulaFrameType["Paren"] = "paren";
+    GroupFormulaFrameType["Fraction"] = "fraction";
+    GroupFormulaFrameType["FeetInches"] = "feetInches";
+    GroupFormulaFrameType["MeasurementObj"] = "measurement";
+    GroupFormulaFrameType["InspectionInput"] = "InspectionInput";
+    GroupFormulaFrameType["Func"] = "func";
+    GroupFormulaFrameType["Output"] = "output";
+})(GroupFormulaFrameType || (GroupFormulaFrameType = {}));
+const toNumber = (v) => {
+    const n = parseInt(v, 10);
+    return Number.isNaN(n) ? 0 : n;
+};
+const fractionToDecimal = (f) => {
+    const numerator = parseInt(f.numerator, 10);
+    const denominator = parseInt(f.denominator, 10);
+    let frac = 0;
+    if (!(Number.isNaN(numerator) && Number.isNaN(denominator))) {
+        const den = Number.isNaN(denominator) ? 0 : denominator;
+        frac =
+            den === 0
+                ? 0
+                : math.number(math.fraction(Number.isNaN(numerator) ? 0 : numerator, den));
+    }
+    return frac + toNumber(f.int);
+};
+const feetInchesToDecimalFeet = (v) => {
+    const feet = parseInt(v.feet, 10);
+    const inchInt = parseInt(v.int, 10);
+    const numerator = parseInt(v.numerator, 10);
+    const denominator = parseInt(v.denominator, 10);
+    const inchFrac = !Number.isNaN(numerator) && !Number.isNaN(denominator) && denominator > 0
+        ? math.number(math.fraction(numerator, denominator))
+        : 0;
+    const inches = (Number.isNaN(inchInt) ? 0 : inchInt) + inchFrac;
+    const sign = v.feet.trim().startsWith('-') ? -1 : 1;
+    return (Number.isNaN(feet) ? 0 : feet) + (sign * inches) / 12;
+};
+/** Composite feet-inches units evaluate in decimal feet; everything else as-is. */
+const evaluationUnit = (u) => {
+    if (!u)
+        return Units.Inches;
+    return u === Units.FeetInchesDecimal || u === Units.FeetInchesFractional
+        ? Units.Feet
+        : u;
+};
+export const micrometersToUnitNumber = (um, unit) => {
+    switch (unit) {
+        case Units.Millimeters:
+            return um / MICROMETERS_PER_MM;
+        case Units.Centimeters:
+            return um / MICROMETERS_PER_CM;
+        case Units.Meters:
+            return um / MICROMETERS_PER_M;
+        case Units.Feet:
+        case Units.FeetInchesDecimal:
+        case Units.FeetInchesFractional:
+            return um / MICROMETERS_PER_FT;
+        case Units.Inches:
+        case Units.FractionalInches:
+            return um / MICROMETERS_PER_IN;
+        default:
+            return NaN;
+    }
+};
+export const unitNumberToMicrometers = (value, unit) => {
+    switch (unit) {
+        case Units.Millimeters:
+            return value * MICROMETERS_PER_MM;
+        case Units.Centimeters:
+            return value * MICROMETERS_PER_CM;
+        case Units.Meters:
+            return value * MICROMETERS_PER_M;
+        case Units.Feet:
+        case Units.FeetInchesDecimal:
+        case Units.FeetInchesFractional:
+            return value * MICROMETERS_PER_FT;
+        case Units.Inches:
+        case Units.FractionalInches:
+            return value * MICROMETERS_PER_IN;
+        default:
+            return NaN;
+    }
+};
+const findLastIndex = (arr, pred) => {
+    for (let i = arr.length - 1; i >= 0; i--)
+        if (pred(arr[i]))
+            return i;
+    return -1;
+};
+/** The mathjs expression string a stack formula evaluates to, for `valueUm`. */
+export const groupFormulaExpression = (frames, valueUm, unit) => {
+    const outputIndex = findLastIndex(frames, (f) => f.type === GroupFormulaFrameType.Output);
+    const sliced = outputIndex === -1 ? frames : frames.slice(outputIndex);
+    const evalUnit = evaluationUnit(unit);
+    return sliced
+        .map((item) => {
+        switch (item.type) {
+            case GroupFormulaFrameType.Fraction:
+                return String(fractionToDecimal(item.value));
+            case GroupFormulaFrameType.FeetInches:
+                return String(feetInchesToDecimalFeet(item.value));
+            case GroupFormulaFrameType.Number:
+            case GroupFormulaFrameType.Operator:
+            case GroupFormulaFrameType.Paren:
+            case GroupFormulaFrameType.Output:
+                return String(item.value ?? '');
+            case GroupFormulaFrameType.MeasurementObj:
+                // The measurement frame stands for THE measurement being displayed.
+                return String(micrometersToUnitNumber(valueUm, evalUnit));
+            case GroupFormulaFrameType.Func: {
+                const funcValue = String(item.value ?? '');
+                const m = item.measurement;
+                if (m && typeof m.value === 'number') {
+                    const converted = micrometersToUnitNumber(m.value, evalUnit);
+                    return funcValue.replace(m.value.toString(), converted.toString());
+                }
+                return funcValue;
+            }
+            default:
+                return '';
+        }
+    })
+        .join(' ');
+};
+/**
+ * Apply a group's stored `formula` to a measurement value (micrometers) and
+ * return the result in micrometers, or null when the group has no formula or
+ * the expression does not evaluate to a finite number (the caller falls back
+ * to the raw value, exactly like the tiles do).
+ */
+export const applyGroupFormulaUm = (formula, valueUm, unit) => {
+    if (!Array.isArray(formula) || formula.length === 0)
+        return null;
+    const expression = groupFormulaExpression(formula, valueUm, unit);
+    let result;
+    try {
+        result = math.evaluate(expression);
+    }
+    catch {
+        return null;
+    }
+    if (typeof result !== 'number' || !Number.isFinite(result))
+        return null;
+    const um = unitNumberToMicrometers(result, evaluationUnit(unit));
+    return Number.isFinite(um) ? um : null;
+};

package/dist/index.d.ts

@@ -1,5 +1,5 @@
 export * from './exports.js';
-export { evaluateFormula, createFormulaScope, createEnhancedFormulaScope, clearFormulaCache, micrometersToUnitNumber, type EnhancedMapping, type FormulaDefinition, type FormulaEvaluationOptions, } from './formulas/evaluateFormula.js';
+export { evaluateFormula, createFormulaScope, createEnhancedFormulaScope, clearFormulaCache, type EnhancedMapping, type FormulaDefinition, type FormulaEvaluationOptions, } from './formulas/evaluateFormula.js';
 export { calculateFormula } from './formulas/calculateFormula.js';
 export { convertMicrometers } from './utils/micrometersToUnit.js';
 export { parseMeasurement } from './utils/parseMeasurement.js';

package/dist/index.js

@@ -3,7 +3,7 @@
 // WithSkiaWeb. Metro/RN consumers resolve `index.native.ts` instead via
 // the `react-native` condition in package.json `exports`.
 export * from './exports.js';
-export { evaluateFormula, createFormulaScope, createEnhancedFormulaScope, clearFormulaCache, micrometersToUnitNumber, } from './formulas/evaluateFormula.js';
+export { evaluateFormula, createFormulaScope, createEnhancedFormulaScope, clearFormulaCache, } from './formulas/evaluateFormula.js';
 export { calculateFormula } from './formulas/calculateFormula.js';
 export { convertMicrometers } from './utils/micrometersToUnit.js';
 export { parseMeasurement } from './utils/parseMeasurement.js';

package/dist/server.d.ts

@@ -1,4 +1,4 @@
-export { evaluateFormula, createFormulaScope, createEnhancedFormulaScope, clearFormulaCache, micrometersToUnitNumber, type EnhancedMapping, type FormulaDefinition, type FormulaEvaluationOptions, } from './formulas/evaluateFormula.js';
+export { evaluateFormula, createFormulaScope, createEnhancedFormulaScope, clearFormulaCache, type EnhancedMapping, type FormulaDefinition, type FormulaEvaluationOptions, } from './formulas/evaluateFormula.js';
 export { calculateFormula } from './formulas/calculateFormula.js';
 export { convertMicrometers } from './utils/micrometersToUnit.js';
 export { parseMeasurement } from './utils/parseMeasurement.js';
@@ -15,3 +15,6 @@ export { desktopBaseUrlForFirebaseProject, desktopFileEditorUrl, type DesktopLin
 export { numberToLetterIndex, formGroupInputLabel, listGroupMeasurementLabel, } from './utils/indexLabels.js';
 export { toSelectedValues, formatSelectedValues, toStoredValue, } from './utils/selectValues.js';
 export * from './calculator/index.js';
+export * from './export/pdf/index.js';
+export { applyGroupFormulaUm, groupFormulaExpression, micrometersToUnitNumber, unitNumberToMicrometers, type GroupFormulaFrame, } from './formulas/groupFormula.js';
+export { MEASUREMENT_LINE_COLOR, MEASUREMENT_LINE_WIDTH, MEASUREMENT_RECT_WIDTH, } from './annotation/canvas/measurementLineStyle.js';

package/dist/server.js

@@ -3,7 +3,7 @@
 // root barrel, whose module graph statically pulls in `react` and
 // `@shopify/react-native-skia`. Only modules with no React/Skia anywhere
 // in their import graph may be re-exported from this file.
-export { evaluateFormula, createFormulaScope, createEnhancedFormulaScope, clearFormulaCache, micrometersToUnitNumber, } from './formulas/evaluateFormula.js';
+export { evaluateFormula, createFormulaScope, createEnhancedFormulaScope, clearFormulaCache, } from './formulas/evaluateFormula.js';
 export { calculateFormula } from './formulas/calculateFormula.js';
 export { convertMicrometers } from './utils/micrometersToUnit.js';
 export { parseMeasurement } from './utils/parseMeasurement.js';
@@ -20,3 +20,8 @@ export { desktopBaseUrlForFirebaseProject, desktopFileEditorUrl, } from './expor
 export { numberToLetterIndex, formGroupInputLabel, listGroupMeasurementLabel, } from './utils/indexLabels.js';
 export { toSelectedValues, formatSelectedValues, toStoredValue, } from './utils/selectValues.js';
 export * from './calculator/index.js';
+// Canvas → annotated PDF export (Cloud Function renderer). Pure pdf-lib; no
+// React or Skia anywhere in its import graph.
+export * from './export/pdf/index.js';
+export { applyGroupFormulaUm, groupFormulaExpression, micrometersToUnitNumber, unitNumberToMicrometers, } from './formulas/groupFormula.js';
+export { MEASUREMENT_LINE_COLOR, MEASUREMENT_LINE_WIDTH, MEASUREMENT_RECT_WIDTH, } from './annotation/canvas/measurementLineStyle.js';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@reekon-tools/boldr-utils",
-  "version": "1.21.1",
+  "version": "1.23.0",
   "description": "Shared utilities for formulas and measurement conversion used in Reekon apps",
   "author": "REEKON Tools",
   "license": "MIT",
@@ -47,10 +47,14 @@
   "keywords": [],
   "repository": "https://gitlab.com/reekon-tools/software/rock-pro/boldr-utils#",
   "dependencies": {
+    "@pdf-lib/fontkit": "1.1.1",
     "mathjs": "^11.11.0",
+    "pdf-lib": "1.17.1",
     "zod": "^4.4.3"
   },
+  "//peerDependencies-embedpdf": "OPTIONAL, server only: `@embedpdf/pdfium` is imported lazily by exactly one module (export/pdf/decrypt.ts, reached through the ./server entry) to strip PDF encryption before pdf-lib appends to a page. The apps never resolve it.",
   "peerDependencies": {
+    "@embedpdf/pdfium": ">=2.15.0",
     "@shopify/react-native-skia": ">=2.5.0",
     "react": "^18.0.0 || ^19.0.0",
     "react-native": ">=0.74.0",
@@ -58,6 +62,9 @@
     "react-native-reanimated": ">=3.0.0"
   },
   "peerDependenciesMeta": {
+    "@embedpdf/pdfium": {
+      "optional": true
+    },
     "react-native": {
       "optional": true
     },
@@ -70,6 +77,7 @@
   },
   "devDependencies": {
     "@arethetypeswrong/cli": "^0.18.1",
+    "@embedpdf/pdfium": "2.15.0",
     "@shopify/react-native-skia": "^2.6.2",
     "@types/node": "^22.15.18",
     "@types/react": "^19.0.8",

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;