@reekon-tools/boldr-utils 1.21.1 → 1.22.0

package/dist/annotation/canvas/AnnotationCanvasSkia.js

@@ -10,17 +10,9 @@ import { BackgroundLayerElement } from './elements/BackgroundImageElement.js';
 import { PlaneElement, PLANE_CHROME_COLOR, PLANE_GRID_COLOR, PLANE_GRID_OPACITY, PLANE_GRID_WIDTH, PLANE_OUTLINE_WIDTH, } from './elements/PlaneElement.js';
 import { ShapeElement } from './elements/ShapeElement.js';
 import { StrokeElement } from './elements/StrokeElement.js';
-// Default visual constants for the measurement-annotation line (the tile itself
-// is a fixed-size overlay; only the line lives in Skia). Width is in doc units,
-// so it scales with zoom like the drawn line/arrow shapes. These are fallbacks:
-// a placed annotation may override them via `lineColor`/`lineWidth`/`lineCap`.
-// The leader line defaults to the medium width preset so it reads clearly
-// against the document; the rectangle border stays thinner (it outlines a
-// region rather than pointing at one).
-const MEASUREMENT_LINE_COLOR = '#0066FF';
-const MEASUREMENT_LINE_WIDTH = 16;
-const MEASUREMENT_RECT_WIDTH = 2;
-// Endpoint handle color — constant selection chrome, independent of the (now
+import { MEASUREMENT_LINE_COLOR, MEASUREMENT_LINE_WIDTH, MEASUREMENT_RECT_WIDTH, } from './measurementLineStyle.js';
+// The measurement-line defaults live in measurementLineStyle.ts (shared with
+// the PDF exporter). Endpoint handle color — constant selection chrome, independent of the (now
 // editable) line color so the handles stay legible on any line color.
 const MEASUREMENT_HANDLE_COLOR = '#0066FF';
 // Selection bounding box for strokes/shapes (measurements get handles instead).

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

@@ -0,0 +1,3 @@
+export declare const MEASUREMENT_LINE_COLOR = "#0066FF";
+export declare const MEASUREMENT_LINE_WIDTH = 16;
+export declare const MEASUREMENT_RECT_WIDTH = 2;

package/dist/annotation/canvas/measurementLineStyle.js

@@ -0,0 +1,14 @@
+// Default visual constants for the measurement-annotation line and rectangle
+// (the `placement: 'line'` / `'rectangle'` variants of PlacedMeasurementRef).
+// Widths are in doc units, so they scale with zoom like the drawn shapes. A
+// placed annotation may override them via `lineColor` / `lineWidth` /
+// `lineCap`. Skia-free so the PDF exporter (export/pdf) and the Skia scene
+// (AnnotationCanvasSkia) read ONE source — a change here re-styles both the
+// screen and the exported page.
+//
+// The leader line defaults to the medium width preset so it reads clearly
+// against the document; the rectangle border stays thinner (it outlines a
+// region rather than pointing at one).
+export const MEASUREMENT_LINE_COLOR = '#0066FF';
+export const MEASUREMENT_LINE_WIDTH = 16;
+export const MEASUREMENT_RECT_WIDTH = 2;

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

@@ -0,0 +1,7 @@
+import { type RGB } from 'pdf-lib';
+export interface ParsedColor {
+    rgb: RGB;
+    /** 0..1. Absent alpha parses as 1. */
+    alpha: number;
+}
+export declare const parseHexColor: (input: string | undefined) => ParsedColor;

package/dist/export/pdf/color.js

@@ -0,0 +1,39 @@
+// Hex colour parsing for the PDF emitter. The canvas stores colours as CSS hex
+// strings (`#RGB`, `#RRGGBB`, `#RRGGBBAA`); pdf-lib wants 0..1 components and
+// PDF carries alpha separately (an ExtGState), so the two are split here.
+import { rgb } from 'pdf-lib';
+const BLACK = { rgb: rgb(0, 0, 0), alpha: 1 };
+const channel = (hex, i, width) => {
+    const raw = hex.slice(i, i + width);
+    const v = parseInt(width === 1 ? raw + raw : raw, 16);
+    return Number.isNaN(v) ? 0 : v / 255;
+};
+export const parseHexColor = (input) => {
+    if (!input)
+        return BLACK;
+    const hex = input.trim().replace(/^#/, '');
+    switch (hex.length) {
+        case 3:
+            return {
+                rgb: rgb(channel(hex, 0, 1), channel(hex, 1, 1), channel(hex, 2, 1)),
+                alpha: 1,
+            };
+        case 4:
+            return {
+                rgb: rgb(channel(hex, 0, 1), channel(hex, 1, 1), channel(hex, 2, 1)),
+                alpha: channel(hex, 3, 1),
+            };
+        case 6:
+            return {
+                rgb: rgb(channel(hex, 0, 2), channel(hex, 2, 2), channel(hex, 4, 2)),
+                alpha: 1,
+            };
+        case 8:
+            return {
+                rgb: rgb(channel(hex, 0, 2), channel(hex, 2, 2), channel(hex, 4, 2)),
+                alpha: channel(hex, 6, 2),
+            };
+        default:
+            return BLACK;
+    }
+};

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

@@ -0,0 +1,37 @@
+import { LineCapStyle, type PDFName, type PDFOperator } from 'pdf-lib';
+import type { StrokeCap, Vec2 } from '../../types/annotation.js';
+import type { AffineMatrix } from './pageMapping.js';
+export declare const withMatrix: (m: AffineMatrix, ops: PDFOperator[]) => PDFOperator[];
+/** Flip back to y-up at (x, y): text and images are drawn upright inside it. */
+export declare const uprightAt: (x: number, y: number) => AffineMatrix;
+export declare const lineCapOf: (cap: StrokeCap | undefined) => LineCapStyle;
+export interface StrokeStyle {
+    color: string;
+    width: number;
+    cap?: StrokeCap;
+    join?: 'round' | 'miter';
+    dash?: boolean;
+    /** ExtGState resource name carrying the element's opacity, if any. */
+    graphicsState?: PDFName;
+}
+/** Operators that set the stroking state for a Skia-style stroked paint. */
+export declare const strokeStateOps: (s: StrokeStyle) => PDFOperator[];
+export declare const fillStateOps: (color: string, graphicsState?: PDFName) => PDFOperator[];
+/** Path construction for a polyline over `points`; no painting operator. */
+export declare const polylinePathOps: (points: readonly Vec2[], close?: boolean) => PDFOperator[];
+/** Same, over the flat [x, y, x, y, …] array strokes store. */
+export declare const flatPolylinePathOps: (points: readonly number[]) => PDFOperator[];
+export declare const circlePathOps: (cx: number, cy: number, r: number) => PDFOperator[];
+export declare const rectPathOps: (x: number, y: number, w: number, h: number) => PDFOperator[];
+/** Rounded rectangle path in a y-down space (radius clamped to half a side). */
+export declare const roundedRectPathOps: (x: number, y: number, w: number, h: number, radius: number) => PDFOperator[];
+/** Intersect the clip with an axis-aligned rect (no painting). */
+export declare const clipRectOps: (x: number, y: number, w: number, h: number) => PDFOperator[];
+export declare const strokeOp: () => PDFOperator;
+export declare const fillOp: () => PDFOperator;
+/**
+ * Draw an image XObject so it occupies the y-down rect (x, y, w, h) with its
+ * top row at `y`. PDF maps the unit square's TOP edge to the image's first
+ * row, so under a y-down CTM the image must be un-flipped locally.
+ */
+export declare const imageOps: (name: PDFName, x: number, y: number, w: number, h: number, graphicsState?: PDFName) => PDFOperator[];

package/dist/export/pdf/emit.js

@@ -0,0 +1,129 @@
+// Low-level PDF operator helpers for the exporter. Everything here works in
+// the CURRENT coordinate system (whatever `cm` is in force), so the same
+// helpers draw marks in doc space and tile chrome in a tile's design space.
+import { LineCapStyle, LineJoinStyle, appendBezierCurve, clip, closePath, concatTransformationMatrix, degrees, drawImage, endPath, fill, lineTo, moveTo, popGraphicsState, pushGraphicsState, rectangle, setDashPattern, setFillingColor, setGraphicsState, setLineCap, setLineJoin, setLineWidth, setStrokingColor, stroke, } from 'pdf-lib';
+import { dashIntervals, toSkiaStrokeCap, } from '../../annotation/canvas/strokeGeometry.js';
+import { parseHexColor } from './color.js';
+/** Bézier circle constant. */
+const KAPPA = 0.5522847498307936;
+export const withMatrix = (m, ops) => [
+    pushGraphicsState(),
+    concatTransformationMatrix(m[0], m[1], m[2], m[3], m[4], m[5]),
+    ...ops,
+    popGraphicsState(),
+];
+/** Flip back to y-up at (x, y): text and images are drawn upright inside it. */
+export const uprightAt = (x, y) => [
+    1,
+    0,
+    0,
+    -1,
+    x,
+    y,
+];
+export const lineCapOf = (cap) => {
+    switch (toSkiaStrokeCap(cap)) {
+        case 'butt':
+            return LineCapStyle.Butt;
+        case 'square':
+            return LineCapStyle.Projecting;
+        default:
+            return LineCapStyle.Round;
+    }
+};
+/** Operators that set the stroking state for a Skia-style stroked paint. */
+export const strokeStateOps = (s) => {
+    const ops = [];
+    if (s.graphicsState)
+        ops.push(setGraphicsState(s.graphicsState));
+    ops.push(setStrokingColor(parseHexColor(s.color).rgb), setLineWidth(s.width), setLineCap(lineCapOf(s.cap)), setLineJoin(s.join === 'round' ? LineJoinStyle.Round : LineJoinStyle.Miter));
+    if (s.dash) {
+        const [on, off] = dashIntervals(s.width);
+        ops.push(setDashPattern([on, off], 0));
+    }
+    return ops;
+};
+export const fillStateOps = (color, graphicsState) => {
+    const ops = [];
+    if (graphicsState)
+        ops.push(setGraphicsState(graphicsState));
+    ops.push(setFillingColor(parseHexColor(color).rgb));
+    return ops;
+};
+/** Path construction for a polyline over `points`; no painting operator. */
+export const polylinePathOps = (points, close = false) => {
+    if (points.length === 0)
+        return [];
+    const ops = [moveTo(points[0].x, points[0].y)];
+    for (let i = 1; i < points.length; i++) {
+        ops.push(lineTo(points[i].x, points[i].y));
+    }
+    if (close)
+        ops.push(closePath());
+    return ops;
+};
+/** Same, over the flat [x, y, x, y, …] array strokes store. */
+export const flatPolylinePathOps = (points) => {
+    if (points.length < 2)
+        return [];
+    const ops = [moveTo(points[0], points[1])];
+    for (let i = 2; i + 1 < points.length; i += 2) {
+        ops.push(lineTo(points[i], points[i + 1]));
+    }
+    return ops;
+};
+export const circlePathOps = (cx, cy, r) => {
+    const k = KAPPA * r;
+    return [
+        moveTo(cx + r, cy),
+        appendBezierCurve(cx + r, cy + k, cx + k, cy + r, cx, cy + r),
+        appendBezierCurve(cx - k, cy + r, cx - r, cy + k, cx - r, cy),
+        appendBezierCurve(cx - r, cy - k, cx - k, cy - r, cx, cy - r),
+        appendBezierCurve(cx + k, cy - r, cx + r, cy - k, cx + r, cy),
+        closePath(),
+    ];
+};
+export const rectPathOps = (x, y, w, h) => [rectangle(x, y, w, h)];
+/** Rounded rectangle path in a y-down space (radius clamped to half a side). */
+export const roundedRectPathOps = (x, y, w, h, radius) => {
+    const r = Math.max(0, Math.min(radius, w / 2, h / 2));
+    if (r === 0)
+        return rectPathOps(x, y, w, h);
+    const k = KAPPA * r;
+    return [
+        moveTo(x + r, y),
+        lineTo(x + w - r, y),
+        appendBezierCurve(x + w - r + k, y, x + w, y + r - k, x + w, y + r),
+        lineTo(x + w, y + h - r),
+        appendBezierCurve(x + w, y + h - r + k, x + w - r + k, y + h, x + w - r, y + h),
+        lineTo(x + r, y + h),
+        appendBezierCurve(x + r - k, y + h, x, y + h - r + k, x, y + h - r),
+        lineTo(x, y + r),
+        appendBezierCurve(x, y + r - k, x + r - k, y, x + r, y),
+        closePath(),
+    ];
+};
+/** Intersect the clip with an axis-aligned rect (no painting). */
+export const clipRectOps = (x, y, w, h) => [rectangle(x, y, w, h), clip(), endPath()];
+export const strokeOp = () => stroke();
+export const fillOp = () => fill();
+/**
+ * Draw an image XObject so it occupies the y-down rect (x, y, w, h) with its
+ * top row at `y`. PDF maps the unit square's TOP edge to the image's first
+ * row, so under a y-down CTM the image must be un-flipped locally.
+ */
+export const imageOps = (name, x, y, w, h, graphicsState) => {
+    const ops = [pushGraphicsState()];
+    if (graphicsState)
+        ops.push(setGraphicsState(graphicsState));
+    ops.push(concatTransformationMatrix(w, 0, 0, -h, x, y + h), ...drawImage(name, {
+        x: 0,
+        y: 0,
+        width: 1,
+        height: 1,
+        rotate: degrees(0),
+        xSkew: degrees(0),
+        ySkew: degrees(0),
+    }), popGraphicsState());
+    return ops;
+};

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

@@ -0,0 +1,38 @@
+import { PDFDocument, PDFFont, PDFName, PDFPage, type PDFOperator } from 'pdf-lib';
+export type TextAlign = 'left' | 'center' | 'right';
+export interface TextOptions {
+    align?: TextAlign;
+    /** ExtGState name carrying an opacity, if any. */
+    graphicsState?: PDFName;
+}
+export declare class PdfFonts {
+    private readonly primary;
+    private readonly fallback;
+    private readonly keys;
+    private constructor();
+    static create(doc: PDFDocument, primaryBytes: Uint8Array): Promise<PdfFonts>;
+    /** Whether the primary face has a glyph for every code point of `text`. */
+    private primaryCovers;
+    /** Drop the code points the standard fallback cannot encode. */
+    private fallbackUsable;
+    /**
+     * The face to draw `text` with and the text it can actually show. The
+     * primary wins when it covers every glyph; otherwise the fallback, minus
+     * anything even it cannot encode. `dropped` is true when glyphs were lost.
+     */
+    pick(text: string): {
+        font: PDFFont;
+        text: string;
+        dropped: boolean;
+    };
+    width(text: string, size: number): number;
+    private keyFor;
+    /**
+     * Operators drawing one line of text in a y-DOWN space, with its baseline at
+     * `yBaseline` and its left / centre / right edge at `x`. Returns [] when
+     * nothing of the text is drawable.
+     */
+    textOps(page: PDFPage, text: string, size: number, color: string, x: number, yBaseline: number, options?: TextOptions): PDFOperator[];
+    /** Largest size ≤ `max` at which `text` fits in `maxWidth`. */
+    fitSize(text: string, maxWidth: number, max: number, min?: number): number;
+}

package/dist/export/pdf/fonts.js

@@ -0,0 +1,97 @@
+// Text for the exporter: one embedded primary face (the apps' tile font) plus
+// a standard-14 fallback for the glyphs it lacks. Metropolis Bold, for one,
+// has no `°` — and an angle tile is nothing without it.
+import { StandardFonts, degrees, drawText, } from 'pdf-lib';
+import fontkit from '@pdf-lib/fontkit';
+import { parseHexColor } from './color.js';
+import { uprightAt, withMatrix } from './emit.js';
+const codePointsOf = (text) => Array.from(text, (ch) => ch.codePointAt(0));
+export class PdfFonts {
+    constructor(primary, fallback) {
+        this.primary = primary;
+        this.fallback = fallback;
+        this.keys = new Map();
+    }
+    static async create(doc, primaryBytes) {
+        doc.registerFontkit(fontkit);
+        // NOT subset: fontkit's CFF subsetter throws on this face ("value" argument out of
+        // bounds in CFFSubset.encode), and the whole file is ~24 KB anyway.
+        const primary = await doc.embedFont(primaryBytes, { subset: false });
+        const fallback = await doc.embedStandardFont(StandardFonts.HelveticaBold);
+        return new PdfFonts(primary, fallback);
+    }
+    /** Whether the primary face has a glyph for every code point of `text`. */
+    primaryCovers(text) {
+        const fk = this.primary.embedder?.font;
+        if (!fk?.hasGlyphForCodePoint)
+            return true;
+        return codePointsOf(text).every((cp) => cp === 0x20 || fk.hasGlyphForCodePoint(cp));
+    }
+    /** Drop the code points the standard fallback cannot encode. */
+    fallbackUsable(text) {
+        const enc = this.fallback.embedder?.encoding;
+        if (!enc?.canEncodeUnicodeCodePoint)
+            return text;
+        return Array.from(text)
+            .filter((ch) => enc.canEncodeUnicodeCodePoint(ch.codePointAt(0)))
+            .join('');
+    }
+    /**
+     * The face to draw `text` with and the text it can actually show. The
+     * primary wins when it covers every glyph; otherwise the fallback, minus
+     * anything even it cannot encode. `dropped` is true when glyphs were lost.
+     */
+    pick(text) {
+        if (this.primaryCovers(text)) {
+            return { font: this.primary, text, dropped: false };
+        }
+        const usable = this.fallbackUsable(text);
+        return { font: this.fallback, text: usable, dropped: usable !== text };
+    }
+    width(text, size) {
+        const p = this.pick(text);
+        return p.text ? p.font.widthOfTextAtSize(p.text, size) : 0;
+    }
+    keyFor(page, font) {
+        let keys = this.keys.get(page);
+        if (!keys) {
+            keys = {
+                primary: page.node.newFontDictionary(this.primary.name, this.primary.ref),
+                fallback: page.node.newFontDictionary(this.fallback.name, this.fallback.ref),
+            };
+            this.keys.set(page, keys);
+        }
+        return font === this.primary ? keys.primary : keys.fallback;
+    }
+    /**
+     * Operators drawing one line of text in a y-DOWN space, with its baseline at
+     * `yBaseline` and its left / centre / right edge at `x`. Returns [] when
+     * nothing of the text is drawable.
+     */
+    textOps(page, text, size, color, x, yBaseline, options = {}) {
+        const picked = this.pick(text);
+        if (!picked.text || size <= 0)
+            return [];
+        const w = picked.font.widthOfTextAtSize(picked.text, size);
+        const align = options.align ?? 'left';
+        const left = align === 'center' ? x - w / 2 : align === 'right' ? x - w : x;
+        return withMatrix(uprightAt(left, yBaseline), drawText(picked.font.encodeText(picked.text), {
+            color: parseHexColor(color).rgb,
+            font: this.keyFor(page, picked.font),
+            size,
+            rotate: degrees(0),
+            xSkew: degrees(0),
+            ySkew: degrees(0),
+            x: 0,
+            y: 0,
+            graphicsState: options.graphicsState,
+        }));
+    }
+    /** Largest size ≤ `max` at which `text` fits in `maxWidth`. */
+    fitSize(text, maxWidth, max, min = 4) {
+        const atOne = this.width(text, 1);
+        if (atOne <= 0)
+            return max;
+        return Math.max(min, Math.min(max, maxWidth / atOne));
+    }
+}

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

@@ -0,0 +1,5 @@
+export { renderCanvasToPdf } from './renderCanvasToPdf.js';
+export { docToPageMatrix, pageRectsOf, normalizeRotation, rotatedBoxSize, applyMatrix, type AffineMatrix, type PageRotation, type PdfBox, } from './pageMapping.js';
+export { resolveTileContent, measurementTileFillFor, FORMULA_COLUMN_TILE_FILL, PLANE_COMPUTED_TILE_FILL, type TileFileInfo, type TileResolutionContext, } from './tileContent.js';
+export { tileFootprint, type TileFootprint } from './tiles.js';
+export { PdfExportError, type EmbeddedImage, type PdfExportCalibration, type RenderCanvasToPdfInput, type RenderCanvasToPdfResult, type ResolvedTileContent, type MeasurementTileContent, type LiteralTileContent, type EmptyTileContent, type HeaderTileContent, type ObjectTileContent, type PlaneDimensionTileContent, type InstructionsTileContent, type SkippedItem, } from './types.js';

package/dist/export/pdf/index.js

@@ -0,0 +1,5 @@
+export { renderCanvasToPdf } from './renderCanvasToPdf.js';
+export { docToPageMatrix, pageRectsOf, normalizeRotation, rotatedBoxSize, applyMatrix, } from './pageMapping.js';
+export { resolveTileContent, measurementTileFillFor, FORMULA_COLUMN_TILE_FILL, PLANE_COMPUTED_TILE_FILL, } from './tileContent.js';
+export { tileFootprint } from './tiles.js';
+export { PdfExportError, } from './types.js';

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

@@ -0,0 +1,5 @@
+import { type PDFName, type PDFOperator } from 'pdf-lib';
+import type { AnnotationBackgroundLayer } from '../../types/annotation.js';
+import type { DocRect } from './pageMapping.js';
+export declare const layerVisibleRect: (layer: AnnotationBackgroundLayer) => DocRect;
+export declare const layerOps: (layer: AnnotationBackgroundLayer, imageName: PDFName) => PDFOperator[];

package/dist/export/pdf/layers.js

@@ -0,0 +1,19 @@
+// Background image layers baked into the page: the full image placed at its
+// doc rect, clipped to its crop window. Draw order is array order, under every
+// mark — exactly the z-order AnnotationCanvasSkia paints.
+import { popGraphicsState, pushGraphicsState, } from 'pdf-lib';
+import { backgroundLayerDocRect, backgroundLayerFullDocRect, } from '../../annotation/canvas/backgroundLayers.js';
+import { clipRectOps, imageOps } from './emit.js';
+export const layerVisibleRect = (layer) => backgroundLayerDocRect(layer);
+export const layerOps = (layer, imageName) => {
+    const crop = backgroundLayerDocRect(layer);
+    const full = backgroundLayerFullDocRect(layer);
+    if (crop.width <= 0 || crop.height <= 0)
+        return [];
+    return [
+        pushGraphicsState(),
+        ...clipRectOps(crop.x, crop.y, crop.width, crop.height),
+        ...imageOps(imageName, full.x, full.y, full.width, full.height),
+        popGraphicsState(),
+    ];
+};

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

@@ -0,0 +1,20 @@
+import { type PDFName, type PDFOperator, type PDFPage } from 'pdf-lib';
+import type { AnnotationShape, AnnotationStroke, PlacedMeasurementRef } from '../../types/annotation.js';
+import { dashIntervals } from '../../annotation/canvas/strokeGeometry.js';
+import type { PdfFonts } from './fonts.js';
+import { type DocRect } from './pageMapping.js';
+import type { SkippedItem } from './types.js';
+export interface MarkContext {
+    page: PDFPage;
+    fonts: PdfFonts;
+    /** An ExtGState carrying `alpha` (CA/ca) for this page; undefined at 1. */
+    alphaState: (alpha: number) => PDFName | undefined;
+    skipped: SkippedItem[];
+}
+export declare const strokeBounds: (s: AnnotationStroke) => DocRect | null;
+export declare const strokeOps: (s: AnnotationStroke, ctx: MarkContext) => PDFOperator[];
+export declare const shapeBounds: (shape: AnnotationShape) => DocRect | null;
+export declare const shapeOps: (shape: AnnotationShape, ctx: MarkContext) => PDFOperator[];
+export declare const measurementMarkBounds: (placed: PlacedMeasurementRef) => DocRect | null;
+export declare const measurementMarkOps: (placed: PlacedMeasurementRef, ctx: MarkContext) => PDFOperator[];
+export { dashIntervals };