documonster 0.7.0 → 0.8.0

package/dist/esm/modules/pdf/core/pdf-writer.js

@@ -164,6 +164,9 @@ export class PdfWriter {
             .set("MediaBox", mediaBox)
             .set("Contents", contentsValue)
             .set("Resources", pdfRef(options.resourcesRef));
+        if (options.transparencyGroup) {
+            dict.set("Group", "<< /S /Transparency /CS /DeviceRGB /I false /K false >>");
+        }
         if (options.annotRefs && options.annotRefs.length > 0) {
             dict.set("Annots", "[" + options.annotRefs.map(r => pdfRef(r)).join(" ") + "]");
         }

package/dist/esm/modules/pdf/excel-bridge.js

@@ -27,7 +27,7 @@ import { chartChartExModel, chartChartModel } from "../excel/chart/chart-handle.
 import { canRenderChartExAsVectorPdf, drawChartExPdf, renderChartExPng } from "../excel/chart/render/chart-ex-renderer.js";
 import { drawChartPdf, renderChartPng } from "../excel/chart/render/chart-renderer.js";
 import { anchorCol, anchorRow } from "../excel/core/anchor.js";
-import { cellCol, cellGetValue, cellHyperlink, cellResult, cellText, cellType, mergeCellStyle } from "../excel/core/cell.js";
+import { cellCol, cellComment, cellGetValue, cellHyperlink, cellResult, cellText, cellType, mergeCellStyle } from "../excel/core/cell.js";
 import { chartsheetChartExModel, chartsheetChartModel, chartsheetModel, chartsheetName, chartsheetPageSetup, chartsheetPageMargins, chartsheetState } from "../excel/core/chartsheet.js";
 import { ValueType } from "../excel/core/enums.js";
 import { computeSparklineGeometry } from "../excel/core/sparkline.js";
@@ -62,7 +62,7 @@ export async function excelToPdf(workbook, options) {
     // shipped with. This keeps the ~200 KB engine out of bundles that only
     // export already-computed workbooks — no host-registry needed.
     options?.recalculate?.(workbook);
-    const pdfWorkbook = await excelWorkbookToPdf(workbook);
+    const pdfWorkbook = await excelWorkbookToPdf(workbook, options);
     return exportPdf(pdfWorkbook, options);
 }
 /**
@@ -174,9 +174,9 @@ export async function chartToPdf(chart, options = {}) {
  * Chartsheets without an orderNo fall to the end, mirroring how Excel
  * treats sheets with missing tab positions.
  */
-async function excelWorkbookToPdf(workbook) {
-    const worksheetResults = await Promise.all(getWorksheets(workbook).map(ws => convertSheet(ws, workbook)));
-    const chartsheetResults = await Promise.all(getChartsheets(workbook).map(cs => convertChartsheet(cs, workbook)));
+async function excelWorkbookToPdf(workbook, options) {
+    const worksheetResults = await Promise.all(getWorksheets(workbook).map(ws => convertSheet(ws, workbook, options)));
+    const chartsheetResults = await Promise.all(getChartsheets(workbook).map(cs => convertChartsheet(cs, workbook, options)));
     const combined = [...worksheetResults, ...chartsheetResults];
     combined.sort((a, b) => (a.orderNo ?? Number.POSITIVE_INFINITY) - (b.orderNo ?? Number.POSITIVE_INFINITY));
     return {
@@ -192,7 +192,7 @@ async function excelWorkbookToPdf(workbook) {
 // =============================================================================
 // Sheet Conversion
 // =============================================================================
-async function convertSheet(ws, workbook) {
+async function convertSheet(ws, workbook, options) {
     const dimensions = getSheetDimensions(ws);
     const hasData = dimensions && dimensions.top > 0 && dimensions.left > 0;
     const bounds = hasData
@@ -312,10 +312,22 @@ async function convertSheet(ws, workbook) {
                 }
                 : undefined,
             scale: ps.scale,
+            fitToPage: ps.fitToPage,
+            fitToWidth: ps.fitToWidth,
+            fitToHeight: ps.fitToHeight,
             printTitlesRow: ps.printTitlesRow,
+            printTitlesColumn: ps.printTitlesColumn,
             showGridLines: ps.showGridLines,
+            showRowColHeaders: ps.showRowColHeaders,
             printArea: ps.printArea,
-            firstPageNumber: ps.useFirstPageNumber === false ? undefined : ps.firstPageNumber
+            firstPageNumber: ps.useFirstPageNumber === false ? undefined : ps.firstPageNumber,
+            pageOrder: ps.pageOrder,
+            blackAndWhite: ps.blackAndWhite,
+            draft: ps.draft,
+            errors: ps.errors,
+            cellComments: ps.cellComments,
+            horizontalCentered: ps.horizontalCentered,
+            verticalCentered: ps.verticalCentered
         }
         : undefined;
     // Convert row/col breaks
@@ -324,9 +336,18 @@ async function convertSheet(ws, workbook) {
     // Convert images and charts. Both are floating objects anchored to
     // cells, and both need to participate in bounds expansion so the
     // layout engine allocates pages that cover their anchor rows/cols.
-    const images = collectImages(ws, workbook);
-    const charts = await collectCharts(ws);
-    const sparklineCharts = collectSparklineCharts(ws);
+    //
+    // Draft quality prints no graphics, so skip collection entirely rather than
+    // gathering (and rasterizing ChartEx layouts) only to drop the result during
+    // layout: draft exists to be cheap, and a rasterizer failure must not sink an
+    // export that would not have shown the graphic anyway. The precedence here
+    // mirrors `resolveOptions`; the layout engine still gates on the resolved
+    // flag, so this stays a pure optimization.
+    const comments = collectComments(ws);
+    const draftQuality = options?.draft ?? ws.pageSetup?.draft ?? false;
+    const images = draftQuality ? undefined : collectImages(ws, workbook);
+    const charts = draftQuality ? undefined : await collectCharts(ws);
+    const sparklineCharts = draftQuality ? undefined : collectSparklineCharts(ws);
     // Merge sparkline micro-charts with regular charts
     const allCharts = charts
         ? sparklineCharts
@@ -398,14 +419,91 @@ async function convertSheet(ws, workbook) {
         rows,
         merges,
         pageSetup,
-        headerFooter: convertHeaderFooter(ws, workbook),
+        headerFooter: convertHeaderFooter(ws, workbook, draftQuality),
         rowBreaks,
         colBreaks,
         images,
-        charts: allCharts
+        charts: allCharts,
+        comments
     };
 }
-function convertHeaderFooter(ws, workbook) {
+/**
+ * Collect every comment on a worksheet, in row-major order.
+ *
+ * Two sources are merged: classic notes stored on the cell (`_comment`, the
+ * VML-backed kind) and Office 365 threaded comments held on the sheet. Only the
+ * text and author are needed — the printed form is an end-of-sheet list, not a
+ * positioned box — so the VML geometry is deliberately ignored.
+ */
+function collectComments(ws) {
+    const collected = [];
+    for (const row of ws._rows ?? []) {
+        if (!row) {
+            continue;
+        }
+        for (const cell of row.cells ?? []) {
+            if (!cell) {
+                continue;
+            }
+            const note = cellComment(cell);
+            const text = noteText(note?.note);
+            if (text) {
+                collected.push({
+                    ref: cell.address,
+                    text,
+                    author: note?.author,
+                    anchor: parseVmlAnchor(note?.note)
+                });
+            }
+        }
+    }
+    for (const entry of ws.threadedComments ?? []) {
+        const text = entry.comment.text?.trim();
+        if (text) {
+            collected.push({ ref: entry.ref, text, author: entry.comment.personId });
+        }
+    }
+    return collected.length > 0 ? collected : undefined;
+}
+/**
+ * Decode a VML comment anchor into fractional sheet coordinates.
+ *
+ * `<x:Anchor>` holds eight integers: for each edge a column/row index followed
+ * by an offset into it, measured in 1/68 of a column and 1/18 of a row (the
+ * reciprocals Excel uses when it writes the value). Returns `undefined` when the
+ * note has no anchor, so callers fall back to Excel's default placement.
+ */
+function parseVmlAnchor(note) {
+    if (!note || typeof note === "string" || typeof note.anchor !== "string") {
+        return undefined;
+    }
+    const parts = note.anchor.split(",").map(p => Number(p.trim()));
+    if (parts.length !== 8 || parts.some(n => !Number.isFinite(n))) {
+        return undefined;
+    }
+    const [l, lf, t, tf, r, rf, b, bf] = parts;
+    return {
+        left: l + lf / 68,
+        top: t + tf / 18,
+        right: r + rf / 68,
+        bottom: b + bf / 18
+    };
+}
+/** Flatten a note body, which may be plain text or a rich `NoteConfig`. */
+function noteText(note) {
+    if (typeof note === "string") {
+        return note.trim() || undefined;
+    }
+    if (note && typeof note === "object" && Array.isArray(note.texts)) {
+        const joined = note.texts
+            .map(t => (typeof t === "string" ? t : (t.text ?? "")))
+            .join("")
+            .trim();
+        return joined || undefined;
+    }
+    return undefined;
+}
+function convertHeaderFooter(ws, workbook, draftQuality = false) {
     const source = ws.headerFooter;
     const fields = [
         source.oddHeader,
@@ -415,7 +513,9 @@ function convertHeaderFooter(ws, workbook) {
         source.firstHeader,
         source.firstFooter
     ];
-    const images = convertHeaderFooterImages(ws, workbook);
+    // Draft quality prints no graphics, header pictures included, so skip
+    // collecting them rather than embedding XObjects nothing will draw.
+    const images = draftQuality ? [] : convertHeaderFooterImages(ws, workbook);
     if (!fields.some(Boolean) && images.length === 0) {
         return undefined;
     }
@@ -1254,7 +1354,7 @@ function chartAnchorRange(chart) {
             : undefined,
         // Chart anchors store ext as EMU (`cx`, `cy`). Pass the values
         // through unchanged; the layout engine converts EMU→pt for charts
-        // (×1/9525) and px→pt for images (×0.75) based on `extUnit`.
+        // (÷12700) and px→pt for images (×0.75) based on `extUnit`.
         ext: r.ext ? { width: r.ext.cx, height: r.ext.cy } : undefined,
         extUnit: r.ext ? "emu" : undefined
     };
@@ -1338,11 +1438,16 @@ const CHARTSHEET_RASTER_PX = { width: 1280, height: 720 };
  *   (matches what Excel prints for a chartsheet whose chart was deleted
  *   but the sheet kept).
  */
-async function convertChartsheet(cs, workbook) {
+async function convertChartsheet(cs, workbook, options) {
     const classicModel = chartsheetChartModel(cs);
     const chartExModel = chartsheetChartExModel(cs);
+    // Resolve draft before touching the chart: a ChartEx outside the vector
+    // whitelist would otherwise be rasterised at cost — and could fail — for a
+    // page that prints no graphics at all. Precedence mirrors `resolveOptions`.
+    const draftQuality = options?.draft ?? chartsheetPageSetup(cs)?.draft ?? false;
+    // Draft quality prints no graphics, so the chart is simply never built.
     let chart = {};
-    if (classicModel) {
+    if (!draftQuality && classicModel) {
         const model = classicModel;
         chart = {
             drawVector: (surface, rect) => {
@@ -1355,7 +1460,7 @@ async function convertChartsheet(cs, workbook) {
             }
         };
     }
-    else if (chartExModel) {
+    else if (!draftQuality && chartExModel) {
         if (canRenderChartExAsVectorPdf(chartExModel)) {
             const model = chartExModel;
             chart = {
@@ -1396,6 +1501,8 @@ async function convertChartsheet(cs, workbook) {
             orientation: ps?.orientation,
             paperSize: ps?.paperSize,
             showGridLines: false,
+            blackAndWhite: ps?.blackAndWhite,
+            draft: ps?.draft,
             firstPageNumber: ps?.useFirstPageNumber === false ? undefined : ps?.firstPageNumber,
             margins: margins
                 ? {
@@ -1417,7 +1524,7 @@ async function convertChartsheet(cs, workbook) {
         orientation,
         chart,
         pageSetup,
-        headerFooter: convertHeaderFooterModel(chartsheetModel(cs).headerFooter, convertChartsheetHeaderImages(chartsheetModel(cs).headerImages, workbook))
+        headerFooter: convertHeaderFooterModel(chartsheetModel(cs).headerFooter, draftQuality ? [] : convertChartsheetHeaderImages(chartsheetModel(cs).headerImages, workbook))
     };
 }
 function convertChartsheetHeaderImages(images, workbook) {

package/dist/esm/modules/pdf/render/chart-surface.js

@@ -18,6 +18,7 @@
  */
 import { resolvePdfFontName } from "../font/font-manager.js";
 import { alphaGsName, emitTextBlock } from "./page-renderer.js";
+import { toGrayscale } from "./style-converter.js";
 /**
  * Build a {@link PdfChartDrawingSurface} that forwards to the given content
  * stream. The returned surface is stateful — callers should not mix it with
@@ -28,38 +29,77 @@ import { alphaGsName, emitTextBlock } from "./page-renderer.js";
  * @param alphaValues   Shared set that accumulates transparency values for
  *                      later `ExtGState` registration. The surface adds any
  *                      `color.a` values it observes to this set.
+ * @param grayscale     When true, every color the chart renderer emits is
+ *                      converted to grayscale. Charts bypass the cell style
+ *                      pipeline entirely — the chart engine pushes colors
+ *                      straight into this surface — so Excel's "Black and
+ *                      white" print option has to be applied right here.
  */
-export function createChartSurface(stream, fontManager, alphaValues) {
+export function createChartSurface(stream, fontManager, alphaValues, grayscale = false) {
+    /** Single choke point for every color entering the surface. */
+    const mapColor = (color) => grayscale && color ? toGrayscale(color) : color;
     const applyAlpha = (color) => {
         if (color?.a !== undefined && color.a < 1) {
             alphaValues.add(color.a);
             stream.setGraphicsState(alphaGsName(color.a));
         }
     };
-    const paintFillStroke = (options) => {
-        const { fill, stroke, lineWidth } = options;
+    /**
+     * Fill and/or stroke the path built by `buildPath`.
+     *
+     * `buildPath` is a closure rather than a pre-built path because a fill and a
+     * stroke with *different* opacities cannot share one graphics state: the
+     * alpha `ExtGState` sets `/ca` and `/CA` together, and `fillAndStroke()`
+     * paints both under whichever was applied last. In that case we paint in two
+     * passes and rebuild the path for the second one. (Within a single pass the
+     * unused half of the ExtGState is harmless — a fill-only pass never strokes.)
+     */
+    const paintFillStroke = (buildPath, options) => {
+        const { lineWidth, dashPattern } = options;
+        const fill = mapColor(options.fill);
+        const stroke = mapColor(options.stroke);
+        const applyDash = () => {
+            if (dashPattern && dashPattern.length > 0) {
+                stream.setDashPattern(dashPattern);
+            }
+        };
+        if (fill && stroke) {
+            const fillAlpha = fill.a ?? 1;
+            const strokeAlpha = stroke.a ?? 1;
+            if (fillAlpha !== strokeAlpha) {
+                stream.save();
+                buildPath();
+                stream.setFillColor(fill);
+                applyAlpha(fill);
+                stream.fill();
+                stream.restore();
+                stream.save();
+                buildPath();
+                stream.setStrokeColor(stroke);
+                applyAlpha(stroke);
+                applyDash();
+                if (lineWidth !== undefined) {
+                    stream.setLineWidth(lineWidth);
+                }
+                stream.stroke();
+                stream.restore();
+                return;
+            }
+        }
+        buildPath();
+        applyDash();
+        // Reaching here means either a single operation, or a fill and stroke that
+        // share one opacity — so one ExtGState describes both and no reset is
+        // needed (the differing case returned above, each pass in its own q/Q).
         if (fill) {
             stream.setFillColor(fill);
             applyAlpha(fill);
         }
         if (stroke) {
             stream.setStrokeColor(stroke);
-            // When fill applied a sub-1 alpha but stroke is fully opaque (no
-            // `a` field or `a >= 1`), we must explicitly restore opaque alpha
-            // so the stroke is not drawn with the fill's transparency. The
-            // ExtGState set by `applyAlpha(fill)` applies to both fill and
-            // stroke operations in PDF; without this reset the stroke leaks
-            // the fill's alpha.
-            const strokeNeedsAlpha = stroke.a !== undefined && stroke.a < 1;
-            const fillAppliedAlpha = fill?.a !== undefined && fill.a < 1;
-            if (strokeNeedsAlpha) {
+            if (!fill) {
                 applyAlpha(stroke);
             }
-            else if (fillAppliedAlpha) {
-                // Reset to fully opaque for the stroke
-                alphaValues.add(1);
-                stream.setGraphicsState(alphaGsName(1));
-            }
             if (lineWidth !== undefined) {
                 stream.setLineWidth(lineWidth);
             }
@@ -81,13 +121,13 @@ export function createChartSurface(stream, fontManager, alphaValues) {
         drawRect(options) {
             const { x, y, width, height, fill, stroke, lineWidth } = options;
             stream.save();
-            stream.rect(x, y, width, height);
-            paintFillStroke({ fill, stroke, lineWidth });
+            paintFillStroke(() => stream.rect(x, y, width, height), { fill, stroke, lineWidth });
             stream.restore();
             return this;
         },
         drawLine(options) {
-            const { x1, y1, x2, y2, color, lineWidth, dashPattern } = options;
+            const { x1, y1, x2, y2, lineWidth, dashPattern } = options;
+            const color = mapColor(options.color);
             stream.save();
             if (color) {
                 stream.setStrokeColor(color);
@@ -108,7 +148,7 @@ export function createChartSurface(stream, fontManager, alphaValues) {
                 return this;
             }
             const fontSize = options.fontSize ?? 10;
-            const color = options.color ?? { r: 0, g: 0, b: 0 };
+            const color = mapColor(options.color ?? { r: 0, g: 0, b: 0 });
             const bold = options.bold ?? false;
             const italic = options.italic ?? false;
             const fontFamily = options.fontFamily ?? "Helvetica";
@@ -140,39 +180,38 @@ export function createChartSurface(stream, fontManager, alphaValues) {
         drawCircle(options) {
             const { cx, cy, r, fill, stroke, lineWidth } = options;
             stream.save();
-            stream.circle(cx, cy, r);
-            paintFillStroke({ fill, stroke, lineWidth });
+            paintFillStroke(() => stream.circle(cx, cy, r), { fill, stroke, lineWidth });
             stream.restore();
             return this;
         },
         drawPath(ops, options) {
-            stream.save();
-            for (const op of ops) {
-                switch (op.op) {
-                    case "move":
-                        stream.moveTo(op.x, op.y);
-                        break;
-                    case "line":
-                        stream.lineTo(op.x, op.y);
-                        break;
-                    case "curve":
-                        stream.curveTo(op.x1, op.y1, op.x2, op.y2, op.x3, op.y3);
-                        break;
-                    case "close":
-                        stream.closePath();
-                        break;
+            const buildPath = () => {
+                for (const op of ops) {
+                    switch (op.op) {
+                        case "move":
+                            stream.moveTo(op.x, op.y);
+                            break;
+                        case "line":
+                            stream.lineTo(op.x, op.y);
+                            break;
+                        case "curve":
+                            stream.curveTo(op.x1, op.y1, op.x2, op.y2, op.x3, op.y3);
+                            break;
+                        case "close":
+                            stream.closePath();
+                            break;
+                    }
                 }
-            }
-            if (options?.closePath) {
-                stream.closePath();
-            }
-            if (options?.dashPattern && options.dashPattern.length > 0) {
-                stream.setDashPattern(options.dashPattern);
-            }
-            paintFillStroke({
+                if (options?.closePath) {
+                    stream.closePath();
+                }
+            };
+            stream.save();
+            paintFillStroke(buildPath, {
                 fill: options?.fill,
                 stroke: options?.stroke,
-                lineWidth: options?.lineWidth
+                lineWidth: options?.lineWidth,
+                dashPattern: options?.dashPattern
             });
             stream.restore();
             return this;

package/dist/esm/modules/pdf/render/constants.js

@@ -28,3 +28,48 @@ export const INDENT_WIDTH = 10;
  */
 export const MAX_DIGIT_WIDTH_PX = 7;
 export const PX_TO_PT = 72 / 96; // 0.75
+/**
+ * Font size of the printed row-number / column-letter headings, in points.
+ *
+ * Deliberately independent of the grid's print scale: headings are a reading
+ * aid rather than content, so a fixed size stays legible even when the grid is
+ * shrunk to fit, and lets the layout reserve exactly the space it draws.
+ */
+export const HEADING_FONT_SIZE = 8;
+/** Padding around a heading label, in points (applied on both sides). */
+export const HEADING_PADDING = 3;
+/** Background shade and rule color of the heading bands. */
+export const HEADING_FILL = { r: 0.94, g: 0.94, b: 0.94 };
+export const HEADING_RULE = { r: 0.6, g: 0.6, b: 0.6 };
+export const HEADING_TEXT = { r: 0.2, g: 0.2, b: 0.2 };
+/**
+ * Lower bound when solving "fit to N pages", matching the 10% floor of Excel's
+ * Page Setup scaling. A target that is unreachable at this scale — typically
+ * because manual page breaks force more pages than requested — yields more than
+ * N pages rather than shrinking the grid into illegibility.
+ */
+export const FIT_MIN_SCALE = 0.1;
+/**
+ * Side length of the red corner marker Excel draws on a commented cell, in
+ * points at 100% scale.
+ */
+export const COMMENT_MARKER_SIZE = 4;
+/** Comment box fill, border and text colors, matching Excel's note styling. */
+export const COMMENT_FILL = { r: 1, g: 1, b: 0.88 };
+export const COMMENT_BORDER = { r: 0.4, g: 0.4, b: 0.4 };
+export const COMMENT_MARKER_COLOR = { r: 0.8, g: 0, b: 0 };
+/**
+ * Overflow tolerance when packing columns into a page, in points.
+ *
+ * Scaled point widths accumulate rounding error, so a column that mathematically
+ * fits can measure a hair too wide. Rows need no such slack because their
+ * heights are not derived from a character-width conversion.
+ */
+export const COLUMN_FIT_EPSILON = 0.01;
+/**
+ * Height of the bands reserved for the fallback sheet-name header and
+ * page-number footer, in points. Excel header/footers use their own margins;
+ * these are the simple `showSheetNames` / `showPageNumbers` bands.
+ */
+export const SHEET_NAME_BAND_HEIGHT = 20;
+export const PAGE_NUMBER_BAND_HEIGHT = 20;