@cj-tech-master/excelts 9.5.4 → 9.5.5

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

@@ -1,9 +1,27 @@
 /**
  * Word-to-PDF Bridge
  *
- * Converts a Word document (DocxDocument) to PDF.
- * Like excel-bridge.ts, this is the ONLY file in the PDF module that imports
- * from @word.
+ * Converts a Word document (`DocxDocument`) to PDF.
+ *
+ * The bridge is a thin translation layer:
+ *
+ *   DocxDocument
+ *      │
+ *      │  layoutDocumentFull()  ← @word/layout
+ *      ▼
+ *   LayoutDocument (positioned PageContent variants)
+ *      │
+ *      │  renderLayoutDocumentToPdf()  ← ./render-layout-to-pdf
+ *      ▼
+ *   PdfDocumentBuilder → bytes
+ *
+ * Every flow decision (line wrapping, page breaks, table sizing,
+ * float positioning) lives in `@word/layout`. This file only handles
+ * option mapping, optional chart-renderer auto-detection, and the
+ * final `builder.build()` serialization.
+ *
+ * Like `excel-bridge.ts`, this is the ONLY file in the PDF module that
+ * imports from `@word`.
  *
  * @example
  * ```typescript
@@ -13,292 +31,122 @@
  * const doc = await readDocx(docxBytes);
  * const pdfBytes = await docxToPdf(doc);
  * ```
- *
- * Note: This is a simple flow-based renderer. For high-fidelity output,
- * consider using Microsoft Word or LibreOffice.
  */
-import { PdfDocumentBuilder } from "./builder/document-builder.js";
+import { layoutDocumentFull } from "../word/layout/layout-full.js";
+import { renderLayoutDocumentToPdf } from "./render-layout-to-pdf.js";
 /**
- * Convert a DocxDocument to PDF bytes.
+ * Convert a `DocxDocument` to PDF bytes.
  *
- * @param doc - The DOCX document model (from readDocx or DocumentBuilder.build()).
- * @param options - PDF rendering options.
- * @returns Promise of PDF bytes.
+ * @param doc - The DOCX document model (from `readDocx` or `Document.build()`).
+ * @param options - Page geometry, fonts, optional chart renderer, …
+ * @returns PDF bytes ready to write to disk or stream over HTTP.
  */
 export async function docxToPdf(doc, options) {
-    const opts = {
-        pageWidth: options?.pageWidth ?? 612,
-        pageHeight: options?.pageHeight ?? 792,
-        marginTop: options?.marginTop ?? 72,
-        marginBottom: options?.marginBottom ?? 72,
-        marginLeft: options?.marginLeft ?? 72,
-        marginRight: options?.marginRight ?? 72,
-        defaultFont: options?.defaultFont ?? "Times-Roman",
-        defaultFontSize: options?.defaultFontSize ?? 11
-    };
-    // Use section properties if available
-    const sectProps = doc.sectionProperties;
-    if (sectProps?.pageSize && !options?.pageWidth) {
-        opts.pageWidth = twipsToPt(sectProps.pageSize.width);
-        opts.pageHeight = twipsToPt(sectProps.pageSize.height);
-        if (sectProps.pageSize.orientation === "landscape") {
-            [opts.pageWidth, opts.pageHeight] = [opts.pageHeight, opts.pageWidth];
-        }
-    }
-    if (sectProps?.margins && !options?.marginTop) {
-        opts.marginTop = twipsToPt(sectProps.margins.top);
-        opts.marginBottom = twipsToPt(sectProps.margins.bottom);
-        opts.marginLeft = twipsToPt(sectProps.margins.left);
-        opts.marginRight = twipsToPt(sectProps.margins.right);
-    }
-    const builder = new PdfDocumentBuilder();
-    if (doc.coreProperties?.title || doc.coreProperties?.creator) {
-        builder.setMetadata({
-            title: doc.coreProperties?.title,
-            author: doc.coreProperties?.creator,
-            subject: doc.coreProperties?.subject
-        });
-    }
-    const state = {
-        builder,
-        opts,
-        doc,
-        rIdToImage: buildImageMap(doc),
-        currentPage: null,
-        cursorY: 0,
-        currentPageIndex: 0
-    };
-    newPage(state);
-    for (const item of doc.body) {
-        renderBodyContent(state, item);
-    }
-    return builder.build();
-}
-function newPage(state) {
-    state.currentPage = state.builder.addPage({
-        width: state.opts.pageWidth,
-        height: state.opts.pageHeight
-    });
-    state.cursorY = state.opts.pageHeight - state.opts.marginTop;
-    state.currentPageIndex++;
-}
-function ensureSpace(state, needed) {
-    if (state.cursorY - needed < state.opts.marginBottom) {
-        newPage(state);
-    }
-}
-function renderBodyContent(state, item) {
-    if (!("type" in item)) {
-        return;
-    }
-    switch (item.type) {
-        case "paragraph":
-            renderParagraphPdf(state, item);
-            break;
-        case "table":
-            renderTablePdf(state, item);
-            break;
-        case "math":
-            renderTextAtCursor(state, "[equation]", { italic: true });
-            break;
-        case "chart":
-            renderTextAtCursor(state, `[${item.chart.type} chart]`, { italic: true });
-            break;
-        default:
-            break;
-    }
-}
-function renderParagraphPdf(state, para) {
-    const props = para.properties;
-    const spacing = props?.spacing;
-    if (spacing?.before) {
-        state.cursorY -= twipsToPt(spacing.before);
-    }
-    const text = collectText(para);
-    if (!text.trim()) {
-        state.cursorY -= state.opts.defaultFontSize * 1.2;
-        return;
-    }
-    // Determine font size and weight based on style
-    let fontSize = state.opts.defaultFontSize;
-    let bold = false;
-    const styleId = props?.style?.toLowerCase() ?? "";
-    if (styleId === "heading1" || styleId === "title") {
-        fontSize = 24;
-        bold = true;
-    }
-    else if (styleId === "heading2") {
-        fontSize = 18;
-        bold = true;
-    }
-    else if (styleId === "heading3") {
-        fontSize = 14;
-        bold = true;
-    }
-    else if (styleId === "heading4") {
-        fontSize = 12;
-        bold = true;
-    }
-    let leftIndent = 0;
-    if (props?.indent?.left !== undefined) {
-        leftIndent = twipsToPt(props.indent.left);
-    }
-    const x = state.opts.marginLeft + leftIndent;
-    const availableWidth = state.opts.pageWidth - state.opts.marginLeft - state.opts.marginRight - leftIndent;
-    const lineHeight = fontSize * 1.2;
-    const estimatedLines = Math.max(1, Math.ceil((text.length * fontSize * 0.5) / availableWidth));
-    ensureSpace(state, estimatedLines * lineHeight);
-    // Simple approach: render entire paragraph as one text block
-    state.currentPage.drawText(text, {
-        x,
-        y: state.cursorY - fontSize,
-        fontSize,
-        bold,
-        maxWidth: availableWidth,
-        lineHeight: 1.2
-    });
-    state.cursorY -= estimatedLines * lineHeight;
-    if (spacing?.after) {
-        state.cursorY -= twipsToPt(spacing.after);
-    }
-    else {
-        state.cursorY -= 6;
-    }
-}
-function collectText(para) {
-    let text = "";
-    for (const child of para.children) {
-        const run = childToRun(child);
-        if (run) {
-            text += runToText(run);
-        }
-    }
-    return text;
-}
-function childToRun(child) {
-    if ("content" in child && !("type" in child)) {
-        return child;
-    }
-    if ("type" in child) {
-        const typed = child;
-        if (typed.type === "hyperlink" && typed.children) {
-            for (const c of typed.children) {
-                if ("content" in c && !("type" in c)) {
-                    return c;
-                }
+    // 1. Resolve effective page geometry. Section properties win unless the
+    //    caller explicitly overrode an axis. Margins are independent: the
+    //    section's margins are applied unless the caller overrode them.
+    const layoutOptions = mapToLayoutOptions(doc, options);
+    // 2. Auto-detect chart support: if no explicit chartRenderer is
+    //    provided, try to import the high-quality Excel-based renderer.
+    let chartRendererForChart = options?.chartRenderer;
+    if (!chartRendererForChart) {
+        try {
+            const mod = await import("./excel-bridge.js");
+            if (typeof mod.createWordChartPdfRenderer === "function") {
+                chartRendererForChart = mod.createWordChartPdfRenderer();
             }
         }
-        else if (typed.type === "insertedRun" ||
-            typed.type === "deletedRun" ||
-            typed.type === "movedFromRun" ||
-            typed.type === "movedToRun") {
-            return typed.run;
+        catch {
+            // Chart support not available — placeholder rendering takes over.
         }
     }
-    return undefined;
-}
-function runToText(run) {
-    let text = "";
-    for (const c of run.content) {
-        switch (c.type) {
-            case "text":
-                text += c.text;
-                break;
-            case "tab":
-                text += "\t";
-                break;
-            case "break":
-            case "carriageReturn":
-                text += "\n";
-                break;
-            case "noBreakHyphen":
-                text += "\u2011";
-                break;
-            case "symbol":
-                try {
-                    text += String.fromCodePoint(parseInt(c.char, 16));
-                }
-                catch {
-                    // Invalid symbol code - skip
+    // 3. Run the layout engine. Everything from line wrapping to page
+    //    breaks happens here; word-bridge no longer carries any of that.
+    const layout = layoutDocumentFull(doc, layoutOptions);
+    // 4. Build a render-options object for the PDF translator. The
+    //    chartRenderer adaptation: layout produces `LayoutChart` (which
+    //    contains the original `ChartContent` in `source`); the public
+    //    chartRenderer API takes the inner `Chart` model. We unwrap so
+    //    existing callers keep working unchanged.
+    const renderOptions = {
+        title: doc.coreProperties?.title,
+        author: doc.coreProperties?.creator,
+        subject: doc.coreProperties?.subject,
+        defaultFont: options?.defaultFont ?? "Helvetica",
+        defaultFontSize: options?.defaultFontSize ?? 11,
+        chartRenderer: chartRendererForChart
+            ? (layoutChart, page, rect) => {
+                const src = layoutChart.source;
+                if (src && src.type === "chart") {
+                    // Forward the user's return value so a renderer that knows
+                    // how to draw classic charts but declines a particular
+                    // family (e.g. unsupported axis combination) gets the
+                    // translator's placeholder fallback.
+                    return chartRendererForChart(src.chart, page, rect);
                 }
-                break;
-            case "field":
-                if (c.cachedValue) {
-                    text += c.cachedValue;
-                }
-                break;
-        }
-    }
-    return text;
-}
-function renderTablePdf(state, table) {
-    const pageWidth = state.opts.pageWidth - state.opts.marginLeft - state.opts.marginRight;
-    const numCols = Math.max(...table.rows.map(r => r.cells.length));
-    const defaultColWidth = pageWidth / numCols;
-    const rowHeight = 20;
-    for (const row of table.rows) {
-        ensureSpace(state, rowHeight);
-        let x = state.opts.marginLeft;
-        const rowTop = state.cursorY;
-        const rowBottom = state.cursorY - rowHeight;
-        for (const cell of row.cells) {
-            const span = cell.properties?.gridSpan ?? 1;
-            const cellWidth = defaultColWidth * span;
-            state.currentPage.drawRect({
-                x,
-                y: rowBottom,
-                width: cellWidth,
-                height: rowHeight,
-                stroke: { r: 0, g: 0, b: 0 },
-                lineWidth: 0.5
-            });
-            const cellText = getCellText(cell);
-            if (cellText) {
-                state.currentPage.drawText(cellText, {
-                    x: x + 4,
-                    y: rowTop - 14,
-                    fontSize: 10,
-                    maxWidth: cellWidth - 8
-                });
+                // ChartEx (or absent source) cannot be passed to the user's
+                // `Chart`-typed callback. Decline so the translator's
+                // placeholder runs instead of leaving a blank slot.
+                return false;
             }
-            x += cellWidth;
-        }
-        state.cursorY = rowBottom;
-    }
-    state.cursorY -= 6;
+            : undefined
+    };
+    const builder = renderLayoutDocumentToPdf(layout, renderOptions);
+    return builder.build();
 }
-function getCellText(cell) {
-    let text = "";
-    for (const item of cell.content) {
-        if ("type" in item && item.type === "paragraph") {
-            text += collectText(item) + " ";
+// =============================================================================
+// Internal: option mapping
+// =============================================================================
+/**
+ * Resolve the effective page geometry from `DocxToPdfOptions`. Caller-
+ * supplied overrides win; otherwise the document's section properties
+ * provide the value (with `pageSize.orientation === "landscape"`
+ * triggering the conventional width/height swap when sectPr supplies
+ * portrait-oriented numbers); otherwise the layout engine's defaults
+ * (US Letter, 1-inch margins) take over.
+ *
+ * `headerMargin` / `footerMargin` are accepted for API compatibility
+ * with the previous flow renderer but currently have no effect on the
+ * layout-driven path: the layout engine does not yet position header /
+ * footer paragraphs against custom inset values, and forwarding the
+ * field would silently mislead callers. Pre-existing documents that
+ * rely on those parameters still get the section's `headerMargin` /
+ * `footerMargin` from sectionProperties when they exist.
+ */
+function mapToLayoutOptions(doc, options) {
+    const sectProps = doc.sectionProperties;
+    // Section page size, applying the orientation swap so a landscape
+    // sectPr written with portrait numerics still ends up wide.
+    let sectionPageWidthPt;
+    let sectionPageHeightPt;
+    if (sectProps?.pageSize) {
+        sectionPageWidthPt = twipsToPt(sectProps.pageSize.width);
+        sectionPageHeightPt = twipsToPt(sectProps.pageSize.height);
+        if (sectProps.pageSize.orientation === "landscape") {
+            [sectionPageWidthPt, sectionPageHeightPt] = [sectionPageHeightPt, sectionPageWidthPt];
         }
     }
-    return text.trim();
+    const sectionMarginTopPt = sectProps?.margins?.top != null ? twipsToPt(sectProps.margins.top) : undefined;
+    const sectionMarginBottomPt = sectProps?.margins?.bottom != null ? twipsToPt(sectProps.margins.bottom) : undefined;
+    const sectionMarginLeftPt = sectProps?.margins?.left != null ? twipsToPt(sectProps.margins.left) : undefined;
+    const sectionMarginRightPt = sectProps?.margins?.right != null ? twipsToPt(sectProps.margins.right) : undefined;
+    const pageGeometry = {
+        pageWidth: options?.pageWidth ?? sectionPageWidthPt,
+        pageHeight: options?.pageHeight ?? sectionPageHeightPt,
+        marginTop: options?.marginTop ?? sectionMarginTopPt,
+        marginBottom: options?.marginBottom ?? sectionMarginBottomPt,
+        marginLeft: options?.marginLeft ?? sectionMarginLeftPt,
+        marginRight: options?.marginRight ?? sectionMarginRightPt
+    };
+    const layoutOpts = {};
+    // Only attach pageGeometry when at least one axis is actually
+    // overridden; otherwise the layout engine should apply its
+    // section-property fallbacks unchanged.
+    if (Object.values(pageGeometry).some(v => v !== undefined)) {
+        layoutOpts.pageGeometry = pageGeometry;
+    }
+    return layoutOpts;
 }
 function twipsToPt(twips) {
     return twips / 20;
 }
-function renderTextAtCursor(state, text, opts) {
-    const fontSize = opts?.fontSize ?? state.opts.defaultFontSize;
-    ensureSpace(state, fontSize * 1.2);
-    state.currentPage.drawText(text, {
-        x: state.opts.marginLeft,
-        y: state.cursorY - fontSize,
-        fontSize,
-        bold: opts?.bold,
-        italic: opts?.italic
-    });
-    state.cursorY -= fontSize * 1.2;
-}
-function buildImageMap(doc) {
-    const map = new Map();
-    if (doc.images) {
-        for (const img of doc.images) {
-            if (img.rId) {
-                map.set(img.rId, img);
-            }
-        }
-    }
-    return map;
-}

package/dist/esm/modules/stream/index.base.js

@@ -9,7 +9,8 @@ export { isDestroyed, isErrored, getDefaultHighWaterMark, setDefaultHighWaterMar
 export { ChunkedBuilder, TransactionalChunkedBuilder } from "./chunked-builder.js";
 export { collect, text, json, bytes, fromString, fromJSON, fromBytes, transform, filter, isReadableStreamLike, readableStreamToAsyncIterable } from "./utils.js";
 export { StreamStateError, StreamTypeError, UnsupportedStreamTypeError } from "./errors.js";
-// Internal utilities exposed for cross-module use (e.g. archive)
+// Internal utilities exposed for cross-module use (e.g. archive, word/excel writers)
 export { isReadableStream, isWritableStream, isAsyncIterable, isTransformStream } from "./internal/type-guards.js";
 export { onceEvent } from "./internal/event-utils.js";
 export { eventedReadableToAsyncIterableNoDestroy } from "./internal/evented-readable-to-async-iterable.js";
+export { SinkAdapter } from "./internal/sink-adapter.js";

package/dist/esm/modules/stream/internal/sink-adapter.js

@@ -0,0 +1,198 @@
+/**
+ * SinkAdapter — unified writable-sink view.
+ *
+ * Producers (zip writers, docx streamers, etc.) generate `Uint8Array`
+ * chunks and want to push them through a user-supplied destination
+ * without caring whether that destination is a Web `WritableStream`,
+ * a Node `Writable`, or some duck-typed object.
+ *
+ * `SinkAdapter` collapses all three into one promise-based API:
+ *   - `write(chunk)` resolves once the chunk has been accepted by the
+ *     sink (after awaiting `drain` for Node-style sinks under
+ *     backpressure, or `writer.ready` for Web streams).
+ *   - `end()` finalises the sink and resolves on close.
+ *   - The first sink error is captured and re-thrown from the next
+ *     `write` / `end` so callers can't lose it.
+ *
+ * Producers are expected to either:
+ *   - drive `await sink.write(chunk)` directly (preferred — gives
+ *     true end-to-end backpressure), or
+ *   - chain writes onto a single shared promise so a synchronous
+ *     emit callback can still feed the adapter without blocking.
+ */
+import { onceEvent } from "./event-utils.js";
+function isWebWritable(s) {
+    return (typeof s === "object" &&
+        s !== null &&
+        typeof s.getWriter === "function");
+}
+function isNodeWritable(s) {
+    return (typeof s === "object" &&
+        s !== null &&
+        typeof s.write === "function" &&
+        typeof s.end === "function" &&
+        (typeof s.once === "function" ||
+            typeof s.on === "function"));
+}
+/** Unified sink view with awaited write + error capture. */
+export class SinkAdapter {
+    constructor(sink) {
+        this._error = null;
+        this._ended = false;
+        if (isWebWritable(sink)) {
+            this._kind = "web";
+            this._webWriter = sink.getWriter();
+            // Web writers expose .closed; surface termination errors through
+            // the same _error channel so producers see them.
+            this._webWriter.closed.catch((err) => {
+                this._captureError(err);
+            });
+        }
+        else if (isNodeWritable(sink)) {
+            this._kind = "node";
+            this._nodeSink = sink;
+            this._attachErrorListener(sink);
+        }
+        else {
+            this._kind = "duck";
+            this._duckSink = sink;
+            this._attachErrorListener(sink);
+        }
+    }
+    /**
+     * The first error reported by the sink (or `null`). Producers that
+     * cannot await `write()` (synchronous emit callbacks) should poll
+     * this between operations.
+     */
+    get error() {
+        return this._error;
+    }
+    async write(chunk) {
+        this._throwIfErrored();
+        if (this._ended) {
+            throw new Error("SinkAdapter: write after end");
+        }
+        if (chunk.length === 0) {
+            return;
+        }
+        if (this._kind === "web") {
+            const w = this._webWriter;
+            // `ready` resolves once the internal queue has drained below the
+            // high-water mark; awaiting it gives backpressure for free.
+            await w.ready;
+            await w.write(chunk);
+            return;
+        }
+        if (this._kind === "node") {
+            const sink = this._nodeSink;
+            const ok = sink.write(chunk);
+            if (!ok) {
+                await onceEvent(sink, "drain");
+                this._throwIfErrored();
+            }
+            return;
+        }
+        // duck
+        const sink = this._duckSink;
+        const result = sink.write(chunk);
+        if (result instanceof Promise) {
+            await result;
+        }
+        else if (!result) {
+            await onceEvent(sink, "drain");
+            this._throwIfErrored();
+        }
+    }
+    async end() {
+        if (this._ended) {
+            return;
+        }
+        this._ended = true;
+        this._throwIfErrored();
+        if (this._kind === "web") {
+            // close() rejects if the stream has already errored — we let that
+            // propagate so callers see the underlying failure.
+            await this._webWriter.close();
+            return;
+        }
+        if (this._kind === "node") {
+            const sink = this._nodeSink;
+            // Prefer the close event when available; some Node writables emit
+            // 'finish' first and only emit 'close' on `destroy()`. We listen
+            // for both.
+            const finished = onceEventAny(sink, ["close", "finish"]);
+            sink.end();
+            await finished;
+            this._throwIfErrored();
+            return;
+        }
+        // duck
+        const sink = this._duckSink;
+        const finished = onceEventAny(sink, ["close", "finish"]);
+        sink.end();
+        await finished;
+        this._throwIfErrored();
+    }
+    _captureError(err) {
+        if (this._error) {
+            return;
+        }
+        this._error = err instanceof Error ? err : new Error(String(err));
+    }
+    _throwIfErrored() {
+        if (this._error) {
+            throw this._error;
+        }
+    }
+    _attachErrorListener(sink) {
+        if (typeof sink.on === "function") {
+            sink.on("error", (err) => {
+                this._captureError(err);
+            });
+        }
+        else if (typeof sink.once === "function") {
+            // Best-effort: a once listener is enough to capture the first error.
+            sink.once("error", (err) => {
+                this._captureError(err);
+            });
+        }
+    }
+}
+/** Resolve on the first of `events` (or reject on `error`). */
+function onceEventAny(emitter, events) {
+    return new Promise((resolve, reject) => {
+        const cleanup = () => {
+            const off = (e, l) => {
+                if (typeof emitter.off === "function") {
+                    emitter.off(e, l);
+                }
+                else if (typeof emitter.removeListener === "function") {
+                    emitter.removeListener(e, l);
+                }
+            };
+            off("error", onError);
+            for (const e of events) {
+                off(e, onDone);
+            }
+        };
+        const onError = (err) => {
+            cleanup();
+            reject(err instanceof Error ? err : new Error(String(err)));
+        };
+        const onDone = () => {
+            cleanup();
+            resolve();
+        };
+        if (typeof emitter.once === "function") {
+            emitter.once("error", onError);
+            for (const e of events) {
+                emitter.once(e, onDone);
+            }
+            return;
+        }
+        emitter.on?.("error", onError);
+        for (const e of events) {
+            emitter.on?.(e, onDone);
+        }
+    });
+}