@reekon-tools/boldr-utils 1.21.1 → 1.22.0

package/dist/export/pdf/tiles.js

@@ -0,0 +1,392 @@
+// Tile chrome: measurement tiles, header chips, object tiles, plane dimension
+// chips and the blank input, drawn as PDF vectors. Each painter works in the
+// tile's DESIGN space (the 96-unit STAMP_TILE_SIZE square, or a header's
+// 200×56 / 90×65 box — the same natural-size-then-scale pattern the RN and
+// DOM tiles use), and the renderer scales that box into the tile's doc-space
+// footprint centred on the placed anchor.
+//
+// These are deliberately PDF-native renditions of the app's tiles — the same
+// fills, type hierarchy and layout — not pixel captures of them.
+import { clip, endPath, fill, popGraphicsState, pushGraphicsState, rectangle, stroke, } from 'pdf-lib';
+import { FileUploadType } from '../../types/firestore.js';
+import { STAMP_TILE_SIZE, stampTileDims, } from '../../annotation/canvas/stampLayout.js';
+import { GROUP_HEADER_STYLE, } from '../../annotation/canvas/groupHeaderLayout.js';
+import { FormColors, FormulaColors, GeneralColors, TileColors, } from '../../theme/colors.js';
+import { circlePathOps, fillStateOps, imageOps, polylinePathOps, roundedRectPathOps, strokeStateOps, withMatrix, } from './emit.js';
+const tileKind = (ref) => ref.fileId ? 'file' : ref.isGroupHeader ? 'header' : 'measurement';
+/**
+ * Doc-space footprint of a placed tile. `fallbackDocEdge` is the doc-space
+ * edge a scale-1 measurement tile covers when neither the request nor the
+ * document carries a calibration.
+ */
+export const tileFootprint = (ref, canvas, calibration, fallbackDocEdge, design) => {
+    const kind = tileKind(ref);
+    const measurementEdge = calibration?.tileDocSize ?? canvas.tileDocSize ?? fallbackDocEdge;
+    const edge = kind === 'header'
+        ? (calibration?.headerTileDocSize ?? measurementEdge)
+        : kind === 'file'
+            ? (calibration?.fileTileDocSize ?? measurementEdge)
+            : measurementEdge;
+    // stampTileDims at unit factors and unit zoom = the base footprint × the
+    // tile's own `scale`; the calibration edge then converts base units to doc.
+    const base = stampTileDims(ref, 1, 1, 1, 1);
+    const k = edge / STAMP_TILE_SIZE;
+    const width = base.width * k;
+    const height = base.height * k;
+    return {
+        x: ref.anchor.x - width / 2,
+        y: ref.anchor.y - height / 2,
+        width,
+        height,
+        design,
+    };
+};
+export const designBoxFor = (ref, content) => content.kind === 'header'
+    ? content.descriptor.design
+    : ref.isGroupHeader
+        ? { width: 200, height: 56 }
+        : { width: STAMP_TILE_SIZE, height: STAMP_TILE_SIZE };
+/** Doc ← design matrix for a footprint. */
+export const designToDocMatrix = (f) => {
+    const k = f.width / f.design.width;
+    return [k, 0, 0, k, f.x, f.y];
+};
+/* ------------------------------------------------------------------ *
+ * Shared bits
+ * ------------------------------------------------------------------ */
+const SQUARE = STAMP_TILE_SIZE;
+const CARD_RADIUS = 6;
+const filledRoundedRect = (x, y, w, h, r, color) => [
+    pushGraphicsState(),
+    ...fillStateOps(color),
+    ...roundedRectPathOps(x, y, w, h, r),
+    fill(),
+    popGraphicsState(),
+];
+const strokedRoundedRect = (x, y, w, h, r, color, width) => [
+    pushGraphicsState(),
+    ...strokeStateOps({ color, width, join: 'miter' }),
+    ...roundedRectPathOps(x + width / 2, y + width / 2, w - width, h - width, r),
+    stroke(),
+    popGraphicsState(),
+];
+/** Truncate to `maxWidth` with an ellipsis, like numberOfLines={1}. */
+const truncate = (fonts, text, size, maxWidth) => {
+    if (fonts.width(text, size) <= maxWidth)
+        return text;
+    const ell = '…';
+    let t = text;
+    while (t.length > 0 && fonts.width(t + ell, size) > maxWidth)
+        t = t.slice(0, -1);
+    return t.length > 0 ? t + ell : '';
+};
+/* ------------------------------------------------------------------ *
+ * Measurement value row: tokens with stacked fractions
+ * ------------------------------------------------------------------ */
+// Mirror of the mobile tileValueFont model at a 96-unit tile.
+const DIGIT_ADVANCE_EM = 0.68;
+const FRACTION_STACK_CHARS = 1.4;
+const FIT_K = 0.9 / DIGIT_ADVANCE_EM;
+const TILE_VALUE_MAX_TILE_SCALE = 0.8 / 3;
+const UNIT_FONT = 12; // clamp(96 × 0.1, 12, 16)
+const UNIT_RESERVE = Math.round(UNIT_FONT * (2 * 0.854 + 0.2));
+const tokenize = (value) => value
+    .trim()
+    .split(/\s+/)
+    .filter(Boolean)
+    .map((t) => {
+    if (!t.includes('/'))
+        return { text: t };
+    const [num, rest = ''] = t.split('/');
+    const den = rest.replace(/[^0-9]/g, '');
+    const suffix = rest.replace(/[0-9]/g, '');
+    return { text: t, fraction: { num: num ?? '', den, suffix } };
+});
+const effectiveLength = (tokens) => tokens.reduce((n, t, i) => n +
+    (i > 0 ? 1 : 0) +
+    (t.fraction
+        ? FRACTION_STACK_CHARS + t.fraction.suffix.length
+        : t.text.length), 0);
+/**
+ * Draw a converted value string centred at (cx, cy) in design units with
+ * whole parts large and fractions stacked over a rule. Returns the ops.
+ */
+const valueRowOps = (ctx, value, cx, cy, color, availableWidth, tileWidth) => {
+    const tokens = tokenize(value);
+    if (tokens.length === 0)
+        return [];
+    const chars = Math.max(effectiveLength(tokens), 1);
+    const fs = Math.min(TILE_VALUE_MAX_TILE_SCALE * tileWidth, (FIT_K / chars) * availableWidth);
+    const fracFs = fs * 0.8;
+    const gap = fs * 0.15;
+    // Measure the row.
+    const widths = tokens.map((t) => {
+        if (!t.fraction)
+            return ctx.fonts.width(t.text, fs);
+        const stack = Math.max(ctx.fonts.width(t.fraction.num, fracFs), ctx.fonts.width(t.fraction.den, fracFs));
+        return (stack + (t.fraction.suffix ? ctx.fonts.width(t.fraction.suffix, fs) : 0));
+    });
+    const total = widths.reduce((a, b) => a + b, 0) + gap * (tokens.length - 1);
+    let x = cx - total / 2;
+    const ops = [];
+    const baseline = cy + fs * 0.35; // cap-height centred on cy
+    tokens.forEach((t, i) => {
+        const w = widths[i];
+        if (!t.fraction) {
+            ops.push(...ctx.fonts.textOps(ctx.page, t.text, fs, color, x, baseline));
+        }
+        else {
+            const stackW = Math.max(ctx.fonts.width(t.fraction.num, fracFs), ctx.fonts.width(t.fraction.den, fracFs));
+            const scx = x + stackW / 2;
+            // Numerator above the rule, denominator below; rule at the row centre.
+            ops.push(...ctx.fonts.textOps(ctx.page, t.fraction.num, fracFs, color, scx, cy - fracFs * 0.15, { align: 'center' }), pushGraphicsState(), ...fillStateOps(color), rectangle(x, cy - fracFs * 0.05, stackW, Math.max(fracFs * 0.08, 0.8)), fill(), popGraphicsState(), ...ctx.fonts.textOps(ctx.page, t.fraction.den, fracFs, color, scx, cy + fracFs * 0.85, { align: 'center' }));
+            if (t.fraction.suffix) {
+                ops.push(...ctx.fonts.textOps(ctx.page, t.fraction.suffix, fs, color, x + stackW, baseline));
+            }
+        }
+        x += w + gap;
+    });
+    return ops;
+};
+/* ------------------------------------------------------------------ *
+ * Painters (design space, y-down)
+ * ------------------------------------------------------------------ */
+const measurementTileOps = (ctx, c) => {
+    const ops = filledRoundedRect(0, 0, SQUARE, SQUARE, CARD_RADIUS, c.fill);
+    const white = GeneralColors.white;
+    // Header row: position label, bold, top-left.
+    if (c.positionLabel) {
+        ops.push(...ctx.fonts.textOps(ctx.page, c.positionLabel, 12, white, 6, 14));
+    }
+    // Value row, centred on the tile, between the two unit slots.
+    const hasUnit = !!c.unit;
+    const available = hasUnit ? SQUARE - 2 * UNIT_RESERVE : SQUARE - 8;
+    const valueText = (c.negative ? '-' : '') + c.value;
+    ops.push(...valueRowOps(ctx, valueText, SQUARE / 2, 48, white, available, SQUARE));
+    if (hasUnit) {
+        ops.push(...ctx.fonts.textOps(ctx.page, c.unit, UNIT_FONT, white, SQUARE - UNIT_RESERVE / 2, 52, {
+            align: 'center',
+        }));
+    }
+    // Bottom label: bare white ink, or on the formula tile's dark-magenta bar.
+    if (c.label) {
+        const labelSize = 11;
+        if (c.formulaBar) {
+            ops.push(...filledRoundedRect(4, SQUARE - 20, SQUARE - 8, 16, 3, FormulaColors.darkPurple), ...strokedRoundedRect(4, SQUARE - 20, SQUARE - 8, 16, 3, FormulaColors.purple, 1));
+        }
+        const text = truncate(ctx.fonts, c.label, labelSize, SQUARE - 12);
+        ops.push(...ctx.fonts.textOps(ctx.page, text, labelSize, white, SQUARE / 2, SQUARE - 8, { align: 'center' }));
+    }
+    return ops;
+};
+const emptyTileOps = (ctx, c) => {
+    const ink = FormColors.lightGrey1;
+    const ops = [
+        ...filledRoundedRect(0, 0, SQUARE, SQUARE, CARD_RADIUS, GeneralColors.grey2),
+        ...strokedRoundedRect(0, 0, SQUARE, SQUARE, CARD_RADIUS, GeneralColors.grey3, 1),
+    ];
+    if (c.topLeftLabel)
+        ops.push(...ctx.fonts.textOps(ctx.page, c.topLeftLabel, 10, ink, 8, 18));
+    if (c.topRightLabel) {
+        ops.push(...ctx.fonts.textOps(ctx.page, c.topRightLabel, 10, ink, SQUARE - 8, 18, {
+            align: 'right',
+        }));
+    }
+    // The "+" well.
+    ops.push(...filledRoundedRect(8, 28, SQUARE - 16, 40, 4, GeneralColors.grey3));
+    const cx = SQUARE / 2;
+    const cy = 48;
+    ops.push(pushGraphicsState(), ...strokeStateOps({ color: ink, width: 2.5, cap: 'round' }), ...polylinePathOps([
+        { x: cx - 8, y: cy },
+        { x: cx + 8, y: cy },
+    ]), stroke(), ...polylinePathOps([
+        { x: cx, y: cy - 8 },
+        { x: cx, y: cy + 8 },
+    ]), stroke(), popGraphicsState());
+    if (c.bottomLabel) {
+        const text = truncate(ctx.fonts, c.bottomLabel, 10, SQUARE - 16);
+        ops.push(...ctx.fonts.textOps(ctx.page, text, 10, ink, cx, SQUARE - 10, {
+            align: 'center',
+        }));
+    }
+    return ops;
+};
+const literalTileOps = (ctx, c) => {
+    const filled = c.value !== '';
+    const fillColor = filled ? TileColors.activeBlue : GeneralColors.grey2;
+    const ink = filled ? GeneralColors.white : GeneralColors.grey4;
+    const ops = filledRoundedRect(0, 0, SQUARE, SQUARE, CARD_RADIUS, fillColor);
+    ops.push(...ctx.fonts.textOps(ctx.page, c.topLeftLabel, 10, ink, 8, 18));
+    ops.push(...ctx.fonts.textOps(ctx.page, c.topRightLabel, 10, ink, SQUARE - 8, 18, {
+        align: 'right',
+    }));
+    ops.push(...filledRoundedRect(8, 28, SQUARE - 16, 40, 4, filled ? TileColors.activeBlue : GeneralColors.grey3));
+    if (filled) {
+        const size = ctx.fonts.fitSize(c.value, SQUARE - 24, 16, 6);
+        ops.push(...ctx.fonts.textOps(ctx.page, c.value, size, ink, SQUARE / 2, 48 + size * 0.35, { align: 'center' }));
+    }
+    const bottom = truncate(ctx.fonts, c.bottomLabel, 10, SQUARE - 16);
+    ops.push(...ctx.fonts.textOps(ctx.page, bottom, 10, ink, SQUARE / 2, SQUARE - 10, {
+        align: 'center',
+    }));
+    return ops;
+};
+const globeOps = (cx, cy, size, color) => {
+    const r = size / 2 - 1;
+    return [
+        pushGraphicsState(),
+        ...strokeStateOps({ color, width: 1.75, join: 'round' }),
+        ...circlePathOps(cx, cy, r),
+        stroke(),
+        ...polylinePathOps([
+            { x: cx - r, y: cy },
+            { x: cx + r, y: cy },
+        ]),
+        stroke(),
+        // Meridian as a narrow ellipse: scale x by 0.45 around cx.
+        ...withMatrix([0.45, 0, 0, 1, cx * (1 - 0.45), 0], [...circlePathOps(cx, cy, r), stroke()]),
+        popGraphicsState(),
+    ];
+};
+const headerTileOps = (ctx, c) => {
+    const d = c.descriptor;
+    const S = GROUP_HEADER_STYLE;
+    const W = d.design.width;
+    const H = d.design.height;
+    const ops = filledRoundedRect(0, 0, W, H, S.radius, S.background);
+    const inner = W - 2 * S.padding;
+    const nameBlock = d.name !== null ? S.nameGap + S.nameFontSize * 1.2 : 0;
+    const badgesBlock = d.collapsed
+        ? d.badges.length * S.badgeHeight +
+            Math.max(0, d.badges.length - 1) * S.badgeGapCollapsed
+        : d.badges.length > 0
+            ? S.badgeHeight
+            : 0;
+    const contentH = badgesBlock + nameBlock;
+    let y = (H - contentH) / 2;
+    if (d.badges.length > 0) {
+        if (d.collapsed) {
+            d.badges.forEach((b, i) => {
+                const by = y + i * (S.badgeHeight + S.badgeGapCollapsed);
+                ops.push(...filledRoundedRect(S.padding, by, inner, S.badgeHeight, S.badgeRadius, b.background));
+                if (d.showGlobe)
+                    ops.push(...globeOps(W / 2, by + S.badgeHeight / 2, S.globeSize, S.globeColor));
+                else {
+                    const text = truncate(ctx.fonts, b.text, S.badgeFontSize, inner - 10);
+                    ops.push(...ctx.fonts.textOps(ctx.page, text, S.badgeFontSize, S.badgeTextColor, W / 2, by + S.badgeHeight / 2 + S.badgeFontSize * 0.35, { align: 'center' }));
+                }
+            });
+        }
+        else {
+            const n = d.badges.length;
+            const bw = (inner - S.badgeGapExpanded * (n - 1)) / n;
+            d.badges.forEach((b, i) => {
+                const bx = S.padding + i * (bw + S.badgeGapExpanded);
+                ops.push(...filledRoundedRect(bx, y, bw, S.badgeHeight, S.badgeRadius, b.background));
+                if (d.showGlobe)
+                    ops.push(...globeOps(bx + bw / 2, y + S.badgeHeight / 2, S.globeSize, S.globeColor));
+                else {
+                    const text = truncate(ctx.fonts, b.text, S.badgeFontSize, bw - 10);
+                    ops.push(...ctx.fonts.textOps(ctx.page, text, S.badgeFontSize, S.badgeTextColor, bx + bw / 2, y + S.badgeHeight / 2 + S.badgeFontSize * 0.35, { align: 'center' }));
+                }
+            });
+        }
+        y += badgesBlock;
+    }
+    if (d.name !== null) {
+        const text = truncate(ctx.fonts, d.name, S.nameFontSize, inner);
+        ops.push(...ctx.fonts.textOps(ctx.page, text, S.nameFontSize, S.nameColor, W / 2, y + S.nameGap + S.nameFontSize * 0.95, { align: 'center' }));
+    }
+    return ops;
+};
+const OBJECT_INSET = 4;
+const OBJECT_BAR_HEIGHT = 20;
+const objectTileOps = (ctx, c) => {
+    const x = OBJECT_INSET;
+    const y = OBJECT_INSET;
+    const w = SQUARE - 2 * OBJECT_INSET;
+    const h = SQUARE - 2 * OBJECT_INSET;
+    const ops = [];
+    const thumb = ctx.thumbnail;
+    if (!thumb) {
+        ops.push(...filledRoundedRect(x, y, w, h, CARD_RADIUS, GeneralColors.grey2));
+        const name = truncate(ctx.fonts, c.name || 'Object removed', 9, w - 8);
+        ops.push(...ctx.fonts.textOps(ctx.page, name, 9, GeneralColors.grey4, SQUARE / 2, SQUARE / 2 + 3, { align: 'center' }));
+        return ops;
+    }
+    // Thumbnail, cover-fit and clipped to the rounded card.
+    const scale = Math.max(w / thumb.width, h / thumb.height);
+    const iw = thumb.width * scale;
+    const ih = thumb.height * scale;
+    ops.push(pushGraphicsState(), ...roundedRectPathOps(x, y, w, h, CARD_RADIUS), clip(), endPath(), ...imageOps(thumb.name, x + (w - iw) / 2, y + (h - ih) / 2, iw, ih), popGraphicsState());
+    // Footer bar by object type: a layout group gets the magenta bar with white
+    // ink, a plain photo/background none, every document a white bar with dark ink.
+    const type = c.fileType;
+    const bar = type === FileUploadType.LayoutGroup
+        ? { fill: FormulaColors.darkPurple, ink: GeneralColors.white }
+        : type === FileUploadType.Background || type === undefined
+            ? null
+            : { fill: GeneralColors.white, ink: GeneralColors.darkGrey };
+    if (bar) {
+        ops.push(pushGraphicsState(), ...roundedRectPathOps(x, y, w, h, CARD_RADIUS), clip(), endPath(), ...fillStateOps(bar.fill), rectangle(x, y + h - OBJECT_BAR_HEIGHT, w, OBJECT_BAR_HEIGHT), fill(), popGraphicsState());
+        const name = truncate(ctx.fonts, c.name, 9, w - 8);
+        ops.push(...ctx.fonts.textOps(ctx.page, name, 9, bar.ink, SQUARE / 2, y + h - OBJECT_BAR_HEIGHT / 2 + 3, { align: 'center' }));
+    }
+    return ops;
+};
+const planeChipOps = (ctx, c) => {
+    const ops = filledRoundedRect(0, 0, SQUARE, SQUARE, 8, TileColors.activeBlue);
+    const usable = SQUARE - 22;
+    const text = c.unit ? `${c.value} ${c.unit}` : c.value;
+    ops.push(...valueRowOps(ctx, text, SQUARE / 2, SQUARE / 2, GeneralColors.white, usable, SQUARE));
+    return ops;
+};
+const instructionsTileOps = (ctx, c) => {
+    const ops = filledRoundedRect(0, 0, SQUARE, SQUARE, 8, c.backgroundColor || '#EDEDED');
+    const color = c.textColor || '#2D3843';
+    const size = 11;
+    const maxW = SQUARE - 16;
+    // Word-wrap to at most four lines, like numberOfLines={4}.
+    const lines = [];
+    let current = '';
+    for (const word of c.text.split(/\s+/).filter(Boolean)) {
+        const next = current ? `${current} ${word}` : word;
+        if (ctx.fonts.width(next, size) <= maxW || !current)
+            current = next;
+        else {
+            lines.push(current);
+            current = word;
+        }
+        if (lines.length === 4)
+            break;
+    }
+    if (current && lines.length < 4)
+        lines.push(current);
+    const lh = size * 1.25;
+    const top = SQUARE / 2 - (lines.length * lh) / 2;
+    lines.forEach((line, i) => {
+        ops.push(...ctx.fonts.textOps(ctx.page, truncate(ctx.fonts, line, size, maxW), size, color, SQUARE / 2, top + i * lh + size * 0.9, { align: 'center' }));
+    });
+    return ops;
+};
+/** Operators for a tile in DESIGN space. */
+export const tileDesignOps = (ctx, content) => {
+    switch (content.kind) {
+        case 'measurement':
+            return measurementTileOps(ctx, content);
+        case 'empty':
+            return emptyTileOps(ctx, content);
+        case 'literal':
+            return literalTileOps(ctx, content);
+        case 'header':
+            return headerTileOps(ctx, content);
+        case 'object':
+            return objectTileOps(ctx, content);
+        case 'planeDimension':
+            return planeChipOps(ctx, content);
+        case 'instructions':
+            return instructionsTileOps(ctx, content);
+    }
+};
+/** Operators for a tile in DOC space: design ops under the footprint matrix. */
+export const tileOps = (ctx, content, footprint) => withMatrix(designToDocMatrix(footprint), tileDesignOps(ctx, content));

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

@@ -0,0 +1,101 @@
+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;
+}
+export interface RenderCanvasToPdfResult {
+    pdf: Uint8Array;
+    pageCount: number;
+    skipped: SkippedItem[];
+}
+export declare class PdfExportError extends Error {
+    readonly code: 'no-pdf-document' | 'page-count-mismatch' | 'page-geometry-mismatch' | 'encrypted' | '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;