@cj-tech-master/excelts 1.6.3-canary.20251224124621.73c5d94 → 1.6.3

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

@@ -1,205 +0,0 @@
-"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;