@cj-tech-master/excelts 3.1.0-canary.20260102041828.82ed571 → 3.1.0

package/dist/cjs/stream/xlsx/workbook-reader.js

@@ -0,0 +1,359 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WorkbookReaderOptions = exports.WorkbookReader = void 0;
+const fs_1 = __importDefault(require("fs"));
+const events_1 = require("events");
+const stream_1 = require("stream");
+const os_1 = __importDefault(require("os"));
+const path_1 = require("path");
+const iterate_stream_1 = require("../../utils/iterate-stream");
+const parse_sax_1 = require("../../utils/parse-sax");
+const styles_xform_1 = require("../../xlsx/xform/style/styles-xform");
+const workbook_xform_1 = require("../../xlsx/xform/book/workbook-xform");
+const relationships_xform_1 = require("../../xlsx/xform/core/relationships-xform");
+const worksheet_reader_1 = require("./worksheet-reader");
+const hyperlink_reader_1 = require("./hyperlink-reader");
+const parse_1 = require("../../utils/unzip/parse");
+class WorkbookReader extends events_1.EventEmitter {
+    constructor(input, options = {}) {
+        super();
+        this.input = input;
+        this.options = {
+            worksheets: "emit",
+            sharedStrings: "cache",
+            hyperlinks: "ignore",
+            styles: "ignore",
+            entries: "ignore",
+            ...options
+        };
+        this.styles = new styles_xform_1.StylesXform();
+        this.styles.init();
+    }
+    _getStream(input) {
+        if (input instanceof stream_1.Readable) {
+            return input;
+        }
+        if (typeof input === "string") {
+            return fs_1.default.createReadStream(input);
+        }
+        throw new Error(`Could not recognise input: ${input}`);
+    }
+    async read(input, options) {
+        try {
+            for await (const { eventType, value } of this.parse(input, options)) {
+                switch (eventType) {
+                    case "shared-strings":
+                        this.emit(eventType, value);
+                        break;
+                    case "worksheet":
+                        this.emit(eventType, value);
+                        await value.read();
+                        break;
+                    case "hyperlinks":
+                        this.emit(eventType, value);
+                        break;
+                }
+            }
+            this.emit("end");
+            this.emit("finished");
+        }
+        catch (error) {
+            this.emit("error", error);
+        }
+    }
+    async *[Symbol.asyncIterator]() {
+        for await (const { eventType, value } of this.parse()) {
+            if (eventType === "worksheet") {
+                yield value;
+            }
+        }
+    }
+    async *parse(input, options) {
+        if (options) {
+            // Note: This replaces all options, not merging with constructor defaults.
+            // This is intentional for backwards compatibility - passing partial options
+            // to parse() will leave unspecified options as undefined.
+            this.options = options;
+        }
+        const stream = (this.stream = this._getStream(input || this.input));
+        const zip = (0, parse_1.createParse)({ forceStream: true });
+        // Handle pipe errors to prevent unhandled rejection
+        stream.on("error", (err) => {
+            zip.emit("error", err);
+        });
+        stream.pipe(zip);
+        // worksheets, deferred for parsing after shared strings reading
+        const waitingWorkSheets = [];
+        try {
+            for await (const entry of (0, iterate_stream_1.iterateStream)(zip)) {
+                let match;
+                let sheetNo;
+                // Normalize path: remove leading slash if present
+                const normalizedPath = entry.path.startsWith("/") ? entry.path.slice(1) : entry.path;
+                switch (normalizedPath) {
+                    case "_rels/.rels":
+                        break;
+                    case "xl/_rels/workbook.xml.rels":
+                        await this._parseRels(entry);
+                        break;
+                    case "xl/workbook.xml":
+                        await this._parseWorkbook(entry);
+                        break;
+                    case "xl/sharedStrings.xml":
+                        for await (const item of this._parseSharedStrings(entry)) {
+                            yield { eventType: "shared-strings", value: item };
+                        }
+                        break;
+                    case "xl/styles.xml":
+                        await this._parseStyles(entry);
+                        break;
+                    default:
+                        if (normalizedPath.match(/xl\/worksheets\/sheet\d+[.]xml/)) {
+                            match = normalizedPath.match(/xl\/worksheets\/sheet(\d+)[.]xml/);
+                            sheetNo = match[1];
+                            if (this.sharedStrings && this.workbookRels) {
+                                yield* this._parseWorksheet((0, iterate_stream_1.iterateStream)(entry), sheetNo);
+                            }
+                            else {
+                                // Worksheet arrives before sharedStrings - write to temp file asynchronously
+                                const tmpDir = fs_1.default.mkdtempSync((0, path_1.join)(os_1.default.tmpdir(), "excelts-"));
+                                const path = (0, path_1.join)(tmpDir, `sheet${sheetNo}.xml`);
+                                const tempFileCleanupCallback = () => {
+                                    fs_1.default.rm(tmpDir, { recursive: true, force: true }, () => { });
+                                };
+                                const writePromise = new Promise((resolve, reject) => {
+                                    const tempStream = fs_1.default.createWriteStream(path);
+                                    tempStream.on("error", reject);
+                                    tempStream.on("finish", resolve);
+                                    entry.pipe(tempStream);
+                                });
+                                waitingWorkSheets.push({ sheetNo, path, tempFileCleanupCallback, writePromise });
+                                continue; // Skip autodrain for piped entries
+                            }
+                        }
+                        else if (normalizedPath.match(/xl\/worksheets\/_rels\/sheet\d+[.]xml.rels/)) {
+                            match = normalizedPath.match(/xl\/worksheets\/_rels\/sheet(\d+)[.]xml.rels/);
+                            sheetNo = match[1];
+                            yield* this._parseHyperlinks((0, iterate_stream_1.iterateStream)(entry), sheetNo);
+                        }
+                        break;
+                }
+                entry.autodrain();
+            }
+            for (const worksheet of waitingWorkSheets) {
+                await worksheet.writePromise;
+                let fileStream = fs_1.default.createReadStream(worksheet.path);
+                try {
+                    // TODO: Remove once node v8 is deprecated
+                    // Detect and upgrade old fileStreams
+                    if (!fileStream[Symbol.asyncIterator]) {
+                        fileStream = fileStream.pipe(new stream_1.PassThrough());
+                    }
+                    yield* this._parseWorksheet(fileStream, worksheet.sheetNo);
+                }
+                finally {
+                    // Ensure stream is closed before cleanup
+                    if (fileStream.close) {
+                        fileStream.close();
+                    }
+                    worksheet.tempFileCleanupCallback();
+                }
+            }
+        }
+        catch (error) {
+            // Clean up any remaining temp files on error
+            for (const { tempFileCleanupCallback } of waitingWorkSheets) {
+                tempFileCleanupCallback();
+            }
+            throw error;
+        }
+    }
+    _emitEntry(payload) {
+        if (this.options.entries === "emit") {
+            this.emit("entry", payload);
+        }
+    }
+    async _parseRels(entry) {
+        const xform = new relationships_xform_1.RelationshipsXform();
+        this.workbookRels = await xform.parseStream((0, iterate_stream_1.iterateStream)(entry));
+    }
+    async _parseWorkbook(entry) {
+        this._emitEntry({ type: "workbook" });
+        const workbook = new workbook_xform_1.WorkbookXform();
+        this.model = await workbook.parseStream((0, iterate_stream_1.iterateStream)(entry));
+        this.properties = workbook.map.workbookPr;
+    }
+    async *_parseSharedStrings(entry) {
+        this._emitEntry({ type: "shared-strings" });
+        switch (this.options.sharedStrings) {
+            case "cache":
+                this.sharedStrings = [];
+                break;
+            case "emit":
+                break;
+            default:
+                return;
+        }
+        let text = null;
+        let richText = [];
+        let index = 0;
+        let font = null;
+        let inRichText = false;
+        for await (const events of (0, parse_sax_1.parseSax)((0, iterate_stream_1.iterateStream)(entry))) {
+            for (const { eventType, value } of events) {
+                if (eventType === "opentag") {
+                    const node = value;
+                    switch (node.name) {
+                        case "b":
+                            font = font || {};
+                            font.bold = true;
+                            break;
+                        case "charset":
+                            font = font || {};
+                            font.charset = parseInt(node.attributes.charset, 10);
+                            break;
+                        case "color":
+                            font = font || {};
+                            font.color = {};
+                            if (node.attributes.rgb) {
+                                font.color.argb = node.attributes.rgb;
+                            }
+                            if (node.attributes.val) {
+                                font.color.argb = node.attributes.val;
+                            }
+                            if (node.attributes.theme) {
+                                font.color.theme = node.attributes.theme;
+                            }
+                            break;
+                        case "family":
+                            font = font || {};
+                            font.family = parseInt(node.attributes.val, 10);
+                            break;
+                        case "i":
+                            font = font || {};
+                            font.italic = true;
+                            break;
+                        case "outline":
+                            font = font || {};
+                            font.outline = true;
+                            break;
+                        case "rFont":
+                            font = font || {};
+                            font.name = node.attributes.val;
+                            break;
+                        case "r":
+                            inRichText = true;
+                            break;
+                        case "si":
+                            font = null;
+                            richText = [];
+                            text = null;
+                            inRichText = false;
+                            break;
+                        case "sz":
+                            font = font || {};
+                            font.size = parseInt(node.attributes.val, 10);
+                            break;
+                        case "strike":
+                            font = font || {};
+                            font.strike = true;
+                            break;
+                        case "t":
+                            text = null;
+                            break;
+                        case "u":
+                            font = font || {};
+                            font.underline = true;
+                            break;
+                        case "vertAlign":
+                            font = font || {};
+                            font.vertAlign = node.attributes.val;
+                            break;
+                    }
+                }
+                else if (eventType === "text") {
+                    text = text ? text + value : value;
+                }
+                else if (eventType === "closetag") {
+                    const node = value;
+                    switch (node.name) {
+                        case "r":
+                            if (inRichText) {
+                                richText.push({
+                                    font,
+                                    text
+                                });
+                                font = null;
+                                text = null;
+                            }
+                            break;
+                        case "si":
+                            if (this.options.sharedStrings === "cache") {
+                                this.sharedStrings.push(richText.length ? { richText } : text || "");
+                            }
+                            else if (this.options.sharedStrings === "emit") {
+                                yield { index: index++, text: richText.length ? { richText } : text || "" };
+                            }
+                            richText = [];
+                            font = null;
+                            text = null;
+                            inRichText = false;
+                            break;
+                    }
+                }
+            }
+        }
+    }
+    async _parseStyles(entry) {
+        this._emitEntry({ type: "styles" });
+        if (this.options.styles === "cache") {
+            this.styles = new styles_xform_1.StylesXform();
+            await this.styles.parseStream((0, iterate_stream_1.iterateStream)(entry));
+        }
+    }
+    *_parseWorksheet(iterator, sheetNo) {
+        this._emitEntry({ type: "worksheet", id: sheetNo });
+        const worksheetReader = new worksheet_reader_1.WorksheetReader({
+            workbook: this,
+            id: parseInt(sheetNo, 10),
+            iterator: iterator,
+            options: this.options
+        });
+        const matchingRel = (this.workbookRels || []).find(rel => rel.Target === `worksheets/sheet${sheetNo}.xml`);
+        const matchingSheet = matchingRel &&
+            this.model &&
+            (this.model.sheets || []).find(sheet => sheet.rId === matchingRel.Id);
+        if (matchingSheet) {
+            worksheetReader.id = matchingSheet.id;
+            worksheetReader.name = matchingSheet.name;
+            worksheetReader.state = matchingSheet.state;
+        }
+        if (this.options.worksheets === "emit") {
+            yield { eventType: "worksheet", value: worksheetReader };
+        }
+    }
+    *_parseHyperlinks(iterator, sheetNo) {
+        this._emitEntry({ type: "hyperlinks", id: sheetNo });
+        const hyperlinksReader = new hyperlink_reader_1.HyperlinkReader({
+            workbook: this,
+            id: parseInt(sheetNo, 10),
+            iterator: iterator,
+            options: this.options
+        });
+        if (this.options.hyperlinks === "emit") {
+            yield { eventType: "hyperlinks", value: hyperlinksReader };
+        }
+    }
+}
+exports.WorkbookReader = WorkbookReader;
+const WorkbookReaderOptions = {
+    worksheets: ["emit", "ignore"],
+    sharedStrings: ["cache", "emit", "ignore"],
+    hyperlinks: ["cache", "emit", "ignore"],
+    styles: ["cache", "ignore"],
+    entries: ["emit", "ignore"]
+};
+exports.WorkbookReaderOptions = WorkbookReaderOptions;