@cj-tech-master/excelts 1.6.2 → 1.6.3-canary.20251224125850.7da664f

package/dist/cjs/xlsx/xlsx.browser.js

@@ -0,0 +1,205 @@
+"use strict";
+/**
+ * XLSX Browser version - No Node.js dependencies
+ *
+ * Extends XLSXBase with:
+ * - load: Load from buffer/ArrayBuffer/Uint8Array
+ * - writeBuffer: Write to BrowserBuffer (Uint8Array with toString("base64"))
+ *
+ * NOT supported:
+ * - readFile/writeFile (no file system)
+ * - read/write (no streams)
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.XLSX = void 0;
+const fflate_1 = require("fflate");
+const zip_stream_browser_1 = require("../utils/zip-stream.browser");
+const stream_buf_browser_1 = require("../utils/stream-buf.browser");
+const utils_1 = require("../utils/utils");
+const browser_buffer_1 = require("../utils/browser-buffer");
+const xlsx_base_1 = require("./xlsx.base");
+/**
+ * Simple stream-like wrapper for parsing - implements async iterable
+ */
+class SimpleStream {
+    constructor(data) {
+        this.listeners = new Map();
+        this.ended = false;
+        this.data = data;
+    }
+    async *[Symbol.asyncIterator]() {
+        yield this.data;
+    }
+    on(event, callback) {
+        const listeners = this.listeners.get(event) || [];
+        listeners.push(callback);
+        this.listeners.set(event, listeners);
+        if (!this.ended) {
+            this.ended = true;
+            queueMicrotask(() => {
+                this.emit("data", this.data);
+                this.emit("end");
+            });
+        }
+        return this;
+    }
+    removeListener(event, callback) {
+        const listeners = this.listeners.get(event) || [];
+        const index = listeners.indexOf(callback);
+        if (index !== -1) {
+            listeners.splice(index, 1);
+        }
+        return this;
+    }
+    emit(event, ...args) {
+        const listeners = this.listeners.get(event) || [];
+        listeners.forEach(cb => cb(...args));
+    }
+    pipe(dest) {
+        dest.write(this.data instanceof Uint8Array ? this.data : new TextEncoder().encode(this.data));
+        dest.end();
+        return dest;
+    }
+}
+class XLSX extends xlsx_base_1.XLSXBase {
+    // ===========================================================================
+    // Abstract method implementations
+    // ===========================================================================
+    createStreamBuf() {
+        return new stream_buf_browser_1.StreamBuf();
+    }
+    createBinaryStream(data) {
+        return new SimpleStream(data);
+    }
+    createTextStream(content) {
+        return new SimpleStream(content);
+    }
+    bufferToString(data) {
+        return (0, utils_1.bufferToString)(data);
+    }
+    // ===========================================================================
+    // Browser specific: Buffer operations
+    // ===========================================================================
+    /**
+     * Load workbook from buffer/ArrayBuffer/Uint8Array
+     * This is the main entry point for browser usage
+     */
+    async load(data, options) {
+        let buffer;
+        if (!data ||
+            (typeof data === "object" && !(data instanceof Uint8Array) && !(data instanceof ArrayBuffer))) {
+            throw new Error("Can't read the data of 'the loaded zip file'. Is it in a supported JavaScript type (String, Blob, ArrayBuffer, etc) ?");
+        }
+        if (options && options.base64) {
+            buffer = (0, browser_buffer_1.base64ToUint8Array)(data.toString());
+        }
+        else if (data instanceof ArrayBuffer) {
+            buffer = new Uint8Array(data);
+        }
+        else if (data instanceof Uint8Array) {
+            buffer = data;
+        }
+        else {
+            buffer = new Uint8Array(data);
+        }
+        const allFiles = {};
+        await new Promise((resolve, reject) => {
+            let filesProcessed = 0;
+            let zipEnded = false;
+            let filesStarted = 0;
+            const checkCompletion = () => {
+                if (zipEnded && filesProcessed === filesStarted) {
+                    resolve();
+                }
+            };
+            const unzipper = new fflate_1.Unzip((file) => {
+                filesStarted++;
+                const fileChunks = [];
+                let totalLength = 0;
+                file.ondata = (err, fileData, final) => {
+                    if (err) {
+                        reject(err);
+                        return;
+                    }
+                    if (fileData) {
+                        fileChunks.push(fileData);
+                        totalLength += fileData.length;
+                    }
+                    if (final) {
+                        if (fileChunks.length === 1) {
+                            allFiles[file.name] = fileChunks[0];
+                        }
+                        else if (fileChunks.length > 1) {
+                            const fullData = new Uint8Array(totalLength);
+                            let offset = 0;
+                            for (const chunk of fileChunks) {
+                                fullData.set(chunk, offset);
+                                offset += chunk.length;
+                            }
+                            allFiles[file.name] = fullData;
+                        }
+                        else {
+                            allFiles[file.name] = new Uint8Array(0);
+                        }
+                        filesProcessed++;
+                        fileChunks.length = 0;
+                        checkCompletion();
+                    }
+                };
+                file.start();
+            });
+            unzipper.register(fflate_1.UnzipInflate);
+            unzipper.push(buffer, true);
+            zipEnded = true;
+            checkCompletion();
+        });
+        return this.loadFromFiles(allFiles, options);
+    }
+    /**
+     * Write workbook to buffer
+     * Returns a BrowserBuffer which supports toString("base64")
+     */
+    async writeBuffer(options) {
+        options = options || {};
+        const { model } = this.workbook;
+        const zip = new zip_stream_browser_1.ZipWriter(options.zip);
+        const stream = new stream_buf_browser_1.StreamBuf();
+        zip.pipe(stream);
+        this.prepareModel(model, options);
+        await this.addContentTypes(zip, model);
+        await this.addOfficeRels(zip, model);
+        await this.addWorkbookRels(zip, model);
+        await this.addWorksheets(zip, model);
+        await this.addSharedStrings(zip, model);
+        this.addDrawings(zip, model);
+        this.addTables(zip, model);
+        this.addPivotTables(zip, model);
+        await Promise.all([this.addThemes(zip, model), this.addStyles(zip, model)]);
+        await this.addMedia(zip, model);
+        await Promise.all([this.addApp(zip, model), this.addCore(zip, model)]);
+        await this.addWorkbook(zip, model);
+        await this._finalize(zip);
+        return browser_buffer_1.BrowserBuffer.from(stream.read());
+    }
+    // ===========================================================================
+    // Browser specific: Media handling (no file support)
+    // ===========================================================================
+    async addMedia(zip, model) {
+        await Promise.all(model.media.map(async (medium) => {
+            if (medium.type === "image") {
+                const filename = `xl/media/${medium.name}.${medium.extension}`;
+                if (medium.buffer) {
+                    return zip.append(medium.buffer, { name: filename });
+                }
+                if (medium.base64) {
+                    const dataimg64 = medium.base64;
+                    const content = dataimg64.substring(dataimg64.indexOf(",") + 1);
+                    return zip.append(content, { name: filename, base64: true });
+                }
+                throw new Error("Loading images from filename is not supported in browser");
+            }
+            throw new Error("Unsupported media");
+        }));
+    }
+}
+exports.XLSX = XLSX;