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

package/dist/esm/local.js

@@ -1 +0,0 @@
-console.log(123);

package/dist/esm/stream/xlsx/hyperlink-reader.js

@@ -1,79 +0,0 @@
-import { EventEmitter } from "events";
-import { parseSax } from "../../utils/parse-sax.js";
-import { Enums } from "../../doc/enums.js";
-import { RelType } from "../../xlsx/rel-type.js";
-class HyperlinkReader extends EventEmitter {
-    constructor({ workbook, id, iterator, options }) {
-        super();
-        this.workbook = workbook;
-        this.id = id;
-        this.iterator = iterator;
-        this.options = options;
-    }
-    get count() {
-        return (this.hyperlinks && Object.keys(this.hyperlinks).length) || 0;
-    }
-    each(fn) {
-        if (this.hyperlinks) {
-            Object.keys(this.hyperlinks).forEach(rId => {
-                fn(this.hyperlinks[rId], rId);
-            });
-        }
-    }
-    async read() {
-        const { iterator, options } = this;
-        let emitHyperlinks = false;
-        let hyperlinks = null;
-        switch (options.hyperlinks) {
-            case "emit":
-                emitHyperlinks = true;
-                break;
-            case "cache":
-                this.hyperlinks = hyperlinks = {};
-                break;
-            default:
-                break;
-        }
-        if (!emitHyperlinks && !hyperlinks) {
-            this.emit("finished");
-            return;
-        }
-        try {
-            for await (const events of parseSax(iterator)) {
-                for (const { eventType, value } of events) {
-                    if (eventType === "opentag") {
-                        const node = value;
-                        if (node.name === "Relationship") {
-                            const rId = node.attributes.Id;
-                            switch (node.attributes.Type) {
-                                case RelType.Hyperlink:
-                                    {
-                                        const relationship = {
-                                            type: Enums.RelationshipType.Hyperlink,
-                                            rId,
-                                            target: node.attributes.Target,
-                                            targetMode: node.attributes.TargetMode
-                                        };
-                                        if (emitHyperlinks) {
-                                            this.emit("hyperlink", relationship);
-                                        }
-                                        else {
-                                            hyperlinks[relationship.rId] = relationship;
-                                        }
-                                    }
-                                    break;
-                                default:
-                                    break;
-                            }
-                        }
-                    }
-                }
-            }
-            this.emit("finished");
-        }
-        catch (error) {
-            this.emit("error", error);
-        }
-    }
-}
-export { HyperlinkReader };

package/dist/esm/stream/xlsx/sheet-comments-writer.js

@@ -1,100 +0,0 @@
-import { XmlStream } from "../../utils/xml-stream.js";
-import { RelType } from "../../xlsx/rel-type.js";
-import { colCache } from "../../utils/col-cache.js";
-import { CommentXform } from "../../xlsx/xform/comment/comment-xform.js";
-import { VmlShapeXform } from "../../xlsx/xform/comment/vml-shape-xform.js";
-class SheetCommentsWriter {
-    constructor(worksheet, sheetRelsWriter, options) {
-        // in a workbook, each sheet will have a number
-        this.id = options.id;
-        this.count = 0;
-        this._worksheet = worksheet;
-        this._workbook = options.workbook;
-        this._sheetRelsWriter = sheetRelsWriter;
-    }
-    get commentsStream() {
-        if (!this._commentsStream) {
-            this._commentsStream = this._workbook._openStream(`xl/comments${this.id}.xml`);
-        }
-        return this._commentsStream;
-    }
-    get vmlStream() {
-        if (!this._vmlStream) {
-            this._vmlStream = this._workbook._openStream(`xl/drawings/vmlDrawing${this.id}.vml`);
-        }
-        return this._vmlStream;
-    }
-    _addRelationships() {
-        const commentRel = {
-            Type: RelType.Comments,
-            Target: `../comments${this.id}.xml`
-        };
-        this._sheetRelsWriter.addRelationship(commentRel);
-        const vmlDrawingRel = {
-            Type: RelType.VmlDrawing,
-            Target: `../drawings/vmlDrawing${this.id}.vml`
-        };
-        this.vmlRelId = this._sheetRelsWriter.addRelationship(vmlDrawingRel);
-    }
-    _addCommentRefs() {
-        this._workbook.commentRefs.push({
-            commentName: `comments${this.id}`,
-            vmlDrawing: `vmlDrawing${this.id}`
-        });
-    }
-    _writeOpen() {
-        this.commentsStream.write('<?xml version="1.0" encoding="UTF-8" standalone="yes"?>' +
-            '<comments xmlns="http://schemas.openxmlformats.org/spreadsheetml/2006/main">' +
-            "<authors><author>Author</author></authors>" +
-            "<commentList>");
-        this.vmlStream.write('<?xml version="1.0" encoding="UTF-8"?>' +
-            '<xml xmlns:o="urn:schemas-microsoft-com:office:office" xmlns:v="urn:schemas-microsoft-com:vml" xmlns:x="urn:schemas-microsoft-com:office:excel">' +
-            '<o:shapelayout v:ext="edit">' +
-            '<o:idmap v:ext="edit" data="1" />' +
-            "</o:shapelayout>" +
-            '<v:shapetype id="_x0000_t202" coordsize="21600,21600" o:spt="202" path="m,l,21600r21600,l21600,xe">' +
-            '<v:stroke joinstyle="miter" />' +
-            '<v:path gradientshapeok="t" o:connecttype="rect" />' +
-            "</v:shapetype>");
-    }
-    _writeComment(comment, index) {
-        const commentXform = new CommentXform();
-        const commentsXmlStream = new XmlStream();
-        commentXform.render(commentsXmlStream, comment);
-        this.commentsStream.write(commentsXmlStream.xml);
-        const vmlShapeXform = new VmlShapeXform();
-        const vmlXmlStream = new XmlStream();
-        vmlShapeXform.render(vmlXmlStream, comment, index);
-        this.vmlStream.write(vmlXmlStream.xml);
-    }
-    _writeClose() {
-        this.commentsStream.write("</commentList></comments>");
-        this.vmlStream.write("</xml>");
-    }
-    addComments(comments) {
-        if (comments && comments.length) {
-            if (!this.startedData) {
-                this._worksheet.comments = [];
-                this._writeOpen();
-                this._addRelationships();
-                this._addCommentRefs();
-                this.startedData = true;
-            }
-            comments.forEach(item => {
-                item.refAddress = colCache.decodeAddress(item.ref);
-            });
-            comments.forEach(comment => {
-                this._writeComment(comment, this.count);
-                this.count += 1;
-            });
-        }
-    }
-    commit() {
-        if (this.count) {
-            this._writeClose();
-            this.commentsStream.end();
-            this.vmlStream.end();
-        }
-    }
-}
-export { SheetCommentsWriter };

package/dist/esm/stream/xlsx/sheet-rels-writer.js

@@ -1,90 +0,0 @@
-import { xmlEncode } from "../../utils/utils.js";
-import { RelType } from "../../xlsx/rel-type.js";
-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(`xl/worksheets/_rels/sheet${this.id}.xml.rels`);
-        }
-        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/stream/xlsx/workbook-reader.js

@@ -1,352 +0,0 @@
-import fs from "fs";
-import { EventEmitter } from "events";
-import { PassThrough, Readable } from "stream";
-import os from "os";
-import { join } from "path";
-import { iterateStream } from "../../utils/iterate-stream.js";
-import { parseSax } from "../../utils/parse-sax.js";
-import { StylesXform } from "../../xlsx/xform/style/styles-xform.js";
-import { WorkbookXform } from "../../xlsx/xform/book/workbook-xform.js";
-import { RelationshipsXform } from "../../xlsx/xform/core/relationships-xform.js";
-import { WorksheetReader } from "./worksheet-reader.js";
-import { HyperlinkReader } from "./hyperlink-reader.js";
-import { createParse } from "../../utils/unzip/parse.js";
-class WorkbookReader extends EventEmitter {
-    constructor(input, options = {}) {
-        super();
-        this.input = input;
-        this.options = {
-            worksheets: "emit",
-            sharedStrings: "cache",
-            hyperlinks: "ignore",
-            styles: "ignore",
-            entries: "ignore",
-            ...options
-        };
-        this.styles = new StylesXform();
-        this.styles.init();
-    }
-    _getStream(input) {
-        if (input instanceof Readable) {
-            return input;
-        }
-        if (typeof input === "string") {
-            return fs.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 = 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 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(iterateStream(entry), sheetNo);
-                            }
-                            else {
-                                // Worksheet arrives before sharedStrings - write to temp file asynchronously
-                                const tmpDir = fs.mkdtempSync(join(os.tmpdir(), "excelts-"));
-                                const path = join(tmpDir, `sheet${sheetNo}.xml`);
-                                const tempFileCleanupCallback = () => {
-                                    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);
-                                });
-                                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(iterateStream(entry), sheetNo);
-                        }
-                        break;
-                }
-                entry.autodrain();
-            }
-            for (const worksheet of waitingWorkSheets) {
-                await worksheet.writePromise;
-                let fileStream = fs.createReadStream(worksheet.path);
-                try {
-                    // TODO: Remove once node v8 is deprecated
-                    // Detect and upgrade old fileStreams
-                    if (!fileStream[Symbol.asyncIterator]) {
-                        fileStream = fileStream.pipe(new 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 RelationshipsXform();
-        this.workbookRels = await xform.parseStream(iterateStream(entry));
-    }
-    async _parseWorkbook(entry) {
-        this._emitEntry({ type: "workbook" });
-        const workbook = new WorkbookXform();
-        this.model = await workbook.parseStream(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 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 worksheetReader = new 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 HyperlinkReader({
-            workbook: this,
-            id: parseInt(sheetNo, 10),
-            iterator: iterator,
-            options: this.options
-        });
-        if (this.options.hyperlinks === "emit") {
-            yield { eventType: "hyperlinks", value: hyperlinksReader };
-        }
-    }
-}
-const WorkbookReaderOptions = {
-    worksheets: ["emit", "ignore"],
-    sharedStrings: ["cache", "emit", "ignore"],
-    hyperlinks: ["cache", "emit", "ignore"],
-    styles: ["cache", "ignore"],
-    entries: ["emit", "ignore"]
-};
-export { WorkbookReader, WorkbookReaderOptions };