documonster 0.7.0 → 0.8.0

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

@@ -25,6 +25,7 @@ const image_utils_1 = require("../builder/image-utils.js");
 const pdf_stream_1 = require("../core/pdf-stream.js");
 const font_manager_1 = require("../font/font-manager.js");
 const constants_1 = require("./constants.js");
+const style_converter_1 = require("./style-converter.js");
 function computeCellPadding(cell, scaleFactor = 1) {
     return {
         left: (constants_1.CELL_PADDING_H + cell.borderInsets.left) * scaleFactor,
@@ -113,6 +114,14 @@ 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");
@@ -1355,7 +1364,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 ? (0, style_converter_1.toGrayscale)(rawColor) : rawColor;
             stream.save();
             stream.setFillColor(color);
             stream.setStrokeColor(color);
@@ -1404,6 +1417,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((0, font_manager_1.resolvePdfFontName)(options.defaultFontFamily, false, false));
+    // The heading palette is already neutral gray, so black-and-white needs no
+    // conversion here.
+    const fill = constants_1.HEADING_FILL;
+    const rule = constants_1.HEADING_RULE;
+    const textColor = constants_1.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 ? (0, style_converter_1.toGrayscale)(constants_1.COMMENT_FILL) : constants_1.COMMENT_FILL;
+    const border = bw ? (0, style_converter_1.toGrayscale)(constants_1.COMMENT_BORDER) : constants_1.COMMENT_BORDER;
+    const markerColor = bw ? (0, style_converter_1.toGrayscale)(constants_1.COMMENT_MARKER_COLOR) : constants_1.COMMENT_MARKER_COLOR;
+    const resourceName = fontManager.hasEmbeddedFont()
+        ? fontManager.getEmbeddedResourceName()
+        : fontManager.ensureFont((0, font_manager_1.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 * constants_1.LINE_HEIGHT_FACTOR;
+        const innerWidth = Math.max(rect.width - 2 * constants_1.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 ? (0, style_converter_1.toGrayscale)({ r: 0, g: 0, b: 0 }) : { r: 0, g: 0, b: 0 });
+        let baseline = rect.y + rect.height - constants_1.CELL_PADDING_V - box.fontSize;
+        for (const line of lines) {
+            if (baseline < rect.y + constants_1.CELL_PADDING_V) {
+                break;
+            }
+            fontManager.trackText(line);
+            emitTextWithMatrix(stream, fontManager, {
+                text: line,
+                matrix: [1, 0, 0, 1, rect.x + constants_1.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;
@@ -1507,7 +1683,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 ? (0, style_converter_1.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/cjs/modules/pdf/render/pdf-exporter.js

@@ -148,7 +148,9 @@ function preflightCharts(allPages, fontManager) {
             }
             const stream = new pdf_stream_1.PdfContentStream();
             const alphaValues = new Set();
-            const surface = (0, chart_surface_1.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 = (0, chart_surface_1.createChartSurface)(stream, fontManager, alphaValues, page.options.blackAndWhite);
             chart.drawVector(surface, constrainChartAspectRatio(chart.rect));
             cache.set(chart, { stream, alphaValues });
         }
@@ -270,6 +272,10 @@ function renderSinglePage(page, fontManager, writer, fontObjectMap, chartCache,
         const { stream: contentStream, alphaValues } = (0, page_renderer_1.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 = (0, page_renderer_1.selectHeaderFooter)(page, "header");
         const footerContent = (0, page_renderer_1.selectHeaderFooter)(page, "footer");
@@ -285,23 +291,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 pdf_object_1.PdfDict(), imageStream);
@@ -310,7 +321,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);
             }
@@ -339,7 +350,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);
                 }
@@ -359,7 +370,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
@@ -440,6 +451,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);
@@ -453,13 +466,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 = (0, image_utils_1.writeImageXObject)(writer, data, format);
-    cache.set(data, objectNumber);
+    const objectNumber = (0, image_utils_1.writeImageXObject)(writer, data, format, grayscale);
+    variants.set(grayscale, objectNumber);
     return objectNumber;
 }
 function headerFooterImagePositions(content, kind) {
@@ -543,6 +561,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.
  */
@@ -563,40 +685,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 = (0, style_converter_1.argbToPdfColor)(gridLineColorStr) ?? {
+    const gridLineColorRaw = (0, style_converter_1.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 && !(0, types_1.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 ? (0, style_converter_1.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) && !(0, types_1.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/cjs/modules/pdf/render/style-converter.js

@@ -13,6 +13,8 @@ exports.DEFAULT_COLORS = void 0;
 exports.argbToPdfColor = argbToPdfColor;
 exports.excelColorToPdf = excelColorToPdf;
 exports.applyTint = applyTint;
+exports.toGrayscale = toGrayscale;
+exports.grayscaleBorders = grayscaleBorders;
 exports.extractFontProperties = extractFontProperties;
 exports.excelFillToPdfColor = excelFillToPdfColor;
 exports.borderStyleToLineWidth = borderStyleToLineWidth;
@@ -177,6 +179,30 @@ function indexedColorToPdf(index) {
 function applyTint(color, tint) {
     return (0, theme_colors_1.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.
+ */
+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. */
+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.
  */

package/dist/esm/modules/pdf/builder/image-utils.js

@@ -76,41 +76,90 @@ export function parseJpegDimensions(data) {
  * Write an image XObject (JPEG or PNG) to the writer.
  * Returns the allocated object number.
  */
-export function writeImageXObject(writer, data, format) {
+export function writeImageXObject(writer, data, format, grayscale = false) {
     if (format === "png") {
-        return writePngImageXObject(writer, data);
+        return writePngImageXObject(writer, data, grayscale);
     }
-    return writeJpegImageXObject(writer, data);
+    return writeJpegImageXObject(writer, data, grayscale);
 }
 /**
- * Write a JPEG image using DCTDecode (raw JPEG data embedded directly).
+ * Write the PostScript calculator function that converts an RGB triple to its
+ * Rec. 601 luma, and return its object number.
+ *
+ * Used as the tint transform of a `/DeviceN` space so a JPEG can be recoloured
+ * without decoding it: the samples stay untouched and the consumer applies the
+ * transform per pixel. Unlike painting a blend on top, this cannot darken
+ * transparent areas, because it *is* the color space rather than an overlay.
  */
-function writeJpegImageXObject(writer, data) {
+function writeLumaTintTransform(writer) {
     const objNum = writer.allocObject();
+    const dict = new PdfDict()
+        .set("FunctionType", "4")
+        .set("Domain", "[0 1 0 1 0 1]")
+        .set("Range", "[0 1]");
+    // Stack on entry is R G B (B on top):
+    //   0.114 mul  -> R G 0.114B
+    //   exch       -> R 0.114B G
+    //   0.587 mul  -> R 0.114B 0.587G
+    //   add        -> R (0.114B + 0.587G)
+    //   exch       -> (0.114B + 0.587G) R
+    //   0.299 mul  -> (0.114B + 0.587G) 0.299R
+    //   add        -> luma
+    const program = "{ 0.114 mul exch 0.587 mul add exch 0.299 mul add }";
+    writer.addStreamObject(objNum, dict, new TextEncoder().encode(program));
+    return objNum;
+}
+/**
+ * Write a JPEG image using DCTDecode (raw JPEG data embedded directly).
+ */
+function writeJpegImageXObject(writer, data, grayscale = false) {
     const dims = parseJpegDimensions(data);
+    // Grayscale without a JPEG decoder: keep the DCTDecode samples and reinterpret
+    // the three components through a `/DeviceN` space whose tint transform is the
+    // luma formula. Component count still matches the JPEG, as PDF requires.
+    const tintRef = grayscale ? writeLumaTintTransform(writer) : undefined;
+    const objNum = writer.allocObject();
     const dict = new PdfDict()
         .set("Type", "/XObject")
         .set("Subtype", "/Image")
         .set("Width", pdfNumber(dims.width))
         .set("Height", pdfNumber(dims.height))
-        .set("ColorSpace", "/DeviceRGB")
+        .set("ColorSpace", tintRef === undefined
+        ? "/DeviceRGB"
+        : `[/DeviceN [/C1 /C2 /C3] /DeviceGray ${pdfRef(tintRef)}]`)
         .set("BitsPerComponent", "8")
         .set("Filter", "/DCTDecode");
     writer.addStreamObject(objNum, dict, data);
     return objNum;
 }
+/** Rec. 601 luma of an 8-bit RGB triple. */
+function lumaByte(r, g, b) {
+    return Math.round(0.299 * r + 0.587 * g + 0.114 * b);
+}
 /**
  * Write a PNG image: decode to raw RGB, create SMask for alpha if needed.
  */
-function writePngImageXObject(writer, data) {
+function writePngImageXObject(writer, data, grayscale = false) {
     const png = decodePng(data);
     const objNum = writer.allocObject();
+    // PNG is already decoded to raw samples here, so grayscale is a real pixel
+    // conversion: collapse RGB to one luma component and switch to DeviceGray.
+    // The alpha channel lives in a separate SMask and is untouched, so transparent
+    // regions stay transparent.
+    let pixels = png.pixels;
+    if (grayscale) {
+        const gray = new Uint8Array(png.width * png.height);
+        for (let i = 0, p = 0; i < gray.length; i++, p += 3) {
+            gray[i] = lumaByte(pixels[p], pixels[p + 1], pixels[p + 2]);
+        }
+        pixels = gray;
+    }
     const dict = new PdfDict()
         .set("Type", "/XObject")
         .set("Subtype", "/Image")
         .set("Width", pdfNumber(png.width))
         .set("Height", pdfNumber(png.height))
-        .set("ColorSpace", "/DeviceRGB")
+        .set("ColorSpace", grayscale ? "/DeviceGray" : "/DeviceRGB")
         .set("BitsPerComponent", pdfNumber(png.bitsPerComponent));
     if (png.alpha) {
         const smaskObjNum = writer.allocObject();
@@ -124,6 +173,6 @@ function writePngImageXObject(writer, data) {
         writer.addStreamObject(smaskObjNum, smaskDict, png.alpha);
         dict.set("SMask", pdfRef(smaskObjNum));
     }
-    writer.addStreamObject(objNum, dict, png.pixels);
+    writer.addStreamObject(objNum, dict, pixels);
     return objNum;
 }