@reekon-tools/boldr-utils 1.21.1 → 1.22.0

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

@@ -0,0 +1,39 @@
+import type { AnnotationCanvasState, PlacedMeasurementRef } from '../../types/annotation.js';
+import { DecimalTolerance, FractionalTolerance, Units, type Formula, type Group, type Measurement, type Section } from '../../types/firestore.js';
+import type { EmbeddedImage, ResolvedTileContent } from './types.js';
+/** Fill for a FORM formula-column tile (the job page's purple). */
+export declare const FORMULA_COLUMN_TILE_FILL = "#7B4783";
+/** Fill for a plane-computed length tile (calibration teal). */
+export declare const PLANE_COMPUTED_TILE_FILL = "#0E7490";
+export interface TileFileInfo {
+    name: string;
+    type?: string;
+    thumbnail?: EmbeddedImage;
+}
+export interface TileResolutionContext {
+    canvas: Pick<AnnotationCanvasState, 'planes'>;
+    units: Units;
+    fractionalTolerance?: FractionalTolerance;
+    decimalTolerance?: DecimalTolerance;
+    groups: Group[];
+    sections: Section[];
+    /** Every measurement a tile may reference, by id. */
+    measurementsById: Map<string, Measurement>;
+    formulas?: Formula[];
+    /** Placed object files, by file id. */
+    filesById?: Map<string, TileFileInfo>;
+    /** The canvas file's own group — the fallback source group for a tile. */
+    hostGroupId?: string;
+}
+/**
+ * The tile fill, in measurementTileFill's precedence: unsaved scratch grey-blue,
+ * completed grey, an explicit colour, formula magenta, else tile blue.
+ */
+export declare const measurementTileFillFor: ({ internal, isCompleted, groupFormula, color, }: {
+    internal?: boolean;
+    isCompleted?: boolean;
+    groupFormula?: unknown;
+    color?: string;
+}) => string;
+/** What a placed tile shows, from the documents in `ctx`. */
+export declare const resolveTileContent: (placed: PlacedMeasurementRef, ctx: TileResolutionContext) => ResolvedTileContent;

package/dist/export/pdf/tileContent.js

@@ -0,0 +1,218 @@
+// Resolve what each placed tile SHOWS, from the documents the caller loaded.
+// A pure mirror of the mobile canvas's renderMeasurementStamp branches
+// (skia-annotation.tsx) and the tile components' own rules (measurementTileFill,
+// convertMicrometers, the position labels), so a server render and the screen
+// agree on value, label and fill. No I/O: the caller fetches the docs.
+import { ColumnType, DecimalTolerance, FractionalTolerance, MeasurementType, convertUnitsToReadable, } from '../../types/firestore.js';
+import { describeGroupHeader } from '../../annotation/canvas/groupHeaderLayout.js';
+import { planeDimensionValueUm, planeLengthForPlaced, } from '../../annotation/canvas/planeGeometry.js';
+import { convertMicrometers } from '../../utils/micrometersToUnit.js';
+import { formGroupInputLabel, listGroupMeasurementLabel, } from '../../utils/indexLabels.js';
+import { calculateFormula } from '../../formulas/calculateFormula.js';
+import { applyGroupFormulaUm } from '../../formulas/groupFormula.js';
+import { FormulaColors, GeneralColors, SecondaryColors, TileColors, } from '../../theme/colors.js';
+/** Fill for a FORM formula-column tile (the job page's purple). */
+export const FORMULA_COLUMN_TILE_FILL = '#7B4783';
+/** Fill for a plane-computed length tile (calibration teal). */
+export const PLANE_COMPUTED_TILE_FILL = '#0E7490';
+const isScalarType = (type) => (type ?? MeasurementType.Length) !== MeasurementType.Length;
+/**
+ * The tile fill, in measurementTileFill's precedence: unsaved scratch grey-blue,
+ * completed grey, an explicit colour, formula magenta, else tile blue.
+ */
+export const measurementTileFillFor = ({ internal, isCompleted, groupFormula, color, }) => {
+    if (internal)
+        return SecondaryColors.accentBlue3;
+    if (isCompleted)
+        return GeneralColors.grey3;
+    if (color)
+        return color;
+    if (groupFormula)
+        return FormulaColors.purple;
+    return TileColors.activeBlue;
+};
+const columnOf = (ctx, placed) => {
+    const group = ctx.groups.find((g) => g.id === placed.groupId);
+    const section = ctx.sections.find((s) => s.id === group?.sectionId);
+    const columnIndex = section?.tableConfig.findIndex((c) => c.id === placed.columnId) ?? -1;
+    const column = columnIndex >= 0 ? section?.tableConfig[columnIndex] : undefined;
+    return { group, section, column, columnIndex };
+};
+const columnTileLabels = (ctx, placed) => {
+    const { group, column, columnIndex } = columnOf(ctx, placed);
+    return {
+        topLeftLabel: formGroupInputLabel(columnIndex, group?.groupIndex ?? 0),
+        topRightLabel: convertUnitsToReadable(ctx.units) ?? '',
+        bottomLabel: column?.name ?? 'Measurement',
+    };
+};
+const tileGroup = (ctx, placed) => ctx.groups.find((g) => g.id === (placed.groupId ?? ctx.hostGroupId));
+const convert = (ctx, um, unit, device) => convertMicrometers(um, unit, ctx.fractionalTolerance ?? FractionalTolerance.Sixteenth, ctx.decimalTolerance ?? DecimalTolerance.Hundredth, device);
+const measurementContent = (ctx, placed, m, column, columnIndex) => {
+    const group = tileGroup(ctx, placed);
+    const groupIndex = group?.groupIndex ?? 0;
+    const positionLabel = placed.columnId
+        ? formGroupInputLabel(columnIndex, groupIndex)
+        : listGroupMeasurementLabel(m.deviceMeasurementNumber, groupIndex);
+    // MeasurementTile shows the measurement's own label first, then the host's
+    // `label` prop (the override, else the column name).
+    const label = m.label || placed.labelOverride || column?.name;
+    const fill = measurementTileFillFor({
+        internal: m.fileId != null,
+        isCompleted: !!m.isCompleted,
+        groupFormula: group?.formula,
+    });
+    const formulaBar = fill === FormulaColors.purple;
+    // Angles and unitless numbers are stored as typed — never converted.
+    const scalar = column?.type === ColumnType.Angle || (!column && isScalarType(m.type));
+    if (scalar) {
+        const suffix = column?.type === ColumnType.Angle || m.type === MeasurementType.Angle
+            ? '°'
+            : '';
+        return {
+            kind: 'measurement',
+            value: `${m.value}${suffix}`,
+            unit: '',
+            positionLabel,
+            label,
+            fill,
+            formulaBar,
+        };
+    }
+    const groupFormula = group?.formula;
+    const unit = placed.unitOverride ?? ctx.units;
+    const formulaUm = groupFormula
+        ? applyGroupFormulaUm(groupFormula, m.value, unit)
+        : null;
+    const um = formulaUm ?? m.value;
+    const converted = convert(ctx, Math.abs(um), unit, formulaUm != null ? undefined : m.device);
+    return {
+        kind: 'measurement',
+        value: converted.value,
+        unit: converted.unit,
+        positionLabel,
+        label,
+        fill,
+        formulaBar,
+        negative: um < 0,
+    };
+};
+/** What a placed tile shows, from the documents in `ctx`. */
+export const resolveTileContent = (placed, ctx) => {
+    // Object tile: the placed file's preview.
+    if (placed.fileId) {
+        const file = ctx.filesById?.get(placed.fileId);
+        return file
+            ? {
+                kind: 'object',
+                name: file.name,
+                fileType: file.type,
+                thumbnail: file.thumbnail,
+            }
+            : { kind: 'object', name: 'Object removed' };
+    }
+    // Group-header chip.
+    if (placed.isGroupHeader) {
+        const group = ctx.groups.find((g) => g.id === placed.groupId);
+        const section = ctx.sections.find((s) => s.id === group?.sectionId);
+        return {
+            kind: 'header',
+            descriptor: describeGroupHeader({
+                group,
+                section,
+                collapsed: !!placed.collapsed,
+            }),
+        };
+    }
+    const { group, section, column, columnIndex } = columnOf(ctx, placed);
+    const columnType = column?.type;
+    // Plane-calibration dimension tile.
+    if (placed.planeEdge) {
+        const plane = ctx.canvas.planes?.find((p) => p.id === placed.planeId);
+        const dimUm = plane ? planeDimensionValueUm(plane, placed.planeEdge) : null;
+        if (dimUm != null) {
+            const c = convert(ctx, dimUm, ctx.units);
+            return { kind: 'planeDimension', value: c.value, unit: c.unit };
+        }
+        return { kind: 'empty' };
+    }
+    if (columnType === ColumnType.Instructions) {
+        const data = (column?.columnData ?? {});
+        return {
+            kind: 'instructions',
+            text: data.text ?? '',
+            textColor: data.textColor,
+            backgroundColor: data.backgroundColor,
+        };
+    }
+    // FORM formula column: the computed output, or the empty tile.
+    if (columnType === ColumnType.Formula) {
+        const formula = ctx.formulas?.find((f) => f.id ===
+            column?.columnData?.formulaId);
+        let result = null;
+        if (group && section && formula) {
+            try {
+                result = calculateFormula(formula, ctx.formulas ?? [], group.columns, section.tableConfig, Array.from(ctx.measurementsById.values()), ctx.units, ctx.fractionalTolerance ?? FractionalTolerance.Sixteenth, ctx.decimalTolerance ?? DecimalTolerance.Tenth);
+            }
+            catch {
+                result = null;
+            }
+        }
+        if (result !== null && result !== '' && Number.isFinite(Number(result))) {
+            const converted = convert(ctx, Math.abs(Number(result)), ctx.units);
+            return {
+                kind: 'measurement',
+                value: converted.value,
+                unit: converted.unit,
+                positionLabel: formGroupInputLabel(columnIndex, group?.groupIndex ?? 0),
+                label: placed.labelOverride ?? column?.name,
+                fill: FORMULA_COLUMN_TILE_FILL,
+                negative: Number(result) < 0,
+            };
+        }
+        return { kind: 'empty', ...columnTileLabels(ctx, placed) };
+    }
+    // Every other non-measurement FORM column stores a literal string.
+    // (Formula and Instructions columns returned above.)
+    const isNonMeasurementColumn = columnType != null &&
+        columnType !== ColumnType.Measurement &&
+        columnType !== ColumnType.Angle;
+    if (isNonMeasurementColumn) {
+        const raw = placed.columnId ? group?.columns?.[placed.columnId] : undefined;
+        return {
+            kind: 'literal',
+            value: raw != null && raw !== '' ? String(raw) : '',
+            ...columnTileLabels(ctx, placed),
+        };
+    }
+    // Bound measurement: by id, else through the FORM group's column slot.
+    let resolved;
+    if (placed.measurementId)
+        resolved = ctx.measurementsById.get(placed.measurementId);
+    if (!resolved && placed.columnId && group) {
+        const mid = group.columns?.[placed.columnId];
+        if (mid)
+            resolved = ctx.measurementsById.get(mid);
+    }
+    if (resolved)
+        return measurementContent(ctx, placed, resolved, column, columnIndex);
+    // Plane-computed length on a calibrated canvas.
+    if (placed.valueSource === 'plane') {
+        const um = planeLengthForPlaced(ctx.canvas.planes, placed);
+        if (um != null) {
+            const c = convert(ctx, Math.abs(um), placed.unitOverride ?? ctx.units);
+            return {
+                kind: 'measurement',
+                value: c.value,
+                unit: c.unit,
+                positionLabel: '',
+                label: placed.labelOverride,
+                fill: PLANE_COMPUTED_TILE_FILL,
+                negative: um < 0,
+            };
+        }
+    }
+    return placed.columnId
+        ? { kind: 'empty', ...columnTileLabels(ctx, placed) }
+        : { kind: 'empty' };
+};

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

@@ -0,0 +1,43 @@
+import { type PDFName, type PDFOperator, type PDFPage } from 'pdf-lib';
+import type { AnnotationCanvasState, PlacedMeasurementRef } from '../../types/annotation.js';
+import type { PdfFonts } from './fonts.js';
+import type { AffineMatrix, DocRect } from './pageMapping.js';
+import type { PdfExportCalibration, ResolvedTileContent } from './types.js';
+/** An image XObject already registered on the page, with its pixel size. */
+export interface PageImage {
+    name: PDFName;
+    width: number;
+    height: number;
+}
+export interface TilePaintContext {
+    page: PDFPage;
+    fonts: PdfFonts;
+    /** Object-tile thumbnail, when the content carries one and it embedded. */
+    thumbnail?: PageImage;
+}
+export interface TileFootprint extends DocRect {
+    /** Design-space box the painter lays out in. */
+    design: {
+        width: number;
+        height: number;
+    };
+}
+/**
+ * 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 declare const tileFootprint: (ref: PlacedMeasurementRef, canvas: Pick<AnnotationCanvasState, "tileDocSize">, calibration: PdfExportCalibration | undefined, fallbackDocEdge: number, design: {
+    width: number;
+    height: number;
+}) => TileFootprint;
+export declare const designBoxFor: (ref: PlacedMeasurementRef, content: ResolvedTileContent) => {
+    width: number;
+    height: number;
+};
+/** Doc ← design matrix for a footprint. */
+export declare const designToDocMatrix: (f: TileFootprint) => AffineMatrix;
+/** Operators for a tile in DESIGN space. */
+export declare const tileDesignOps: (ctx: TilePaintContext, content: ResolvedTileContent) => PDFOperator[];
+/** Operators for a tile in DOC space: design ops under the footprint matrix. */
+export declare const tileOps: (ctx: TilePaintContext, content: ResolvedTileContent, footprint: TileFootprint) => PDFOperator[];