@reekon-tools/boldr-utils 1.22.0 → 1.24.0

package/dist/export/pdf/fonts.js

@@ -10,7 +10,6 @@ export class PdfFonts {
     constructor(primary, fallback) {
         this.primary = primary;
         this.fallback = fallback;
-        this.keys = new Map();
     }
     static async create(doc, primaryBytes) {
         doc.registerFontkit(fontkit);
@@ -52,23 +51,12 @@ export class PdfFonts {
         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 = {}) {
+    textOps(scope, text, size, color, x, yBaseline, options = {}) {
         const picked = this.pick(text);
         if (!picked.text || size <= 0)
             return [];
@@ -77,7 +65,7 @@ export class PdfFonts {
         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),
+            font: scope.fontKey(picked.font),
             size,
             rotate: degrees(0),
             xSkew: degrees(0),

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

@@ -1,5 +1,7 @@
-export { renderCanvasToPdf } from './renderCanvasToPdf.js';
+export { renderCanvasToPdf, renderPdfCanvasToPdf, } from './renderCanvasToPdf.js';
+export { stripPdfEncryption, type StripPdfEncryptionOptions, type StripPdfEncryptionResult, } from './decrypt.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';
+export { annotationCount } from './annots.js';
+export { PdfExportError, type EmbeddedImage, type PdfExportCalibration, type RenderCanvasToPdfInput, type RenderPdfCanvasToPdfInput, 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

@@ -1,5 +1,7 @@
-export { renderCanvasToPdf } from './renderCanvasToPdf.js';
+export { renderCanvasToPdf, renderPdfCanvasToPdf, } from './renderCanvasToPdf.js';
+export { stripPdfEncryption, } from './decrypt.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 { annotationCount } from './annots.js';
 export { PdfExportError, } from './types.js';

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

@@ -1,16 +1,73 @@
-import { type PDFName, type PDFOperator, type PDFPage } from 'pdf-lib';
-import type { AnnotationShape, AnnotationStroke, PlacedMeasurementRef } from '../../types/annotation.js';
+import { type PDFOperator } from 'pdf-lib';
+import type { AnnotationShape, AnnotationStroke, PlacedMeasurementRef, Vec2 } 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 { ResourceScope } from './resources.js';
 import type { SkippedItem } from './types.js';
 export interface MarkContext {
-    page: PDFPage;
+    /** Where fonts, images and opacity states get registered. */
+    scope: ResourceScope;
     fonts: PdfFonts;
-    /** An ExtGState carrying `alpha` (CA/ca) for this page; undefined at 1. */
-    alphaState: (alpha: number) => PDFName | undefined;
     skipped: SkippedItem[];
 }
+/**
+ * What an element IS, for the annotation dictionary that wraps its
+ * appearance stream in annotation mode: the standard fields a viewer reads
+ * back (and regenerates from after an edit). Points and rects are in DOC
+ * space; the annotation builder maps them onto the page.
+ */
+export type AnnotMeta = {
+    subtype: 'Ink';
+    color: string;
+    width: number;
+    alpha: number;
+    paths: Vec2[][];
+} | {
+    subtype: 'Line';
+    color: string;
+    width: number;
+    alpha: number;
+    dash: boolean;
+    a: Vec2;
+    b: Vec2;
+    startArrow: boolean;
+    endArrow: boolean;
+} | {
+    subtype: 'Square' | 'Circle';
+    color: string;
+    fill?: string;
+    width: number;
+    alpha: number;
+    dash: boolean;
+    rect: DocRect;
+} | {
+    subtype: 'Polygon' | 'PolyLine';
+    color: string;
+    fill?: string;
+    width: number;
+    alpha: number;
+    dash: boolean;
+    vertices: Vec2[];
+    startArrow: boolean;
+    endArrow: boolean;
+} | {
+    subtype: 'FreeText';
+    color: string;
+    fontSize: number;
+    text: string;
+    alpha: number;
+} | {
+    subtype: 'Stamp';
+    contents?: string;
+};
+/** One drawable element: its operators, its doc-space bounds, its identity. */
+export interface Mark {
+    id: string;
+    ops: PDFOperator[];
+    bounds: DocRect;
+    annot: AnnotMeta;
+}
 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;
@@ -18,3 +75,7 @@ export declare const shapeOps: (shape: AnnotationShape, ctx: MarkContext) => PDF
 export declare const measurementMarkBounds: (placed: PlacedMeasurementRef) => DocRect | null;
 export declare const measurementMarkOps: (placed: PlacedMeasurementRef, ctx: MarkContext) => PDFOperator[];
 export { dashIntervals };
+export declare const strokeMark: (s: AnnotationStroke, ctx: MarkContext) => Mark | null;
+export declare const shapeMark: (shape: AnnotationShape, ctx: MarkContext) => Mark | null;
+/** The measurement annotation's line / rectangle (not its tile). */
+export declare const measurementMark: (placed: PlacedMeasurementRef, ctx: MarkContext) => Mark | null;

package/dist/export/pdf/marks.js

@@ -66,7 +66,7 @@ export const strokeOps = (s, ctx) => {
         return [];
     const opacity = s.tool === 'highlighter' ? 0.3 : 1;
     const alpha = opacity * parseHexColor(s.color).alpha;
-    const gs = ctx.alphaState(alpha);
+    const gs = ctx.scope.alphaState(alpha);
     const isDot = n === 4 && s.points[0] === s.points[2] && s.points[1] === s.points[3];
     if (isDot) {
         // Skia paints a zero-length round-capped contour as a dot; PDF only does
@@ -137,7 +137,7 @@ const textShapeOps = (shape, ctx) => {
     const colorStr = shape.style.stroke ?? '#000000';
     const decoration = shape.style.textDecoration;
     const glyphColor = decoration === 'highlight' ? highlightTextColor(colorStr) : colorStr;
-    const gs = ctx.alphaState(parseHexColor(colorStr).alpha);
+    const gs = ctx.scope.alphaState(parseHexColor(colorStr).alpha);
     const lineHeight = TEXT_LINE_HEIGHT_FACTOR * fontSize;
     const ops = [];
     let lost = false;
@@ -151,7 +151,7 @@ const textShapeOps = (shape, ctx) => {
         if (decoration === 'highlight' && width > 0) {
             ops.push(pushGraphicsState(), ...fillStateOps(colorStr, gs), rectangle(origin.x, top, width, lineHeight), fill(), popGraphicsState());
         }
-        ops.push(...ctx.fonts.textOps(ctx.page, line, fontSize, glyphColor, origin.x, baseline, {
+        ops.push(...ctx.fonts.textOps(ctx.scope, line, fontSize, glyphColor, origin.x, baseline, {
             graphicsState: gs,
         }));
         if ((decoration === 'underline' || decoration === 'squiggle') &&
@@ -177,7 +177,7 @@ export const shapeOps = (shape, ctx) => {
         return textShapeOps(shape, ctx);
     const strokeColor = style.stroke ?? '#000000';
     const strokeWidth = style.strokeWidth ?? 2;
-    const gs = ctx.alphaState(parseHexColor(strokeColor).alpha);
+    const gs = ctx.scope.alphaState(parseHexColor(strokeColor).alpha);
     const closed = geometry.closed !== false;
     const pts = geometry.points;
     const strokeWith = (pathOps, join, cap) => [
@@ -197,7 +197,7 @@ export const shapeOps = (shape, ctx) => {
     const fillWith = (pathOps) => style.fill
         ? [
             pushGraphicsState(),
-            ...fillStateOps(style.fill, ctx.alphaState(parseHexColor(style.fill).alpha)),
+            ...fillStateOps(style.fill, ctx.scope.alphaState(parseHexColor(style.fill).alpha)),
             ...pathOps,
             fill(),
             popGraphicsState(),
@@ -298,7 +298,7 @@ export const measurementMarkOps = (placed, ctx) => {
                 width,
                 join: 'miter',
                 dash: !!placed.lineDash,
-                graphicsState: ctx.alphaState(parseHexColor(color).alpha),
+                graphicsState: ctx.scope.alphaState(parseHexColor(color).alpha),
             }),
             ...rectPathOps(n.minX, n.minY, n.maxX - n.minX, n.maxY - n.minY),
             stroke(),
@@ -309,7 +309,7 @@ export const measurementMarkOps = (placed, ctx) => {
         const { a, b } = placed.line;
         const color = placed.lineColor ?? MEASUREMENT_LINE_COLOR;
         const width = placed.lineWidth ?? MEASUREMENT_LINE_WIDTH;
-        const gs = ctx.alphaState(parseHexColor(color).alpha);
+        const gs = ctx.scope.alphaState(parseHexColor(color).alpha);
         const ops = [
             pushGraphicsState(),
             ...strokeStateOps({
@@ -334,3 +334,146 @@ export const measurementMarkOps = (placed, ctx) => {
 };
 // Re-exported so the renderer can size dash tests without a second import.
 export { dashIntervals };
+/* ------------------------------------------------------------------ *
+ * Marks: ops + bounds + annotation metadata, per element
+ * ------------------------------------------------------------------ */
+const strokePaths = (s) => {
+    const pts = [];
+    for (let i = 0; i + 1 < s.points.length; i += 2) {
+        pts.push({ x: s.points[i], y: s.points[i + 1] });
+    }
+    return pts;
+};
+export const strokeMark = (s, ctx) => {
+    const bounds = strokeBounds(s);
+    if (!bounds)
+        return null;
+    const opacity = s.tool === 'highlighter' ? 0.3 : 1;
+    return {
+        id: s.id,
+        ops: strokeOps(s, ctx),
+        bounds,
+        annot: {
+            subtype: 'Ink',
+            color: s.color,
+            width: s.width,
+            alpha: opacity * parseHexColor(s.color).alpha,
+            paths: [strokePaths(s)],
+        },
+    };
+};
+export const shapeMark = (shape, ctx) => {
+    const bounds = shapeBounds(shape);
+    if (!bounds)
+        return null;
+    const ops = shapeOps(shape, ctx);
+    const { kind, geometry, style } = shape;
+    const color = style.stroke ?? '#000000';
+    const width = style.strokeWidth ?? 2;
+    const alpha = parseHexColor(color).alpha;
+    const dash = !!style.dash;
+    const pts = geometry.points;
+    let annot;
+    switch (kind) {
+        case 'rect':
+        case 'ellipse': {
+            const b = visualShapeBounds(shape);
+            annot = {
+                subtype: kind === 'rect' ? 'Square' : 'Circle',
+                color,
+                fill: style.fill,
+                width,
+                alpha,
+                dash,
+                rect: boundsToRect(b),
+            };
+            break;
+        }
+        case 'line':
+        case 'arrow':
+            annot = {
+                subtype: 'Line',
+                color,
+                width,
+                alpha,
+                dash,
+                a: pts[0],
+                b: pts[1],
+                startArrow: style.startCap === 'arrow',
+                endArrow: kind === 'arrow' || style.cap === 'arrow',
+            };
+            break;
+        case 'polygon': {
+            const closed = geometry.closed !== false;
+            annot = {
+                subtype: closed ? 'Polygon' : 'PolyLine',
+                color,
+                fill: closed ? style.fill : undefined,
+                width,
+                alpha,
+                dash,
+                vertices: pts,
+                startArrow: !closed && style.startCap === 'arrow',
+                endArrow: !closed && style.cap === 'arrow',
+            };
+            break;
+        }
+        case 'text':
+            annot = {
+                subtype: 'FreeText',
+                color,
+                fontSize: style.fontSize ?? DEFAULT_TEXT_FONT_SIZE,
+                text: shape.text ?? '',
+                alpha,
+            };
+            break;
+        default:
+            return null;
+    }
+    return { id: shape.id, ops, bounds, annot };
+};
+/** The measurement annotation's line / rectangle (not its tile). */
+export const measurementMark = (placed, ctx) => {
+    const bounds = measurementMarkBounds(placed);
+    if (!bounds)
+        return null;
+    const ops = measurementMarkOps(placed, ctx);
+    const color = placed.lineColor ?? MEASUREMENT_LINE_COLOR;
+    const alpha = parseHexColor(color).alpha;
+    const dash = !!placed.lineDash;
+    if (placementOf(placed) === 'rectangle' && placed.rect) {
+        const n = normalizeRect(placed.rect);
+        return {
+            id: `${placed.id}:rect`,
+            ops,
+            bounds,
+            annot: {
+                subtype: 'Square',
+                color,
+                width: placed.lineWidth ?? MEASUREMENT_RECT_WIDTH,
+                alpha,
+                dash,
+                rect: boundsToRect(n),
+            },
+        };
+    }
+    if (placementOf(placed) === 'line' && placed.line) {
+        return {
+            id: `${placed.id}:line`,
+            ops,
+            bounds,
+            annot: {
+                subtype: 'Line',
+                color,
+                width: placed.lineWidth ?? MEASUREMENT_LINE_WIDTH,
+                alpha,
+                dash,
+                a: placed.line.a,
+                b: placed.line.b,
+                startArrow: placed.lineStartCap === 'arrow',
+                endArrow: placed.lineCap === 'arrow',
+            },
+        };
+    }
+    return null;
+};

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

@@ -39,6 +39,8 @@ export declare const applyMatrix: (m: AffineMatrix, x: number, y: number) => {
     x: number;
     y: number;
 };
+/** The overlap of two rects, or null when they do not overlap. */
+export declare const intersectRects: (a: DocRect, b: DocRect) => DocRect | null;
 export declare const rectsIntersect: (a: DocRect, b: DocRect) => boolean;
 /** Axis-aligned bounds → DocRect, inflated by `pad` on every side. */
 export declare const boundsToRect: (b: {

package/dist/export/pdf/pageMapping.js

@@ -54,6 +54,16 @@ export const applyMatrix = (m, x, y) => ({
     x: m[0] * x + m[2] * y + m[4],
     y: m[1] * x + m[3] * y + m[5],
 });
+/** The overlap of two rects, or null when they do not overlap. */
+export const intersectRects = (a, b) => {
+    const x = Math.max(a.x, b.x);
+    const y = Math.max(a.y, b.y);
+    const right = Math.min(a.x + a.width, b.x + b.width);
+    const bottom = Math.min(a.y + a.height, b.y + b.height);
+    if (right <= x || bottom <= y)
+        return null;
+    return { x, y, width: right - x, height: bottom - y };
+};
 export const rectsIntersect = (a, b) => a.x < b.x + b.width &&
     a.x + a.width > b.x &&
     a.y < b.y + b.height &&

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

@@ -1,2 +1,10 @@
-import { type RenderCanvasToPdfInput, type RenderCanvasToPdfResult } from './types.js';
+import { type RenderCanvasToPdfInput, type RenderCanvasToPdfResult, type RenderPdfCanvasToPdfInput } from './types.js';
 export declare const renderCanvasToPdf: (input: RenderCanvasToPdfInput) => Promise<RenderCanvasToPdfResult>;
+/**
+ * Export a PdfCanvas file. Each page's state is drawn in that page's own doc
+ * space (the DISPLAYED page: rotated extents, origin top-left). A user
+ * rotation is written into the page's /Rotate — so the recipient sees the
+ * page as the user did — and the page matrix undoes the combined rotation.
+ * Pages without a state are still rotated.
+ */
+export declare const renderPdfCanvasToPdf: (input: RenderPdfCanvasToPdfInput) => Promise<RenderCanvasToPdfResult>;