@reekon-tools/boldr-utils 1.26.1 → 1.26.2

package/dist/annotation/canvas/pdfCanvasPages.d.ts

@@ -1,5 +1,5 @@
-import { type AnnotationCanvasState, type AnnotationPdfDocument, type Vec2 } from '../../types/annotation.js';
-import type { PdfCanvasData, PdfCanvasPage, PdfCanvasPageState, PdfCanvasRev, PdfPageRotation } from '../../types/pdfCanvas.js';
+import { type AnnotationCanvasState, type AnnotationPdfDocument, type PlacedMeasurementRef, type Vec2 } from '../../types/annotation.js';
+import type { PdfCanvasData, PdfCanvasPage, PdfCanvasPageState, PdfCanvasPlacement, PdfCanvasTileScales, PdfCanvasRev, PdfPageRotation } from '../../types/pdfCanvas.js';
 export interface PdfPageDisplaySize {
     width: number;
     height: number;
@@ -10,16 +10,19 @@ export declare const pdfPageDisplaySize: (page: Pick<PdfCanvasPage, "width" | "h
 export declare const pdfCanvasPageDocId: (pageIndex: number) => string;
 export declare const emptyPdfCanvasPageState: (pageIndex: number) => PdfCanvasPageState;
 export declare const pdfCanvasPageDocument: (data: PdfCanvasData, pageIndex: number) => AnnotationPdfDocument;
-type PdfCanvasKnobs = Pick<PdfCanvasData, 'tileScaleFactor' | 'tileScaleFactorMobile' | 'headerTileScaleFactor' | 'headerTileScaleFactorMobile' | 'tileDocSize'>;
+type PdfCanvasKnobs = PdfCanvasTileScales;
 export declare const pdfCanvasKnobsOf: (source: Partial<PdfCanvasKnobs>) => PdfCanvasKnobs;
 export declare const pdfCanvasKnobsEqual: (a: Partial<PdfCanvasKnobs>, b: Partial<PdfCanvasKnobs>) => boolean;
+export declare const pdfCanvasPageKnobs: (data: Pick<PdfCanvasData, "pageTileScales"> & PdfCanvasKnobs, pageIndex: number) => PdfCanvasKnobs;
 export declare const pageStateToCanvasState: (data: PdfCanvasData, pageState: PdfCanvasPageState | null, pageIndex: number) => AnnotationCanvasState;
 export declare const canvasStateToPageState: (canvas: AnnotationCanvasState, pageIndex: number, stamp: {
     updatedAt: number;
     rev?: PdfCanvasRev;
 }) => PdfCanvasPageState;
+export declare const pdfCanvasPagePlacements: (placed: readonly PlacedMeasurementRef[]) => PdfCanvasPlacement[];
+export declare const pdfCanvasPlacementsOf: (pdfCanvas: Pick<PdfCanvasData, "placementsByPage"> | null | undefined) => PdfCanvasPlacement[];
 export type PdfRotationDelta = 90 | -90 | 180;
 export declare const rotatePointInPage: (p: Vec2, size: PdfPageDisplaySize, delta: PdfRotationDelta) => Vec2;
-export declare const rotatePageState: <T extends Pick<PdfCanvasPageState, "strokes" | "shapes" | "placedMeasurements" | "planes">>(state: T, currentSize: PdfPageDisplaySize, delta: PdfRotationDelta) => T;
+export declare const rotatePageState: <T extends Pick<PdfCanvasPageState, "strokes" | "shapes" | "placedMeasurements" | "planes" | "backgroundImages">>(state: T, currentSize: PdfPageDisplaySize, delta: PdfRotationDelta) => T;
 export declare const rotatePdfCanvasPage: (page: PdfCanvasPage, delta: PdfRotationDelta) => PdfCanvasPage;
 export {};

package/dist/annotation/canvas/pdfCanvasPages.js

@@ -3,6 +3,7 @@
 // AnnotationCanvasState the engine mounts, and the coordinate transform that
 // turns a page's annotations with it when the page is rotated.
 import { createDefaultLayer, createEmptyCanvasState, } from '../../types/annotation.js';
+import { backgroundLayerFullDocRect, backgroundLayersOf, } from './backgroundLayers.js';
 import { textShapeBounds } from './textGeometry.js';
 // Snap any degree value onto the four legal rotations, modulo 360.
 export const normalizePdfRotation = (deg) => {
@@ -58,7 +59,8 @@ const KNOB_KEYS = [
     'headerTileScaleFactorMobile',
     'tileDocSize',
 ];
-// The file-level tile-scale knobs present on a canvas (undefined keys omitted).
+// The tile-scale knobs present on a canvas or knob record (undefined keys
+// omitted).
 export const pdfCanvasKnobsOf = (source) => {
     const out = {};
     for (const key of KNOB_KEYS) {
@@ -69,6 +71,13 @@ export const pdfCanvasKnobsOf = (source) => {
     return out;
 };
 export const pdfCanvasKnobsEqual = (a, b) => KNOB_KEYS.every((key) => a[key] === b[key]);
+// One page's tile-scale knobs: its own `pageTileScales` entry, else the
+// legacy file-wide knobs (files written before scale went per-page, Asana
+// 1218877420681571 — they keep their look until a page's knobs change).
+export const pdfCanvasPageKnobs = (data, pageIndex) => {
+    const own = data.pageTileScales?.[String(pageIndex)];
+    return pdfCanvasKnobsOf(own && typeof own === 'object' ? own : data);
+};
 // The AnnotationCanvasState the editor mounts for one page. A null page state
 // (never annotated) yields an empty canvas over the page.
 export const pageStateToCanvasState = (data, pageState, pageIndex) => {
@@ -81,7 +90,15 @@ export const pageStateToCanvasState = (data, pageState, pageIndex) => {
     });
     return {
         ...base,
-        ...pdfCanvasKnobsOf(data),
+        ...pdfCanvasPageKnobs(data, pageIndex),
+        ...(pageState?.backgroundImages?.length
+            ? {
+                viewport: {
+                    ...base.viewport,
+                    backgroundImages: pageState.backgroundImages,
+                },
+            }
+            : {}),
         layers: pageState && pageState.layers.length > 0 ? pageState.layers : base.layers,
         strokes: pageState?.strokes ?? [],
         shapes: pageState?.shapes ?? [],
@@ -90,18 +107,60 @@ export const pageStateToCanvasState = (data, pageState, pageIndex) => {
     };
 };
 // Inverse of pageStateToCanvasState: the elements to persist for one page.
-// Viewport and pdfDocument are derived and never stored on the page doc.
-export const canvasStateToPageState = (canvas, pageIndex, stamp) => ({
-    schemaVersion: 1,
-    pageIndex,
-    layers: canvas.layers,
-    strokes: canvas.strokes,
-    shapes: canvas.shapes,
-    placedMeasurements: canvas.placedMeasurements,
-    ...(canvas.planes !== undefined ? { planes: canvas.planes } : {}),
-    updatedAt: stamp.updatedAt,
-    ...(stamp.rev ? { rev: stamp.rev } : {}),
-});
+// The viewport's size and pdfDocument are derived from the file record and
+// never stored on the page doc; its image layers are page CONTENT (an
+// expanded image tile lives there) and are.
+export const canvasStateToPageState = (canvas, pageIndex, stamp) => {
+    const backgroundImages = backgroundLayersOf(canvas.viewport);
+    return {
+        schemaVersion: 1,
+        pageIndex,
+        layers: canvas.layers,
+        strokes: canvas.strokes,
+        shapes: canvas.shapes,
+        placedMeasurements: canvas.placedMeasurements,
+        ...(canvas.planes !== undefined ? { planes: canvas.planes } : {}),
+        ...(backgroundImages.length > 0 ? { backgroundImages } : {}),
+        updatedAt: stamp.updatedAt,
+        ...(stamp.rev ? { rev: stamp.rev } : {}),
+    };
+};
+// The measurement bindings of one page's tiles, for
+// `PdfCanvasData.placementsByPage`. Group-header chips, object tiles and
+// unbound tiles (a plane dimension, an unbound "+") bind no measurement and
+// are left out, so an empty list means "nothing placed on this page".
+export const pdfCanvasPagePlacements = (placed) => {
+    const out = [];
+    const seen = new Set();
+    for (const p of placed) {
+        if (!p || p.isGroupHeader || p.fileId)
+            continue;
+        const bound = !!p.measurementId || !!p.measurementPath;
+        if (!bound && !(p.groupId && p.columnId))
+            continue;
+        const entry = {
+            ...(p.measurementId ? { measurementId: p.measurementId } : {}),
+            ...(p.measurementPath ? { measurementPath: p.measurementPath } : {}),
+            ...(p.groupId ? { groupId: p.groupId } : {}),
+            ...(p.columnId ? { columnId: p.columnId } : {}),
+        };
+        const key = JSON.stringify(entry);
+        if (seen.has(key))
+            continue;
+        seen.add(key);
+        out.push(entry);
+    }
+    return out;
+};
+// Every page's measurement bindings on a PdfCanvas file, flattened — what the
+// placed-in-file readers treat exactly like an inline canvas's
+// placedMeasurements.
+export const pdfCanvasPlacementsOf = (pdfCanvas) => {
+    const byPage = pdfCanvas?.placementsByPage;
+    if (!byPage || typeof byPage !== 'object')
+        return [];
+    return Object.values(byPage).flatMap((list) => Array.isArray(list) ? list : []);
+};
 export const rotatePointInPage = (p, size, delta) => {
     switch (normalizePdfRotation(delta)) {
         case 90:
@@ -237,10 +296,30 @@ const rotatePlane = (plane, size, delta) => {
             }),
     };
 };
+// Image layers carry no rotation (a transform is translate + scale), so like
+// text they stay upright: the layer keeps its size and is re-anchored so the
+// centre of its full image turns with the page.
+const rotateBackgroundLayer = (layer, size, delta) => {
+    const full = backgroundLayerFullDocRect(layer);
+    const centre = rotatePointInPage({ x: full.x + full.width / 2, y: full.y + full.height / 2 }, size, delta);
+    return {
+        ...layer,
+        transform: {
+            ...layer.transform,
+            x: centre.x - full.width / 2,
+            y: centre.y - full.height / 2,
+        },
+    };
+};
 // Rewrite every coordinate of a page's state from its current displayed size
 // into the size it will have after turning by `delta`.
 export const rotatePageState = (state, currentSize, delta) => ({
     ...state,
+    ...(state.backgroundImages !== undefined
+        ? {
+            backgroundImages: state.backgroundImages.map((l) => rotateBackgroundLayer(l, currentSize, delta)),
+        }
+        : {}),
     strokes: state.strokes.map((s) => rotateStroke(s, currentSize, delta)),
     shapes: state.shapes.map((s) => rotateShape(s, currentSize, delta)),
     placedMeasurements: state.placedMeasurements.map((p) => rotatePlaced(p, currentSize, delta)),

package/dist/annotation/canvas/tileCalibration.d.ts

@@ -0,0 +1,16 @@
+import type { AnnotationCanvasState, TileScalePlatform } from '../../types/annotation.js';
+import type { PdfCanvasData, PdfCanvasPageState } from '../../types/pdfCanvas.js';
+export declare const computeBaseFitZoom: (canvas: AnnotationCanvasState, width: number, height: number) => number;
+export interface ResolvedTileFactors {
+    tileScaleFactor: number;
+    headerTileScaleFactor: number;
+    fileTileScaleFactor: number;
+}
+export declare const resolveTileFactors: (canvas: AnnotationCanvasState, platform: TileScalePlatform, baseFitZoom: number, hasViewport: boolean) => ResolvedTileFactors;
+export interface TileDocSizes {
+    tileDocSize: number;
+    headerTileDocSize: number;
+    fileTileDocSize: number;
+}
+export declare const tileDocSizesFor: (canvas: AnnotationCanvasState, platform: TileScalePlatform, width: number, height: number) => TileDocSizes;
+export declare const pdfCanvasPageTileDocSizes: (data: PdfCanvasData, pageStates: Partial<Record<number, PdfCanvasPageState>>, platform: TileScalePlatform, width: number, height: number) => Record<number, TileDocSizes>;

package/dist/annotation/canvas/tileCalibration.js

@@ -0,0 +1,91 @@
+// How large tiles are on a canvas, as pure functions — the editor
+// (useAnnotationCanvasState) and the PDF export resolve them the same way.
+//
+// A tile's footprint is base × per-tile `scale` × the platform's document-wide
+// factor, at the canvas's CONTENT-FIT zoom (tiles are doc-constant from there).
+// So how much of the drawing a tile covers depends on the screen the canvas is
+// fitted into: only a client knows its own, and an exporter that wants "the
+// same as on my screen" needs the screen size, not just the stored factors.
+import { backgroundLayerDocRect, backgroundLayersOf, } from './backgroundLayers.js';
+import { pageStateToCanvasState } from './pdfCanvasPages.js';
+import { pdfFirstPageDocRect } from './pdfDocument.js';
+import { resolveFileTileScaleFactor, resolveHeaderTileScaleFactor, resolveTileScaleFactor, tileDocSizeForFactor, tileScaleFromDocSize, } from './stampLayout.js';
+import { fitRectToScreen } from './viewport.js';
+// The content-fit zoom tiles are sized against. A PDF-backed canvas
+// references its FIRST PAGE (not the whole filmstrip — see
+// pdfFirstPageDocRect), whatever image layers sit on it: the PDF is the
+// drawing, and images are placed ON it. Referencing an image instead made
+// every tile on a PDF page jump in size the moment an image object tile was
+// expanded (there was no image before it), and jump back on collapse or
+// delete (Asana 1218877420681573). Otherwise the first image layer — on a
+// photo canvas the photo IS the drawing — else the virtual doc rect.
+export const computeBaseFitZoom = (canvas, width, height) => {
+    if (!(width > 0) || !(height > 0))
+        return 1;
+    const { viewport } = canvas;
+    const pdfFirstPage = viewport.pdfDocument
+        ? pdfFirstPageDocRect(viewport.pdfDocument)
+        : null;
+    const first = pdfFirstPage ? undefined : backgroundLayersOf(viewport)[0];
+    const baseRect = pdfFirstPage ??
+        (first ? backgroundLayerDocRect(first) : null) ?? {
+        x: 0,
+        y: 0,
+        width: viewport.width,
+        height: viewport.height,
+    };
+    return fitRectToScreen(baseRect, width, height).zoom;
+};
+// The platform's three tile-kind factors. A mobile canvas whose own knob is
+// still unset derives its factor from the web-stamped doc-space calibration
+// (tileDocSize) instead of web's raw screen-space value: at the content-fit
+// view its tiles then cover the same area of the drawing the web user saw.
+// The header / object factors ride the same calibration ratio so their
+// relation to the measurement factor survives the override. The first mobile
+// slider commit writes tileScaleFactorMobile and takes over for good.
+export const resolveTileFactors = (canvas, platform, baseFitZoom, hasViewport) => {
+    let tileScaleFactor = resolveTileScaleFactor(canvas, platform);
+    let headerTileScaleFactor = resolveHeaderTileScaleFactor(canvas, platform);
+    let fileTileScaleFactor = resolveFileTileScaleFactor(canvas, platform);
+    if (platform === 'mobile' &&
+        canvas.tileScaleFactorMobile == null &&
+        canvas.tileDocSize != null &&
+        canvas.tileDocSize > 0 &&
+        hasViewport) {
+        const calibrated = tileScaleFromDocSize(canvas.tileDocSize, baseFitZoom);
+        headerTileScaleFactor =
+            tileScaleFactor > 0
+                ? headerTileScaleFactor * (calibrated / tileScaleFactor)
+                : calibrated;
+        fileTileScaleFactor =
+            tileScaleFactor > 0
+                ? fileTileScaleFactor * (calibrated / tileScaleFactor)
+                : calibrated;
+        tileScaleFactor = calibrated;
+    }
+    return { tileScaleFactor, headerTileScaleFactor, fileTileScaleFactor };
+};
+// The doc-space edge a scale-1 tile of each kind covers on `canvas` when it is
+// fitted into a `width` × `height` view on `platform` — what an export needs
+// to draw tiles exactly as that screen shows them.
+export const tileDocSizesFor = (canvas, platform, width, height) => {
+    const zoom = computeBaseFitZoom(canvas, width, height);
+    const f = resolveTileFactors(canvas, platform, zoom, width > 0 && height > 0);
+    return {
+        tileDocSize: tileDocSizeForFactor(f.tileScaleFactor, zoom),
+        headerTileDocSize: tileDocSizeForFactor(f.headerTileScaleFactor, zoom),
+        fileTileDocSize: tileDocSizeForFactor(f.fileTileScaleFactor, zoom),
+    };
+};
+// Every page of a PdfCanvas file, calibrated as the requesting screen shows
+// it: each page mounts as its own canvas with its own knobs (tile scale is per
+// page — Asana 1218877420681571) and its own content-fit zoom, so one
+// calibration taken from the page on screen would mis-size every other page.
+export const pdfCanvasPageTileDocSizes = (data, pageStates, platform, width, height) => {
+    const out = {};
+    for (let i = 0; i < data.document.pages.length; i++) {
+        const canvas = pageStateToCanvasState(data, pageStates[i] ?? null, i);
+        out[i] = tileDocSizesFor(canvas, platform, width, height);
+    }
+    return out;
+};

package/dist/annotation/canvas/useAnnotationCanvasState.js

@@ -1,10 +1,11 @@
 import { useCallback, useEffect, useMemo, useRef, useState } from 'react';
 import { applyPatch, invertPatch, DEFAULT_LAYER_ID, } from '../../types/annotation.js';
-import { resolveHeaderTileScaleFactor, resolveFileTileScaleFactor, resolveTileScaleFactor, stampTileDims, STAMP_TILE_SIZE, tileDocSizeForFactor, tileScaleFromDocSize, } from './stampLayout.js';
+import { stampTileDims, STAMP_TILE_SIZE, tileDocSizeForFactor, } from './stampLayout.js';
 import { SNAP_RADIUS_PX } from './snapGeometry.js';
+import { computeBaseFitZoom, resolveTileFactors } from './tileCalibration.js';
 import { createViewportApi, fitDocRectViewport, fitRectToScreen, panBy, zoomAt, DEFAULT_VIEWPORT, DEFAULT_ZOOM_LIMITS, } from './viewport.js';
-import { computeZoomFloor, pdfFirstPageDocRect } from './pdfDocument.js';
-import { backgroundLayerDocRect, backgroundLayersOf, backgroundLayersUnionRect, } from './backgroundLayers.js';
+import { computeZoomFloor } from './pdfDocument.js';
+import { backgroundLayersOf, backgroundLayersUnionRect, } from './backgroundLayers.js';
 import { buildRemoveMeasurementOps, recomputeAnchor, rectCenter, DEFAULT_LINE_POS, } from './measurementGeometry.js';
 // The viewport that frames the document's content inside a screen rect of the
 // canvas box. When background images are present we fit the union of their
@@ -70,38 +71,6 @@ const computeContentFitRect = (canvas, rect) => {
     };
 };
 const computeContentFit = (canvas, width, height) => computeContentFitRect(canvas, { x: 0, y: 0, width, height });
-// Content-fit zoom of the DOCUMENT alone — the FIRST background layer's
-// rendered rect when present, the document rect otherwise, deliberately
-// ignoring placed tiles — into the full canvas box. This is the stable
-// reference zoom for tile sizing (see tileViewportScale below): at this zoom
-// a tile renders at exactly its slider size. computeContentFitRect's
-// tile-extended union would make the reference move whenever a tile is
-// dragged outside the image (every tile on the canvas would resize); the
-// document rect can't. The reference is pinned to the first layer — never
-// the layer union — for the same reason: adding, dragging, or scaling a
-// SECOND image must not silently resize (and re-hit-test) every placed tile
-// on the canvas. For a single-image doc the first layer's rect is exactly
-// the legacy fit rect, so existing canvases keep their tile sizes.
-const computeBaseFitZoom = (canvas, width, height) => {
-    if (!(width > 0) || !(height > 0))
-        return 1;
-    const { viewport } = canvas;
-    const first = backgroundLayersOf(viewport)[0];
-    // A PDF-backed canvas with no image layers references its FIRST PAGE, not
-    // the whole filmstrip — see pdfFirstPageDocRect for why.
-    const pdfFirstPage = viewport.pdfDocument
-        ? pdfFirstPageDocRect(viewport.pdfDocument)
-        : null;
-    const baseRect = first
-        ? backgroundLayerDocRect(first)
-        : (pdfFirstPage ?? {
-            x: 0,
-            y: 0,
-            width: viewport.width,
-            height: viewport.height,
-        });
-    return fitRectToScreen(baseRect, width, height).zoom;
-};
 // Default leader length (doc units) for a placed measurement when no explicit
 // length is given. A generous fraction of the document width, clamped, so the
 // leader — and its draggable endcaps — stay clear of the value tile at
@@ -191,38 +160,9 @@ export const useAnnotationCanvasState = (props) => {
     // the same area of the image the web user saw. The first mobile slider
     // commit writes tileScaleFactorMobile and takes over for good.
     const tileScalePlatformResolved = tileScalePlatform ?? 'web';
-    let tileScaleFactor = resolveTileScaleFactor(effectiveCanvas, tileScalePlatformResolved);
-    // Group/form header chips carry their own document-wide knob (Asana
-    // 1217570500895543), resolved the same way. With no header knob set it
-    // equals the measurement factor (resolveHeaderTileScaleFactor's fallback) —
-    // the pre-split one-knob behavior.
-    let headerTileScaleFactor = resolveHeaderTileScaleFactor(effectiveCanvas, tileScalePlatformResolved);
-    // Object tiles share the measurement factor — their own knob was retired
-    // (see resolveFileTileScaleFactor), so this always equals tileScaleFactor
-    // and rides the same calibration below.
-    let fileTileScaleFactor = resolveFileTileScaleFactor(effectiveCanvas, tileScalePlatformResolved);
-    if (tileScalePlatformResolved === 'mobile' &&
-        effectiveCanvas.tileScaleFactorMobile == null &&
-        effectiveCanvas.tileDocSize != null &&
-        effectiveCanvas.tileDocSize > 0 &&
-        width > 0 &&
-        height > 0) {
-        const calibrated = tileScaleFromDocSize(effectiveCanvas.tileDocSize, baseFitZoom);
-        // Scale the header factor by the same calibration ratio so its relation
-        // to the measurement factor survives the override: a doc with no header
-        // knob keeps headers exactly at the calibrated measurement factor, and a
-        // doc whose web user set a header knob keeps the same header-to-tile
-        // proportion the web user saw.
-        headerTileScaleFactor =
-            tileScaleFactor > 0
-                ? headerTileScaleFactor * (calibrated / tileScaleFactor)
-                : calibrated;
-        fileTileScaleFactor =
-            tileScaleFactor > 0
-                ? fileTileScaleFactor * (calibrated / tileScaleFactor)
-                : calibrated;
-        tileScaleFactor = calibrated;
-    }
+    // Shared with the PDF export (tileCalibration.ts) so an exported page draws
+    // its tiles exactly as this screen does.
+    const { tileScaleFactor, headerTileScaleFactor, fileTileScaleFactor } = resolveTileFactors(effectiveCanvas, tileScalePlatformResolved, baseFitZoom, width > 0 && height > 0);
     const ctx = useMemo(() => ({
         document: canvas,
         selection,

package/dist/annotation/data/hooks/usePdfCanvasDoc.js

@@ -1,15 +1,19 @@
 import { useCallback, useEffect, useMemo, useRef, useState } from 'react';
 import { applyPatch, createEmptyCanvasState, } from '../../../types/annotation.js';
-import { canvasStateToPageState, pageStateToCanvasState, pdfCanvasKnobsEqual, pdfCanvasKnobsOf, pdfPageDisplaySize, rotatePageState, rotatePdfCanvasPage, } from '../../canvas/pdfCanvasPages.js';
+import { canvasStateToPageState, pageStateToCanvasState, pdfCanvasKnobsEqual, pdfCanvasPagePlacements, pdfCanvasKnobsOf, pdfCanvasPageKnobs, pdfPageDisplaySize, rotatePageState, rotatePdfCanvasPage, } from '../../canvas/pdfCanvasPages.js';
 import { useAnnotationData } from '../AnnotationDataContext.js';
 import { annotationScopeKey, } from '../AnnotationDataProvider.js';
+import { backgroundLayersOf } from '../../canvas/backgroundLayers.js';
 import { createCoalescedRunner } from '../coalescedRunner.js';
 import { useAnnotationDoc } from './useAnnotationDoc.js';
 const makeClientId = () => `${Date.now().toString(36)}-${Math.floor(Math.random() * 0x100000000).toString(36)}`;
 const hasContent = (canvas) => canvas.strokes.length > 0 ||
     canvas.shapes.length > 0 ||
     canvas.placedMeasurements.length > 0 ||
-    (canvas.planes?.length ?? 0) > 0;
+    (canvas.planes?.length ?? 0) > 0 ||
+    // An expanded image tile is page content too (PdfCanvasPageState
+    // .backgroundImages) — a page holding only one must still turn with it.
+    backgroundLayersOf(canvas.viewport).length > 0;
 // Drop undefined keys (Firestore — RN in particular — rejects them) and detach
 // the persisted payload from the working state's object identities.
 const jsonClone = (value) => JSON.parse(JSON.stringify(value));
@@ -120,11 +124,21 @@ export const usePdfCanvasDoc = (options) => {
                     values: [target.pageIndex],
                 };
             }
+            // The page's measurement bindings, for the job grid's placed-in-file
+            // link (Asana 1218877420681569). Only this page's entry is written,
+            // and only when it changed.
+            const placements = pdfCanvasPagePlacements(state.placedMeasurements);
+            const pageKey = String(target.pageIndex);
+            const previous = target.pdfCanvas.placementsByPage?.[pageKey] ?? [];
+            if (JSON.stringify(placements) !== JSON.stringify(previous)) {
+                patch[`fileData.pdfCanvas.placementsByPage.${pageKey}`] = placements;
+            }
+            // Tile scale is per page (Asana 1218877420681571): write this page's
+            // complete knob set, only when it moved. The legacy file-wide knobs
+            // are left alone — they stay the fallback for pages never re-scaled.
             const knobs = pdfCanvasKnobsOf(target.canvas);
-            if (!pdfCanvasKnobsEqual(knobs, pdfCanvasKnobsOf(target.pdfCanvas))) {
-                for (const [key, value] of Object.entries(knobs)) {
-                    patch[`fileData.pdfCanvas.${key}`] = value;
-                }
+            if (!pdfCanvasKnobsEqual(knobs, pdfCanvasPageKnobs(target.pdfCanvas, target.pageIndex))) {
+                patch[`fileData.pdfCanvas.pageTileScales.${pageKey}`] = knobs;
             }
             if (Object.keys(patch).length > 0) {
                 await provider.update(currentScope, currentFileId, patch);
@@ -292,7 +306,10 @@ export const usePdfCanvasDoc = (options) => {
         // Knobs the flush just wrote may not have echoed back yet; carry them.
         const nextData = {
             ...data,
-            ...pdfCanvasKnobsOf(canvas),
+            pageTileScales: {
+                ...data.pageTileScales,
+                [String(index)]: pdfCanvasKnobsOf(canvas),
+            },
             document: { ...data.document, pages },
         };
         setStatus('saving');

package/dist/export/pdf/renderCanvasToPdf.js

@@ -12,7 +12,7 @@
 //    /Rotate and the page matrix.
 import { EncryptedPDFError, PDFDocument, degrees, } from 'pdf-lib';
 import { backgroundLayersOf } from '../../annotation/canvas/backgroundLayers.js';
-import { effectivePageRotation, pdfPageDisplaySize, } from '../../annotation/canvas/pdfCanvasPages.js';
+import { effectivePageRotation, pdfCanvasPageKnobs, pdfPageDisplaySize, } from '../../annotation/canvas/pdfCanvasPages.js';
 import { fitRectToScreen } from '../../annotation/canvas/viewport.js';
 import { STAMP_TILE_SIZE } from '../../annotation/canvas/stampLayout.js';
 import { clipRectOps, withMatrix } from './emit.js';
@@ -174,7 +174,7 @@ const renderJobs = async (doc, jobs, options, skipped) => {
         const onPage = (b) => b !== null && rectsIntersect(b, rect);
         const hiddenLayerIds = new Set(job.layerDefs.filter((l) => l.visible === false).map((l) => l.id));
         const visible = (layerId) => !hiddenLayerIds.has(layerId);
-        const footprintFor = (placed, content) => tileFootprint(placed, { tileDocSize: job.tileDocSize }, options.calibration, fallbackDocEdge, designBoxFor(placed, content));
+        const footprintFor = (placed, content) => tileFootprint(placed, { tileDocSize: job.tileDocSize }, job.calibration ?? options.calibration, fallbackDocEdge, designBoxFor(placed, content));
         const contentOf = (placed) => tileContent.get(placed.id) ?? { kind: 'empty' };
         if (options.mode === 'flatten') {
             // Everything into the page's content stream, under one matrix + clip.
@@ -363,18 +363,20 @@ export const renderPdfCanvasToPdf = async (input) => {
             box,
             rotation: effective,
             rect: { x: 0, y: 0, width: display.width, height: display.height },
-            layers: [],
+            // The page's image layers (expanded image tiles), in page doc space.
+            layers: state?.backgroundImages ?? [],
             layerDefs: state?.layers ?? [],
             strokes: state?.strokes ?? [],
             shapes: state?.shapes ?? [],
             placed: state?.placedMeasurements ?? [],
-            tileDocSize: pdfCanvas.tileDocSize,
+            tileDocSize: pdfCanvasPageKnobs(pdfCanvas, i).tileDocSize,
+            calibration: input.pageCalibrations?.[i],
         });
     });
     const skipped = [];
     const annotationCount = await renderJobs(doc, jobs, {
         resolveTile: input.resolveTile,
-        layerImages: {},
+        layerImages: input.layerImages ?? {},
         calibration: input.calibration,
         primaryFont: input.primaryFont,
         mode: input.mode ?? 'annotations',

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

@@ -106,6 +106,17 @@ export interface RenderPdfCanvasToPdfInput {
     /** Page docs by page index; a page without one is exported un-annotated. */
     pageStates: Partial<Record<number, PdfCanvasPageState>>;
     resolveTile: (ref: PlacedMeasurementRef) => ResolvedTileContent | undefined;
+    /**
+     * Decoded bytes per image layer id, across every page's
+     * `backgroundImages`. Missing → that layer is skipped.
+     */
+    layerImages?: Record<string, EmbeddedImage>;
+    /**
+     * Per-page calibration (pdfCanvasPageTileDocSizes). Tile scale is per page,
+     * so a page's entry wins over `calibration`, which then only covers pages
+     * without one (and requests from clients that predate the split).
+     */
+    pageCalibrations?: Partial<Record<number, PdfExportCalibration>>;
     calibration?: PdfExportCalibration;
     primaryFont: Uint8Array;
     mode?: 'annotations' | 'flatten';

package/dist/exports.d.ts

@@ -7,6 +7,7 @@ export * from './types/firestore.js';
 export * from './types/layout.js';
 export * from './types/annotation.js';
 export * from './types/pdfCanvas.js';
+export { computeBaseFitZoom, resolveTileFactors, tileDocSizesFor, pdfCanvasPageTileDocSizes, type ResolvedTileFactors, type TileDocSizes, } from './annotation/canvas/tileCalibration.js';
 export { getToleranceColor, calculateDeviationPercentage, isWithinTolerance, generateToleranceGradient, createDefaultToleranceThresholds, DEFAULT_TOLERANCE_COLORS, type ToleranceThreshold, type ToleranceConfig, } from './utils/tolerance.js';
 export { GeneralColors, SecondaryColors, FormColors, TileColors, FormulaColors, YellowColors, RedColors, GreenColors, tailwindColors, } from './theme/colors.js';
 export { DEFAULT_GROUP_INDEX, isDefaultGroup, findDefaultGroup, isFormGroupCompleted, } from './utils/groups.js';
@@ -39,7 +40,7 @@ export { STAMP_TILE_SIZE, GROUP_HEADER_TILE_WIDTH, GROUP_HEADER_TILE_HEIGHT, GRO
 export { GROUP_HEADER_STYLE, describeGroupHeader, groupHeaderSignature, type GroupHeaderBadge, type GroupHeaderDescriptor, } from './annotation/canvas/groupHeaderLayout.js';
 export { createViewportApi, fitToScreen, fitRectToScreen, fitDocRectViewport, imageDocRect, panBy, zoomAt, DEFAULT_VIEWPORT, DEFAULT_ZOOM_LIMITS, type ViewportApi, type ViewportState, type ZoomLimits, } from './annotation/canvas/viewport.js';
 export { DEFAULT_PDF_PAGE_GAP, DEFAULT_MIN_ZOOM, DEFAULT_MAX_ZOOM, makePdfDocumentId, createPdfDocument, pdfPageDocRects, pdfDocumentExtent, pdfFirstPageDocRect, computeZoomFloor, type PdfDocRect, } from './annotation/canvas/pdfDocument.js';
-export { normalizePdfRotation, effectivePageRotation, pdfPageDisplaySize, pdfCanvasPageDocId, emptyPdfCanvasPageState, pdfCanvasPageDocument, pdfCanvasKnobsOf, pdfCanvasKnobsEqual, pageStateToCanvasState, canvasStateToPageState, rotatePointInPage, rotatePageState, rotatePdfCanvasPage, type PdfPageDisplaySize, type PdfRotationDelta, } from './annotation/canvas/pdfCanvasPages.js';
+export { normalizePdfRotation, effectivePageRotation, pdfPageDisplaySize, pdfCanvasPageDocId, emptyPdfCanvasPageState, pdfCanvasPageDocument, pdfCanvasKnobsOf, pdfCanvasKnobsEqual, pageStateToCanvasState, canvasStateToPageState, rotatePointInPage, rotatePageState, rotatePdfCanvasPage, pdfCanvasPagePlacements, pdfCanvasPlacementsOf, pdfCanvasPageKnobs, type PdfPageDisplaySize, type PdfRotationDelta, } from './annotation/canvas/pdfCanvasPages.js';
 export { LEGACY_BACKGROUND_LAYER_ID, BACKGROUND_PLACEMENT_GAP_RATIO, backgroundLayersOf, backgroundLayerIsLocked, isBackgroundLayerLocked, defaultBackgroundLayerLocked, backgroundLayerDocRect, backgroundLayersUnionRect, placeNewBackgroundLayer, } from './annotation/canvas/backgroundLayers.js';
 export { fileTileImageSource, expandFileTileToBackground, collapseBackgroundToFileTile, type FileTileImageSource, } from './annotation/canvas/fileTileSwap.js';
 export { createPenTool, type PenToolOptions, } from './annotation/canvas/tools/penTool.js';

package/dist/exports.js

@@ -11,6 +11,7 @@ export * from './types/firestore.js';
 export * from './types/layout.js';
 export * from './types/annotation.js';
 export * from './types/pdfCanvas.js';
+export { computeBaseFitZoom, resolveTileFactors, tileDocSizesFor, pdfCanvasPageTileDocSizes, } from './annotation/canvas/tileCalibration.js';
 export { getToleranceColor, calculateDeviationPercentage, isWithinTolerance, generateToleranceGradient, createDefaultToleranceThresholds, DEFAULT_TOLERANCE_COLORS, } from './utils/tolerance.js';
 // Shared color palette (canonical source for both apps' brand colors).
 export { GeneralColors, SecondaryColors, FormColors, TileColors, FormulaColors, YellowColors, RedColors, GreenColors, tailwindColors, } from './theme/colors.js';
@@ -45,7 +46,7 @@ export { STAMP_TILE_SIZE, GROUP_HEADER_TILE_WIDTH, GROUP_HEADER_TILE_HEIGHT, GRO
 export { GROUP_HEADER_STYLE, describeGroupHeader, groupHeaderSignature, } from './annotation/canvas/groupHeaderLayout.js';
 export { createViewportApi, fitToScreen, fitRectToScreen, fitDocRectViewport, imageDocRect, panBy, zoomAt, DEFAULT_VIEWPORT, DEFAULT_ZOOM_LIMITS, } from './annotation/canvas/viewport.js';
 export { DEFAULT_PDF_PAGE_GAP, DEFAULT_MIN_ZOOM, DEFAULT_MAX_ZOOM, makePdfDocumentId, createPdfDocument, pdfPageDocRects, pdfDocumentExtent, pdfFirstPageDocRect, computeZoomFloor, } from './annotation/canvas/pdfDocument.js';
-export { normalizePdfRotation, effectivePageRotation, pdfPageDisplaySize, pdfCanvasPageDocId, emptyPdfCanvasPageState, pdfCanvasPageDocument, pdfCanvasKnobsOf, pdfCanvasKnobsEqual, pageStateToCanvasState, canvasStateToPageState, rotatePointInPage, rotatePageState, rotatePdfCanvasPage, } from './annotation/canvas/pdfCanvasPages.js';
+export { normalizePdfRotation, effectivePageRotation, pdfPageDisplaySize, pdfCanvasPageDocId, emptyPdfCanvasPageState, pdfCanvasPageDocument, pdfCanvasKnobsOf, pdfCanvasKnobsEqual, pageStateToCanvasState, canvasStateToPageState, rotatePointInPage, rotatePageState, rotatePdfCanvasPage, pdfCanvasPagePlacements, pdfCanvasPlacementsOf, pdfCanvasPageKnobs, } from './annotation/canvas/pdfCanvasPages.js';
 export { LEGACY_BACKGROUND_LAYER_ID, BACKGROUND_PLACEMENT_GAP_RATIO, backgroundLayersOf, backgroundLayerIsLocked, isBackgroundLayerLocked, defaultBackgroundLayerLocked, backgroundLayerDocRect, backgroundLayersUnionRect, placeNewBackgroundLayer, } from './annotation/canvas/backgroundLayers.js';
 export { fileTileImageSource, expandFileTileToBackground, collapseBackgroundToFileTile, } from './annotation/canvas/fileTileSwap.js';
 export { createPenTool, } from './annotation/canvas/tools/penTool.js';

package/dist/server.d.ts

@@ -6,7 +6,8 @@ export * from './types/firestore.js';
 export * from './types/layout.js';
 export * from './types/annotation.js';
 export * from './types/pdfCanvas.js';
-export { normalizePdfRotation, effectivePageRotation, pdfPageDisplaySize, pdfCanvasPageDocId, pageStateToCanvasState, rotatePageState, type PdfPageDisplaySize, type PdfRotationDelta, } from './annotation/canvas/pdfCanvasPages.js';
+export { computeBaseFitZoom, resolveTileFactors, tileDocSizesFor, pdfCanvasPageTileDocSizes, type ResolvedTileFactors, type TileDocSizes, } from './annotation/canvas/tileCalibration.js';
+export { normalizePdfRotation, effectivePageRotation, pdfPageDisplaySize, pdfCanvasPageDocId, pageStateToCanvasState, rotatePageState, pdfCanvasPagePlacements, pdfCanvasPlacementsOf, pdfCanvasPageKnobs, type PdfPageDisplaySize, type PdfRotationDelta, } from './annotation/canvas/pdfCanvasPages.js';
 export { getToleranceColor, getToleranceSecondaryColor, calculateDeviationPercentage, isWithinTolerance, generateToleranceGradient, createDefaultToleranceThresholds, DEFAULT_TOLERANCE_COLORS, DEFAULT_TOLERANCE_SECONDARY_COLORS, type ToleranceThreshold, type ToleranceConfig, } from './utils/tolerance.js';
 export { DEFAULT_GROUP_INDEX, isDefaultGroup, findDefaultGroup, isFormGroupCompleted, } from './utils/groups.js';
 export { ROLE_RANK, EMPTY_GRANTS, normalizeRole, roleAtLeast, effectiveRole, canView, canEdit, canManage, canManageOrg, isGuest, groupGrants, resolveAccess, type MaybeRole, type GroupedGrants, type ResolvedAccess, } from './utils/permissions.js';

package/dist/server.js

@@ -11,7 +11,8 @@ export * from './types/firestore.js';
 export * from './types/layout.js';
 export * from './types/annotation.js';
 export * from './types/pdfCanvas.js';
-export { normalizePdfRotation, effectivePageRotation, pdfPageDisplaySize, pdfCanvasPageDocId, pageStateToCanvasState, rotatePageState, } from './annotation/canvas/pdfCanvasPages.js';
+export { computeBaseFitZoom, resolveTileFactors, tileDocSizesFor, pdfCanvasPageTileDocSizes, } from './annotation/canvas/tileCalibration.js';
+export { normalizePdfRotation, effectivePageRotation, pdfPageDisplaySize, pdfCanvasPageDocId, pageStateToCanvasState, rotatePageState, pdfCanvasPagePlacements, pdfCanvasPlacementsOf, pdfCanvasPageKnobs, } from './annotation/canvas/pdfCanvasPages.js';
 export { getToleranceColor, getToleranceSecondaryColor, calculateDeviationPercentage, isWithinTolerance, generateToleranceGradient, createDefaultToleranceThresholds, DEFAULT_TOLERANCE_COLORS, DEFAULT_TOLERANCE_SECONDARY_COLORS, } from './utils/tolerance.js';
 export { DEFAULT_GROUP_INDEX, isDefaultGroup, findDefaultGroup, isFormGroupCompleted, } from './utils/groups.js';
 export { ROLE_RANK, EMPTY_GRANTS, normalizeRole, roleAtLeast, effectiveRole, canView, canEdit, canManage, canManageOrg, isGuest, groupGrants, resolveAccess, } from './utils/permissions.js';

package/dist/types/pdfCanvas.d.ts

@@ -1,4 +1,4 @@
-import type { AnnotationLayer, AnnotationShape, AnnotationStroke, PlacedMeasurementRef, PlaneCalibration } from './annotation.js';
+import type { AnnotationBackgroundLayer, AnnotationLayer, AnnotationShape, AnnotationStroke, PlacedMeasurementRef, PlaneCalibration } from './annotation.js';
 export type PdfPageRotation = 0 | 90 | 180 | 270;
 export interface PdfCanvasPage {
     width: number;
@@ -23,8 +23,18 @@ export interface PdfCanvasData {
     headerTileScaleFactor?: number;
     headerTileScaleFactorMobile?: number;
     tileDocSize?: number;
+    pageTileScales?: Record<string, PdfCanvasTileScales>;
     annotatedPages: number[];
+    placementsByPage?: Record<string, PdfCanvasPlacement[]>;
 }
+export interface PdfCanvasTileScales {
+    tileScaleFactor?: number;
+    tileScaleFactorMobile?: number;
+    headerTileScaleFactor?: number;
+    headerTileScaleFactorMobile?: number;
+    tileDocSize?: number;
+}
+export type PdfCanvasPlacement = Pick<PlacedMeasurementRef, 'measurementId' | 'measurementPath' | 'groupId' | 'columnId'>;
 export interface PdfCanvasPageState {
     schemaVersion: 1;
     pageIndex: number;
@@ -33,6 +43,7 @@ export interface PdfCanvasPageState {
     shapes: AnnotationShape[];
     placedMeasurements: PlacedMeasurementRef[];
     planes?: PlaneCalibration[];
+    backgroundImages?: AnnotationBackgroundLayer[];
     updatedAt: number;
     rev?: PdfCanvasRev;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@reekon-tools/boldr-utils",
-  "version": "1.26.1",
+  "version": "1.26.2",
   "description": "Shared utilities for formulas and measurement conversion used in Reekon apps",
   "author": "REEKON Tools",
   "license": "MIT",

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;