documonster 0.7.0 → 0.8.0

package/dist/browser/modules/pdf/render/page-renderer.js

@@ -12,7 +12,8 @@
 import { parseImageDimensions } from "../builder/image-utils.js";
 import { PdfContentStream } from "../core/pdf-stream.js";
 import { resolvePdfFontName } from "../font/font-manager.js";
-import { CELL_PADDING_H, CELL_PADDING_V, LINE_HEIGHT_FACTOR, INDENT_WIDTH } from "./constants.js";
+import { CELL_PADDING_H, CELL_PADDING_V, LINE_HEIGHT_FACTOR, INDENT_WIDTH, HEADING_FILL, HEADING_RULE, HEADING_TEXT, COMMENT_FILL, COMMENT_BORDER, COMMENT_MARKER_COLOR } from "./constants.js";
+import { toGrayscale } from "./style-converter.js";
 function computeCellPadding(cell, scaleFactor = 1) {
     return {
         left: (CELL_PADDING_H + cell.borderInsets.left) * scaleFactor,
@@ -101,6 +102,14 @@ export function renderPage(page, options, fontManager, totalPages) {
             drawCellText(stream, cell, fontManager, alphaValues, sf);
         }
     }
+    // --- Step 5b: Draw printed row/column headings ---
+    if (options.showRowColHeaders) {
+        drawRowColHeadings(stream, page, options, fontManager);
+    }
+    // --- Step 5c: Draw comment boxes over the grid ---
+    if (page.commentBoxes?.length) {
+        drawCommentBoxes(stream, page, options, fontManager);
+    }
     // --- Step 5: Draw page header (sheet name) ---
     const excelHeader = selectHeaderFooter(page, "header");
     const excelFooter = selectHeaderFooter(page, "footer");
@@ -1343,7 +1352,11 @@ function drawHeaderFooterSection(stream, page, fontManager, runs, anchorX, basel
                 : run.subscript
                     ? -fontSize * HEADER_FOOTER_METRICS.SUBSCRIPT_DROP
                     : 0;
-            const color = run.color ?? { r: 0, g: 0, b: 0 };
+            // Header/footer runs carry their own `&K` colors, which bypass the cell
+            // style pipeline — apply black-and-white here.
+            const bw = page.options.blackAndWhite;
+            const rawColor = run.color ?? { r: 0, g: 0, b: 0 };
+            const color = bw ? toGrayscale(rawColor) : rawColor;
             stream.save();
             stream.setFillColor(color);
             stream.setStrokeColor(color);
@@ -1392,6 +1405,169 @@ function resolveLineRuns(line, page, fontManager) {
         return { run, text, resourceName, fontSize, width };
     });
 }
+// =============================================================================
+// Row / Column Headings
+// =============================================================================
+/** Convert a 1-based column number to its Excel letters (1 → "A", 27 → "AA"). */
+function columnNumberToLetters(col) {
+    let n = col;
+    let out = "";
+    while (n > 0) {
+        const rem = (n - 1) % 26;
+        out = String.fromCharCode(65 + rem) + out;
+        n = Math.floor((n - 1) / 26);
+    }
+    return out;
+}
+/**
+ * Draw Excel's printed row numbers and column letters around the grid.
+ *
+ * The bands occupy space reserved by the layout engine (see
+ * `computeHeadingMetrics`), so the grid origin already accounts for them and
+ * nothing here can push content off the page.
+ */
+function drawRowColHeadings(stream, page, options, fontManager) {
+    const headings = page.headings;
+    if (!headings || page.columnWidths.length === 0 || page.rowHeights.length === 0) {
+        return;
+    }
+    const { gutterWidth, bandHeight, fontSize } = headings;
+    const resourceName = fontManager.hasEmbeddedFont()
+        ? fontManager.getEmbeddedResourceName()
+        : fontManager.ensureFont(resolvePdfFontName(options.defaultFontFamily, false, false));
+    // The heading palette is already neutral gray, so black-and-white needs no
+    // conversion here.
+    const fill = HEADING_FILL;
+    const rule = HEADING_RULE;
+    const textColor = HEADING_TEXT;
+    const gridLeft = page.columnOffsets[0];
+    const lastCol = page.columnWidths.length - 1;
+    const gridRight = page.columnOffsets[lastCol] + page.columnWidths[lastCol];
+    const gridTop = page.rowYPositions[0];
+    const lastRow = page.rowHeights.length - 1;
+    const gridBottom = page.rowYPositions[lastRow] - page.rowHeights[lastRow];
+    stream.save();
+    // Band backgrounds: column letters above the grid, row numbers to its left,
+    // plus the corner square where the two meet.
+    stream.fillRect(gridLeft, gridTop, gridRight - gridLeft, bandHeight, fill);
+    stream.fillRect(gridLeft - gutterWidth, gridBottom, gutterWidth, gridTop - gridBottom, fill);
+    stream.fillRect(gridLeft - gutterWidth, gridTop, gutterWidth, bandHeight, fill);
+    // Rules: one per column boundary through the top band, one per row boundary
+    // through the gutter, and the two outer edges.
+    stream.setStrokeColor(rule);
+    stream.setLineWidth(0.25);
+    for (let i = 0; i <= page.columnWidths.length; i++) {
+        const x = i < page.columnWidths.length
+            ? page.columnOffsets[i]
+            : page.columnOffsets[i - 1] + page.columnWidths[i - 1];
+        stream.moveTo(x, gridTop);
+        stream.lineTo(x, gridTop + bandHeight);
+    }
+    for (let i = 0; i <= page.rowYPositions.length; i++) {
+        const y = i < page.rowYPositions.length
+            ? page.rowYPositions[i]
+            : page.rowYPositions[i - 1] - page.rowHeights[i - 1];
+        stream.moveTo(gridLeft - gutterWidth, y);
+        stream.lineTo(gridLeft, y);
+    }
+    stream.moveTo(gridLeft - gutterWidth, gridTop + bandHeight);
+    stream.lineTo(gridRight, gridTop + bandHeight);
+    stream.moveTo(gridLeft - gutterWidth, gridBottom);
+    stream.lineTo(gridLeft - gutterWidth, gridTop + bandHeight);
+    stream.stroke();
+    // Labels, centered in their band cell.
+    stream.setFillColor(textColor);
+    const baselineOffset = (bandHeight - fontSize) / 2 + fontSize * 0.2;
+    for (let i = 0; i < page.sheetCols.length; i++) {
+        const label = columnNumberToLetters(page.sheetCols[i]);
+        fontManager.trackText(label);
+        const w = fontManager.measureText(label, resourceName, fontSize);
+        const x = page.columnOffsets[i] + (page.columnWidths[i] - w) / 2;
+        emitTextWithMatrix(stream, fontManager, {
+            text: label,
+            matrix: [1, 0, 0, 1, x, gridTop + baselineOffset],
+            resourceName,
+            fontSize
+        });
+    }
+    for (let i = 0; i < page.sheetRows.length; i++) {
+        const label = String(page.sheetRows[i]);
+        fontManager.trackText(label);
+        const w = fontManager.measureText(label, resourceName, fontSize);
+        const rowH = page.rowHeights[i];
+        const x = gridLeft - gutterWidth + (gutterWidth - w) / 2;
+        const y = page.rowYPositions[i] - rowH + (rowH - fontSize) / 2 + fontSize * 0.2;
+        emitTextWithMatrix(stream, fontManager, {
+            text: label,
+            matrix: [1, 0, 0, 1, x, y],
+            resourceName,
+            fontSize
+        });
+    }
+    stream.restore();
+}
+/**
+ * Draw Excel's on-sheet comment boxes and their cell corner markers.
+ *
+ * Positioned by the layout engine, so this only has to paint: a pale note-yellow
+ * box with a thin border, the wrapped body inside it, and the small red triangle
+ * Excel puts in the commented cell's top-right corner.
+ */
+function drawCommentBoxes(stream, page, options, fontManager) {
+    const boxes = page.commentBoxes;
+    if (!boxes?.length) {
+        return;
+    }
+    const bw = options.blackAndWhite;
+    const fill = bw ? toGrayscale(COMMENT_FILL) : COMMENT_FILL;
+    const border = bw ? toGrayscale(COMMENT_BORDER) : COMMENT_BORDER;
+    const markerColor = bw ? toGrayscale(COMMENT_MARKER_COLOR) : COMMENT_MARKER_COLOR;
+    const resourceName = fontManager.hasEmbeddedFont()
+        ? fontManager.getEmbeddedResourceName()
+        : fontManager.ensureFont(resolvePdfFontName(options.defaultFontFamily, false, false));
+    for (const box of boxes) {
+        const { rect } = box;
+        stream.save();
+        stream.fillRect(rect.x, rect.y, rect.width, rect.height, fill);
+        stream.setStrokeColor(border);
+        stream.setLineWidth(0.5);
+        stream.rect(rect.x, rect.y, rect.width, rect.height);
+        stream.stroke();
+        // Body text, wrapped to the box and clipped by simply stopping once the
+        // remaining height is used up.
+        const lineHeight = box.fontSize * LINE_HEIGHT_FACTOR;
+        const innerWidth = Math.max(rect.width - 2 * CELL_PADDING_H, 1);
+        const measure = (t) => fontManager.measureText(t, resourceName, box.fontSize);
+        const lines = box.text.split("\n").flatMap(part => wrapTextLines(part, measure, innerWidth));
+        stream.setFillColor(bw ? toGrayscale({ r: 0, g: 0, b: 0 }) : { r: 0, g: 0, b: 0 });
+        let baseline = rect.y + rect.height - CELL_PADDING_V - box.fontSize;
+        for (const line of lines) {
+            if (baseline < rect.y + CELL_PADDING_V) {
+                break;
+            }
+            fontManager.trackText(line);
+            emitTextWithMatrix(stream, fontManager, {
+                text: line,
+                matrix: [1, 0, 0, 1, rect.x + CELL_PADDING_H, baseline],
+                resourceName,
+                fontSize: box.fontSize
+            });
+            baseline -= lineHeight;
+        }
+        stream.restore();
+        if (box.marker) {
+            const { x, y, size } = box.marker;
+            stream.save();
+            stream.setFillColor(markerColor);
+            stream.moveTo(x - size, y);
+            stream.lineTo(x, y);
+            stream.lineTo(x, y - size);
+            stream.closePath();
+            stream.fill();
+            stream.restore();
+        }
+    }
+}
 function drawPageHeader(stream, page, options, fontManager) {
     const headerFontSize = 10;
     const headerText = page.sheetName;
@@ -1495,7 +1671,8 @@ function clamp01(v) {
  */
 function renderTextWatermark(stream, page, watermark, fontManager) {
     const fontSize = watermark.fontSize ?? TEXT_WM_DEFAULTS.fontSize;
-    const color = watermark.color ?? TEXT_WM_DEFAULTS.color;
+    const rawColor = watermark.color ?? TEXT_WM_DEFAULTS.color;
+    const color = page.options.blackAndWhite ? toGrayscale(rawColor) : rawColor;
     const opacity = watermark.opacity ?? TEXT_WM_DEFAULTS.opacity;
     const rotation = watermark.rotation ?? TEXT_WM_DEFAULTS.rotation;
     const fontFamily = watermark.fontFamily ?? TEXT_WM_DEFAULTS.fontFamily;

package/dist/browser/modules/pdf/render/pdf-exporter.js

@@ -19,7 +19,7 @@ import { parseTtf } from "../font/ttf-parser.js";
 import { createChartSurface } from "./chart-surface.js";
 import { layoutChartsheet, layoutSheet } from "./layout-engine.js";
 import { renderPage, alphaGsName, renderWatermark, resolveHeaderFooterRunText, selectHeaderFooter } from "./page-renderer.js";
-import { argbToPdfColor } from "./style-converter.js";
+import { argbToPdfColor, toGrayscale } from "./style-converter.js";
 import { PageSizes, PdfCellType, isPdfChartsheet } from "../types.js";
 import { yieldToEventLoop } from "../../../utils/utils.base.js";
 // =============================================================================
@@ -145,7 +145,9 @@ function preflightCharts(allPages, fontManager) {
             }
             const stream = new PdfContentStream();
             const alphaValues = new Set();
-            const surface = createChartSurface(stream, fontManager, alphaValues);
+            // Black-and-white is a per-sheet print option, and each page carries the
+            // options of the sheet that produced it.
+            const surface = createChartSurface(stream, fontManager, alphaValues, page.options.blackAndWhite);
             chart.drawVector(surface, constrainChartAspectRatio(chart.rect));
             cache.set(chart, { stream, alphaValues });
         }
@@ -267,6 +269,10 @@ function renderSinglePage(page, fontManager, writer, fontObjectMap, chartCache,
         const { stream: contentStream, alphaValues } = renderPage(page, page.options, fontManager, totalPages);
         // Handle images: create XObject Image entries and draw them
         const imageXObjects = new Map();
+        // Raster payloads are converted when the XObject is written — a real pixel
+        // conversion for PNG, a `/DeviceN` luma space for JPEG — so no overlay is
+        // painted and transparency is preserved.
+        const grayscaleRaster = page.options.blackAndWhite;
         let headerImageContentObjNum;
         const headerContent = selectHeaderFooter(page, "header");
         const footerContent = selectHeaderFooter(page, "footer");
@@ -282,23 +288,28 @@ function renderSinglePage(page, fontManager, writer, fontObjectMap, chartCache,
             const rightEdge = alignWithMargins
                 ? page.width - page.options.margins.right
                 : page.width - 18;
+            // `scaleWithDoc` governs the whole header/footer, not just its text, so a
+            // logo has to shrink with the grid the same way the runs do.
+            const hfScale = page.headerFooter?.scaleWithDoc === false ? 1 : page.scaleFactor;
             for (let index = 0; index < headerImages.length; index++) {
                 const headerImage = headerImages[index];
                 if (!activePositions.has(headerImage.position)) {
                     continue;
                 }
                 const imageName = `HfIm${index + 1}`;
-                imageXObjects.set(imageName, getOrWriteImageObject(writer, imageObjectCache, headerImage.data, headerImage.format));
+                imageXObjects.set(imageName, getOrWriteImageObject(writer, imageObjectCache, headerImage.data, headerImage.format, grayscaleRaster));
+                const drawWidth = headerImage.width * hfScale;
+                const drawHeight = headerImage.height * hfScale;
                 const placement = headerFooterImagePlacement(headerImage.position);
                 const imageX = placement.section === "left"
                     ? leftEdge
                     : placement.section === "right"
-                        ? rightEdge - headerImage.width
-                        : (page.width - headerImage.width) / 2;
+                        ? rightEdge - drawWidth
+                        : (page.width - drawWidth) / 2;
                 const imageY = placement.kind === "header"
-                    ? page.height - page.options.headerMargin - headerImage.height
+                    ? page.height - page.options.headerMargin - drawHeight
                     : page.options.footerMargin;
-                imageStream.drawImage(imageName, imageX, imageY, headerImage.width, headerImage.height);
+                imageStream.drawImage(imageName, imageX, imageY, drawWidth, drawHeight);
             }
             headerImageContentObjNum = writer.allocObject();
             writer.addStreamObject(headerImageContentObjNum, new PdfDict(), imageStream);
@@ -307,7 +318,7 @@ function renderSinglePage(page, fontManager, writer, fontObjectMap, chartCache,
             for (let imgIdx = 0; imgIdx < page.images.length; imgIdx++) {
                 const img = page.images[imgIdx];
                 const imgName = `Im${imgIdx + 1}`;
-                const imgObjNum = getOrWriteImageObject(writer, imageObjectCache, img.data, img.format);
+                const imgObjNum = getOrWriteImageObject(writer, imageObjectCache, img.data, img.format, grayscaleRaster);
                 imageXObjects.set(imgName, imgObjNum);
                 contentStream.drawImage(imgName, img.rect.x, img.rect.y, img.rect.width, img.rect.height);
             }
@@ -336,7 +347,7 @@ function renderSinglePage(page, fontManager, writer, fontObjectMap, chartCache,
                 }
                 if (chart.raster) {
                     const imgName = `Im${++rasterCounter}`;
-                    const imgObjNum = getOrWriteImageObject(writer, imageObjectCache, chart.raster.data, chart.raster.format);
+                    const imgObjNum = getOrWriteImageObject(writer, imageObjectCache, chart.raster.data, chart.raster.format, grayscaleRaster);
                     imageXObjects.set(imgName, imgObjNum);
                     contentStream.drawImage(imgName, chart.rect.x, chart.rect.y, chart.rect.width, chart.rect.height);
                 }
@@ -356,7 +367,7 @@ function renderSinglePage(page, fontManager, writer, fontObjectMap, chartCache,
             }
             // Register watermark image XObjects
             for (const wmImg of wmResult.imageXObjects) {
-                const imgObjNum = getOrWriteImageObject(writer, imageObjectCache, wmImg.data, wmImg.format);
+                const imgObjNum = getOrWriteImageObject(writer, imageObjectCache, wmImg.data, wmImg.format, grayscaleRaster);
                 imageXObjects.set(wmImg.name, imgObjNum);
             }
             // Write watermark content stream object
@@ -437,6 +448,8 @@ function renderSinglePage(page, fontManager, writer, fontObjectMap, chartCache,
             height: page.height,
             contentsRef: contentsRef,
             resourcesRef: resourcesObjNum,
+            // Constant alpha needs a defined backdrop.
+            transparencyGroup: alphaValues.size > 0,
             annotRefs: annotRefs.length > 0 ? annotRefs : undefined
         });
         pageObjNums.push(pageObjNum);
@@ -450,13 +463,18 @@ function renderSinglePage(page, fontManager, writer, fontObjectMap, chartCache,
         });
     }
 }
-function getOrWriteImageObject(writer, cache, data, format) {
-    const existing = cache.get(data);
+function getOrWriteImageObject(writer, cache, data, format, grayscale = false) {
+    let variants = cache.get(data);
+    if (variants === undefined) {
+        variants = new Map();
+        cache.set(data, variants);
+    }
+    const existing = variants.get(grayscale);
     if (existing !== undefined) {
         return existing;
     }
-    const objectNumber = writeImageXObject(writer, data, format);
-    cache.set(data, objectNumber);
+    const objectNumber = writeImageXObject(writer, data, format, grayscale);
+    variants.set(grayscale, objectNumber);
     return objectNumber;
 }
 function headerFooterImagePositions(content, kind) {
@@ -540,6 +558,110 @@ function selectSheets(workbook, sheets) {
 // =============================================================================
 // Options Resolution
 // =============================================================================
+/**
+ * Parse an Excel "Columns to repeat at left" reference (`printTitlesColumn`)
+ * into an absolute column band, e.g. `"A:B"` → `{ first: 1, last: 2 }`.
+ *
+ * Returns `null` for anything that is not a column range.
+ */
+function parseTitlesColumnBand(ref) {
+    const match = ref
+        .replace(/\$/g, "")
+        .toUpperCase()
+        .match(/^([A-Z]+)(?::([A-Z]+))?$/);
+    if (!match) {
+        return null;
+    }
+    const first = columnLettersToNumber(match[1]);
+    const last = match[2] ? columnLettersToNumber(match[2]) : first;
+    if (last < first) {
+        return null;
+    }
+    return { first, last };
+}
+/**
+ * Parse an Excel "Rows to repeat at top" reference (`printTitlesRow`) into an
+ * absolute row band, e.g. `"1:3"` → `{ first: 1, last: 3 }`.
+ */
+function parseTitlesRowBand(ref) {
+    const match = ref.replace(/\$/g, "").match(/^(\d+)(?::(\d+))?$/);
+    if (!match) {
+        return null;
+    }
+    const first = parseInt(match[1], 10);
+    const last = match[2] ? parseInt(match[2], 10) : first;
+    if (first < 1 || last < first) {
+        return null;
+    }
+    return { first, last };
+}
+function columnLettersToNumber(letters) {
+    let n = 0;
+    for (let i = 0; i < letters.length; i++) {
+        n = n * 26 + (letters.charCodeAt(i) - 64);
+    }
+    return n;
+}
+function normalizePageOrder(value) {
+    return value === "overThenDown" ? "overThenDown" : "downThenOver";
+}
+/** Excel writes `None` / `asDisplayed` / `atEnd`. */
+function normalizeCommentMode(value) {
+    if (value === "atEnd" || value === "asDisplayed") {
+        return value;
+    }
+    return "none";
+}
+function normalizeErrorMode(value) {
+    switch (value) {
+        case "blank":
+        case "dash":
+        case "NA":
+            return value;
+        default:
+            return "displayed";
+    }
+}
+/**
+ * Reconcile documonster's scaling options with Excel's two mutually exclusive
+ * scaling modes (Page Setup → Scaling):
+ *
+ *  - **"Adjust to N %"** — `pageSetup.scale`, with `pageSetup.fitToPage` off.
+ *  - **"Fit to N pages wide by M tall"** — `pageSetup.fitToWidth` /
+ *    `fitToHeight`, with `pageSetup.fitToPage` on. Excel ignores `scale` here.
+ *
+ * Neither mode ever enlarges: Excel caps fit-to-page scaling at 100%.
+ *
+ * `PdfExportOptions.fitToPage` is documonster's own convenience default
+ * ("shrink to one page wide"). It only applies when neither the caller nor the
+ * sheet expresses a scaling intent, so a sheet that asks for 80% is not
+ * shrunk twice.
+ */
+function resolveScaling(options, ps) {
+    const clampPages = (n) => n === undefined || !Number.isFinite(n) || n <= 0 ? 0 : Math.floor(n);
+    const callerFit = options?.fitToWidth !== undefined || options?.fitToHeight !== undefined;
+    const sheetFitMode = ps?.fitToPage === true;
+    let fitToWidth = 0;
+    let fitToHeight = 0;
+    if (callerFit) {
+        fitToWidth = clampPages(options?.fitToWidth);
+        fitToHeight = clampPages(options?.fitToHeight);
+    }
+    else if (sheetFitMode && options?.scale === undefined && options?.fitToPage !== false) {
+        // `fitToPage: false` is the caller saying "do not auto-scale"; it has to
+        // beat the sheet's own fit-to-N mode, or an explicit option would lose to
+        // the workbook it is meant to override.
+        fitToWidth = clampPages(ps?.fitToWidth);
+        fitToHeight = clampPages(ps?.fitToHeight);
+    }
+    // A sheet in "Adjust to N %" mode with a non-default percentage.
+    const sheetScalePercent = !sheetFitMode && ps?.scale !== undefined && ps.scale !== 100 ? ps.scale / 100 : undefined;
+    // Excel's Page Setup allows 10–400%, so the ceiling is 4.0 rather than 3.0.
+    const scale = Math.max(0.1, Math.min(4.0, options?.scale ?? sheetScalePercent ?? 1.0));
+    const hasFitConstraint = fitToWidth > 0 || fitToHeight > 0;
+    const fitToPage = options?.fitToPage ?? !(hasFitConstraint || sheetScalePercent !== undefined || callerFit);
+    return { fitToPage, scale, fitToWidth, fitToHeight };
+}
 /**
  * Resolve user options with defaults.
  */
@@ -560,40 +682,59 @@ function resolveOptions(options, sheet) {
         chartsheetOrientation ??
         (ps?.orientation === "landscape" ? "landscape" : "portrait");
     const margins = resolveMargins(options?.margins, ps?.margins);
+    const blackAndWhite = options?.blackAndWhite ?? ps?.blackAndWhite ?? false;
     const gridLineColorStr = options?.gridLineColor ?? "FFD0D0D0";
-    const gridLineColor = argbToPdfColor(gridLineColorStr) ?? {
+    const gridLineColorRaw = argbToPdfColor(gridLineColorStr) ?? {
         r: 0.816,
         g: 0.816,
         b: 0.816
     };
-    // Use sheet's printTitlesRow as fallback for repeatRows. Only
-    // PdfSheetData carries `printTitlesRow` — chartsheets never have
-    // repeated header rows.
-    let repeatRows = options?.repeatRows ?? false;
-    if (repeatRows === false && sheet && !isPdfChartsheet(sheet) && ps?.printTitlesRow) {
-        // printTitlesRow format: "1:3" (repeat rows 1-3) or "1" (repeat row 1)
-        const match = ps.printTitlesRow.match(/^(\d+)(?::(\d+))?$/);
-        if (match) {
-            repeatRows = parseInt(match[2] ?? match[1], 10);
-        }
-    }
+    const gridLineColor = blackAndWhite ? toGrayscale(gridLineColorRaw) : gridLineColorRaw;
+    // Repeated title rows/columns fall back to the sheet's print titles. Only
+    // PdfSheetData carries them — chartsheets have no repeated bands. An
+    // explicitly passed `false` suppresses the sheet setting, so "not provided"
+    // (undefined) and "provided as off" must stay distinguishable.
+    const isWorksheet = Boolean(sheet) && !isPdfChartsheet(sheet);
+    // A caller-supplied count means "the first N rows/columns of the sheet"; the
+    // sheet's own print titles are absolute ranges that may sit outside the print
+    // area, so both normalise to an absolute band.
+    const countToBand = (n) => typeof n === "number" && n > 0 ? { first: 1, last: n } : false;
+    let repeatRows = false;
+    if (options?.repeatRows !== undefined) {
+        repeatRows = countToBand(options.repeatRows);
+    }
+    else if (isWorksheet && ps?.printTitlesRow) {
+        repeatRows = parseTitlesRowBand(ps.printTitlesRow) ?? false;
+    }
+    let repeatCols = false;
+    if (options?.repeatCols !== undefined) {
+        repeatCols = countToBand(options.repeatCols);
+    }
+    else if (isWorksheet && ps?.printTitlesColumn) {
+        repeatCols = parseTitlesColumnBand(ps.printTitlesColumn) ?? false;
+    }
+    const { fitToPage, scale, fitToWidth, fitToHeight } = resolveScaling(options, ps);
     return {
         pageSize,
         orientation,
         margins,
         ignorePrintArea: options?.ignorePrintArea ?? false,
-        fitToPage: options?.fitToPage !== undefined ? options.fitToPage : true,
-        scale: Math.max(0.1, Math.min(3.0, options?.scale ??
-            // When fitToPage is active (default), ignore sheet's pageSetup.scale
-            // to avoid double-scaling. Only apply sheet scale when fitToPage is off.
-            ((options?.fitToPage !== undefined ? options.fitToPage : true)
-                ? 1.0
-                : ps?.scale
-                    ? ps.scale / 100
-                    : 1.0))),
+        fitToPage,
+        scale,
+        fitToWidth,
+        fitToHeight,
         showGridLines: options?.showGridLines ?? ps?.showGridLines ?? false,
         gridLineColor,
+        showRowColHeaders: options?.showRowColHeaders ?? ps?.showRowColHeaders ?? false,
+        horizontalCentered: options?.horizontalCentered ?? ps?.horizontalCentered ?? false,
+        verticalCentered: options?.verticalCentered ?? ps?.verticalCentered ?? false,
+        pageOrder: options?.pageOrder ?? normalizePageOrder(ps?.pageOrder),
+        blackAndWhite,
+        draft: options?.draft ?? ps?.draft ?? false,
+        errors: options?.errors ?? normalizeErrorMode(ps?.errors),
+        cellComments: options?.cellComments ?? normalizeCommentMode(ps?.cellComments),
         repeatRows,
+        repeatCols,
         defaultFontFamily: options?.defaultFontFamily ?? "Helvetica",
         defaultFontSize: options?.defaultFontSize ?? 11,
         showSheetNames: options?.showSheetNames ?? false,

package/dist/browser/modules/pdf/render/style-converter.d.ts

@@ -27,6 +27,17 @@ export declare function excelColorToPdf(color: Partial<PdfColorData> | undefined
  * @see OOXML §18.8.19 - tint formula
  */
 export declare function applyTint(color: PdfColor, tint: number): PdfColor;
+/**
+ * Convert a color to its luminance-preserving grayscale equivalent, using the
+ * Rec. 601 luma weights. Backs Excel's "Black and white" print option: hues are
+ * discarded while relative lightness — and therefore contrast — is kept.
+ *
+ * Opacity is carried through untouched; dropping it would make transparent
+ * chart fills opaque.
+ */
+export declare function toGrayscale(color: PdfColor): PdfColor;
+/** Grayscale every edge of a border set, preserving `null` edges. */
+export declare function grayscaleBorders(borders: LayoutBorders): LayoutBorders;
 /**
  * Default colors used in PDF rendering.
  */

package/dist/browser/modules/pdf/render/style-converter.js

@@ -165,6 +165,30 @@ function indexedColorToPdf(index) {
 export function applyTint(color, tint) {
     return applyTintRgb01(color, tint);
 }
+/**
+ * Convert a color to its luminance-preserving grayscale equivalent, using the
+ * Rec. 601 luma weights. Backs Excel's "Black and white" print option: hues are
+ * discarded while relative lightness — and therefore contrast — is kept.
+ *
+ * Opacity is carried through untouched; dropping it would make transparent
+ * chart fills opaque.
+ */
+export function toGrayscale(color) {
+    const luma = 0.299 * color.r + 0.587 * color.g + 0.114 * color.b;
+    return color.a === undefined
+        ? { r: luma, g: luma, b: luma }
+        : { r: luma, g: luma, b: luma, a: color.a };
+}
+/** Grayscale every edge of a border set, preserving `null` edges. */
+export function grayscaleBorders(borders) {
+    const convert = (b) => b === null ? null : { ...b, color: toGrayscale(b.color) };
+    return {
+        top: convert(borders.top),
+        right: convert(borders.right),
+        bottom: convert(borders.bottom),
+        left: convert(borders.left)
+    };
+}
 /**
  * Default colors used in PDF rendering.
  */