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

package/dist/esm/modules/excel/stream/sheet-rels-writer.js

@@ -1,91 +0,0 @@
-import { xmlEncode } from "@utils/utils";
-import { RelType } from "@excel/xlsx/rel-type";
-import { worksheetRelsPath } from "@excel/utils/ooxml-paths";
-class HyperlinksProxy {
-    constructor(sheetRelsWriter) {
-        this.writer = sheetRelsWriter;
-    }
-    push(hyperlink) {
-        this.writer.addHyperlink(hyperlink);
-    }
-}
-class SheetRelsWriter {
-    constructor(options) {
-        // in a workbook, each sheet will have a number
-        this.id = options.id;
-        // count of all relationships
-        this.count = 0;
-        // keep record of all hyperlinks
-        this._hyperlinks = [];
-        this._workbook = options.workbook;
-    }
-    get stream() {
-        if (!this._stream) {
-            this._stream = this._workbook._openStream(worksheetRelsPath(this.id));
-        }
-        return this._stream;
-    }
-    get length() {
-        return this._hyperlinks.length;
-    }
-    each(fn) {
-        return this._hyperlinks.forEach(fn);
-    }
-    get hyperlinksProxy() {
-        return this._hyperlinksProxy || (this._hyperlinksProxy = new HyperlinksProxy(this));
-    }
-    addHyperlink(hyperlink) {
-        // Write to stream
-        const relationship = {
-            Target: hyperlink.target,
-            Type: RelType.Hyperlink,
-            TargetMode: "External"
-        };
-        const rId = this._writeRelationship(relationship);
-        // store sheet stuff for later
-        this._hyperlinks.push({
-            rId,
-            address: hyperlink.address
-        });
-    }
-    addMedia(media) {
-        return this._writeRelationship(media);
-    }
-    addRelationship(rel) {
-        return this._writeRelationship(rel);
-    }
-    commit() {
-        if (this.count) {
-            // write xml utro
-            this._writeClose();
-            // and close stream
-            this.stream.end();
-        }
-    }
-    // ================================================================================
-    _writeOpen() {
-        this.stream.write(`<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
-       <Relationships xmlns="http://schemas.openxmlformats.org/package/2006/relationships">`);
-    }
-    _writeRelationship(relationship) {
-        if (!this.count) {
-            this._writeOpen();
-        }
-        const rId = `rId${++this.count}`;
-        if (relationship.TargetMode) {
-            this.stream.write(`<Relationship Id="${rId}"` +
-                ` Type="${relationship.Type}"` +
-                ` Target="${xmlEncode(relationship.Target)}"` +
-                ` TargetMode="${relationship.TargetMode}"` +
-                "/>");
-        }
-        else {
-            this.stream.write(`<Relationship Id="${rId}" Type="${relationship.Type}" Target="${relationship.Target}"/>`);
-        }
-        return rId;
-    }
-    _writeClose() {
-        this.stream.write("</Relationships>");
-    }
-}
-export { SheetRelsWriter };

package/dist/esm/modules/excel/stream/workbook-reader.browser.js

@@ -1,443 +0,0 @@
-/**
- * WorkbookReader - Browser Streaming Workbook Reader
- *
- * This module contains the full shared implementation for the streaming
- * workbook reader and a browser-compatible `WorkbookReader` that buffers
- * waiting worksheets in memory.
- *
- * Node.js uses `workbook-reader.ts`, which extends the same base implementation
- * with filesystem-specific features (filename input + temp-file buffering).
- */
-import { EventEmitter, Readable } from "@stream";
-import { createParse } from "@archive/parse";
-import { iterateStream } from "@excel/utils/iterate-stream";
-import { getWorksheetNoFromWorksheetPath, getWorksheetNoFromWorksheetRelsPath, normalizeZipPath, OOXML_PATHS, worksheetRelTarget } from "@excel/utils/ooxml-paths";
-import { parseSax } from "@excel/utils/parse-sax";
-import { StylesXform } from "@excel/xlsx/xform/style/styles-xform";
-import { WorkbookXform } from "@excel/xlsx/xform/book/workbook-xform";
-import { RelationshipsXform } from "@excel/xlsx/xform/core/relationships-xform";
-import { WorksheetReader } from "@excel/stream/worksheet-reader";
-import { HyperlinkReader } from "@excel/stream/hyperlink-reader";
-// ============================================================================
-// Base Class
-// ============================================================================
-export class WorkbookReaderBase extends EventEmitter {
-    getHyperlinkReader(sheetNo) {
-        return this._hyperlinkReadersBySheetNo?.[String(sheetNo)];
-    }
-    getHyperlink(sheetNo, rId) {
-        return this.getHyperlinkReader(sheetNo)?.hyperlinks?.[rId];
-    }
-    getHyperlinkTarget(sheetNo, rId) {
-        return this.getHyperlink(sheetNo, rId)?.target;
-    }
-    constructor(input, options, WorksheetReaderClass, HyperlinkReaderClass) {
-        super();
-        this.input = input;
-        this.WorksheetReaderClass = WorksheetReaderClass;
-        this.HyperlinkReaderClass = HyperlinkReaderClass;
-        this.options = {
-            worksheets: "emit",
-            sharedStrings: "cache",
-            hyperlinks: "ignore",
-            styles: "ignore",
-            entries: "ignore",
-            ...options
-        };
-        this.styles = new StylesXform();
-        this.styles.init();
-    }
-    // Default implementation for CommonInput types
-    _getStream(input) {
-        if (input instanceof Readable) {
-            return input;
-        }
-        // Accept Web ReadableStream (browser fetch() body, Node 18+ fetch(), etc.)
-        if (input &&
-            typeof input === "object" &&
-            typeof input.getReader === "function") {
-            const fromWeb = Readable.fromWeb;
-            if (typeof fromWeb === "function") {
-                return fromWeb(input);
-            }
-            // Browser wrapper supports `{ stream }` constructor option.
-            // Node's Readable does not, so this is best-effort.
-            try {
-                return new Readable({
-                    stream: input
-                });
-            }
-            catch {
-                throw new Error("Could not recognise input: ReadableStream");
-            }
-        }
-        let data = input;
-        if (data instanceof ArrayBuffer) {
-            data = new Uint8Array(data);
-        }
-        if (data instanceof Uint8Array) {
-            // Cross-platform: both Node's Readable and our browser Readable implement `.from()`.
-            return Readable.from([data]);
-        }
-        throw new Error(`Could not recognise input: ${input}`);
-    }
-    _cleanupWaitingWorksheets(_waitingWorksheets) {
-        // Default: attempt best-effort cleanup if the stored object provides it.
-        for (const ws of _waitingWorksheets) {
-            if (ws && typeof ws.cleanup === "function") {
-                ws.cleanup();
-            }
-        }
-    }
-    // Unified implementations using passed-in classes
-    _createWorksheetReader(params) {
-        return new this.WorksheetReaderClass({
-            workbook: this,
-            id: params.id,
-            iterator: params.iterator,
-            options: params.options
-        });
-    }
-    _createHyperlinkReader(params) {
-        return new this.HyperlinkReaderClass({
-            workbook: this,
-            id: params.id,
-            iterator: params.iterator,
-            options: params.options
-        });
-    }
-    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) {
-            this.options = options;
-        }
-        const stream = (this.stream = this._getStream(input || this.input));
-        const waitingWorksheets = [];
-        try {
-            for await (const event of this._parseEntries(stream)) {
-                if (event.eventType === "waiting-worksheet") {
-                    const stored = await this._storeWaitingWorksheet(event.sheetNo, event.entry);
-                    waitingWorksheets.push(stored);
-                }
-                else {
-                    yield event;
-                }
-            }
-            yield* this._processWaitingWorksheets(waitingWorksheets);
-        }
-        catch (error) {
-            this._cleanupWaitingWorksheets(waitingWorksheets);
-            throw error;
-        }
-    }
-    _emitEntry(payload) {
-        if (this.options.entries === "emit") {
-            this.emit("entry", payload);
-        }
-    }
-    async _parseRels(entry) {
-        const xform = new RelationshipsXform();
-        this.workbookRels = await xform.parseStream(iterateStream(entry));
-        // Build fast lookup for worksheet relationship ids.
-        this._workbookRelIdByTarget = Object.create(null);
-        for (const rel of this.workbookRels || []) {
-            if (rel?.Target && rel?.Id) {
-                this._workbookRelIdByTarget[rel.Target] = rel.Id;
-            }
-        }
-    }
-    async _parseWorkbook(entry) {
-        this._emitEntry({ type: "workbook" });
-        const workbook = new WorkbookXform();
-        this.model = await workbook.parseStream(iterateStream(entry));
-        this.properties = workbook.map?.workbookPr;
-        // Build fast lookup for sheet metadata by relationship id.
-        this._sheetByRelId = Object.create(null);
-        for (const sheet of this.model?.sheets || []) {
-            this._sheetByRelId[sheet.rId] = sheet;
-        }
-    }
-    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 parseSax(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 StylesXform();
-            await this.styles.parseStream(iterateStream(entry));
-        }
-    }
-    *_parseWorksheet(iterator, sheetNo) {
-        this._emitEntry({ type: "worksheet", id: sheetNo });
-        const sheetNoNumber = parseInt(sheetNo, 10);
-        const worksheetReader = this._createWorksheetReader({
-            id: sheetNoNumber,
-            iterator,
-            options: this.options
-        });
-        // Preserve original sheet index from the zip path. `worksheetReader.id` may be remapped
-        // later using workbook metadata.
-        worksheetReader.sheetNo = sheetNoNumber;
-        const relId = this._workbookRelIdByTarget?.[worksheetRelTarget(sheetNo)];
-        const matchingSheet = relId ? this._sheetByRelId?.[relId] : undefined;
-        if (matchingSheet) {
-            worksheetReader.id = matchingSheet.id;
-            worksheetReader.name = matchingSheet.name;
-            worksheetReader.state = matchingSheet.state;
-        }
-        if (this.options.worksheets === "emit") {
-            yield { eventType: "worksheet", value: worksheetReader };
-        }
-    }
-    async *_parseHyperlinks(iterator, sheetNo) {
-        this._emitEntry({ type: "hyperlinks", id: sheetNo });
-        const hyperlinksReader = this._createHyperlinkReader({
-            id: parseInt(sheetNo, 10),
-            iterator,
-            options: this.options
-        });
-        if (this.options.hyperlinks === "cache") {
-            if (!this._hyperlinkReadersBySheetNo) {
-                this._hyperlinkReadersBySheetNo = Object.create(null);
-            }
-            this._hyperlinkReadersBySheetNo[sheetNo] = hyperlinksReader;
-            const readFn = hyperlinksReader.read;
-            if (typeof readFn === "function") {
-                await readFn.call(hyperlinksReader);
-            }
-            return;
-        }
-        if (this.options.hyperlinks === "emit") {
-            yield { eventType: "hyperlinks", value: hyperlinksReader };
-        }
-    }
-    async *_parseEntries(stream) {
-        const zip = createParse({ forceStream: true });
-        stream.on("error", (err) => zip.emit("error", err));
-        stream.pipe(zip);
-        for await (const entry of iterateStream(zip)) {
-            let sheetNo;
-            const normalizedPath = normalizeZipPath(entry.path);
-            switch (normalizedPath) {
-                case OOXML_PATHS.rootRels:
-                    break;
-                case OOXML_PATHS.xlWorkbookRels:
-                    await this._parseRels(entry);
-                    break;
-                case OOXML_PATHS.xlWorkbook:
-                    await this._parseWorkbook(entry);
-                    break;
-                case OOXML_PATHS.xlSharedStrings:
-                    for await (const item of this._parseSharedStrings(entry)) {
-                        yield { eventType: "shared-strings", value: item };
-                    }
-                    break;
-                case OOXML_PATHS.xlStyles:
-                    await this._parseStyles(entry);
-                    break;
-                default:
-                    sheetNo = getWorksheetNoFromWorksheetPath(normalizedPath)?.toString();
-                    if (sheetNo) {
-                        // Performance: only wait for sharedStrings when they are actually needed.
-                        const hasPrerequisites = !!this.workbookRels &&
-                            (this.options.sharedStrings !== "cache" || !!this.sharedStrings);
-                        if (hasPrerequisites) {
-                            yield* this._parseWorksheet(iterateStream(entry), sheetNo);
-                            continue;
-                        }
-                        else {
-                            yield { eventType: "waiting-worksheet", sheetNo, entry };
-                            continue;
-                        }
-                    }
-                    sheetNo = getWorksheetNoFromWorksheetRelsPath(normalizedPath)?.toString();
-                    if (sheetNo) {
-                        yield* this._parseHyperlinks(iterateStream(entry), sheetNo);
-                        continue;
-                    }
-                    break;
-            }
-            entry.autodrain();
-        }
-    }
-}
-export const WorkbookReaderOptionsSchema = {
-    worksheets: ["emit", "ignore"],
-    sharedStrings: ["cache", "emit", "ignore"],
-    hyperlinks: ["cache", "emit", "ignore"],
-    styles: ["cache", "ignore"],
-    entries: ["emit", "ignore"]
-};
-class WorkbookReader extends WorkbookReaderBase {
-    constructor(input, options = {}) {
-        super(input, options, WorksheetReader, HyperlinkReader);
-    }
-    async _storeWaitingWorksheet(sheetNo, entry) {
-        const chunks = [];
-        const encoder = new TextEncoder();
-        for await (const chunk of iterateStream(entry)) {
-            if (chunk instanceof Uint8Array) {
-                chunks.push(chunk);
-            }
-            else if (typeof chunk === "string") {
-                chunks.push(encoder.encode(chunk));
-            }
-        }
-        return { sheetNo, data: chunks };
-    }
-    async *_processWaitingWorksheets(waitingWorksheets) {
-        for (const ws of waitingWorksheets) {
-            const iterator = (async function* () {
-                for (const chunk of ws.data) {
-                    yield chunk;
-                }
-            })();
-            yield* this._parseWorksheet(iterator, ws.sheetNo);
-        }
-    }
-}
-export { WorkbookReader };

package/dist/esm/modules/excel/stream/workbook-reader.js

@@ -1,50 +0,0 @@
-/**
- * WorkbookReader - Node.js Streaming Workbook Reader
- *
- * Extends base with file path support and temp file storage for large files.
- */
-import fs from "fs";
-import os from "os";
-import { join } from "path";
-import { iterateStream } from "@excel/utils/iterate-stream";
-import { WorksheetReader } from "@excel/stream/worksheet-reader";
-import { HyperlinkReader } from "@excel/stream/hyperlink-reader";
-import { WorkbookReaderBase, WorkbookReaderOptionsSchema } from "@excel/stream/workbook-reader.browser";
-class WorkbookReader extends WorkbookReaderBase {
-    constructor(input, options = {}) {
-        super(input, options, WorksheetReader, HyperlinkReader);
-        this.input = input;
-    }
-    _getStream(input) {
-        if (typeof input === "string") {
-            return fs.createReadStream(input);
-        }
-        return super._getStream(input);
-    }
-    async _storeWaitingWorksheet(sheetNo, entry) {
-        const tmpDir = fs.mkdtempSync(join(os.tmpdir(), "excelts-"));
-        const path = join(tmpDir, `sheet${sheetNo}.xml`);
-        const cleanup = () => fs.rm(tmpDir, { recursive: true, force: true }, () => { });
-        const writePromise = new Promise((resolve, reject) => {
-            const tempStream = fs.createWriteStream(path);
-            tempStream.on("error", reject);
-            tempStream.on("finish", resolve);
-            entry.pipe(tempStream);
-        });
-        return { sheetNo, path, cleanup, writePromise };
-    }
-    async *_processWaitingWorksheets(waitingWorksheets) {
-        for (const ws of waitingWorksheets) {
-            await ws.writePromise;
-            const fileStream = fs.createReadStream(ws.path);
-            try {
-                yield* this._parseWorksheet(iterateStream(fileStream), ws.sheetNo);
-            }
-            finally {
-                fileStream.close();
-                ws.cleanup();
-            }
-        }
-    }
-}
-export { WorkbookReader, WorkbookReaderOptionsSchema };