@cj-tech-master/excelts 1.6.3 → 2.0.0-canary.20251228013952.4f2c3c6

package/dist/cjs/csv/csv.base.js

@@ -0,0 +1,137 @@
+"use strict";
+/**
+ * CSV Base class - Shared functionality for Node.js and Browser
+ *
+ * Uses native CSV parser (RFC 4180 compliant) with zero external dependencies.
+ * Date parsing uses native high-performance datetime utilities.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseCsvStream = exports.formatCsv = exports.parseCsv = void 0;
+exports.createDefaultValueMapper = createDefaultValueMapper;
+exports.createDefaultWriteMapper = createDefaultWriteMapper;
+exports.parseCsvToWorksheet = parseCsvToWorksheet;
+exports.formatWorksheetToCsv = formatWorksheetToCsv;
+const datetime_1 = require("../utils/datetime");
+const csv_core_1 = require("./csv-core");
+// Special Excel values mapping
+const SpecialValues = {
+    true: true,
+    false: false,
+    "#N/A": { error: "#N/A" },
+    "#REF!": { error: "#REF!" },
+    "#NAME?": { error: "#NAME?" },
+    "#DIV/0!": { error: "#DIV/0!" },
+    "#NULL!": { error: "#NULL!" },
+    "#VALUE!": { error: "#VALUE!" },
+    "#NUM!": { error: "#NUM!" }
+};
+/**
+ * Create the default value mapper for CSV parsing
+ */
+function createDefaultValueMapper(dateFormats) {
+    const dateParser = datetime_1.DateParser.create(dateFormats);
+    return function mapValue(datum) {
+        if (datum === "") {
+            return null;
+        }
+        // Try to parse as number
+        const datumNumber = Number(datum);
+        if (!Number.isNaN(datumNumber) && datumNumber !== Infinity) {
+            return datumNumber;
+        }
+        // Try to parse as date
+        const date = dateParser.parse(datum);
+        if (date) {
+            return date;
+        }
+        // Check for special values
+        const special = SpecialValues[datum];
+        if (special !== undefined) {
+            return special;
+        }
+        return datum;
+    };
+}
+/**
+ * Create the default value mapper for CSV writing
+ */
+function createDefaultWriteMapper(dateFormat, dateUTC) {
+    const formatter = dateFormat
+        ? datetime_1.DateFormatter.create(dateFormat, { utc: dateUTC })
+        : datetime_1.DateFormatter.iso(dateUTC);
+    return function mapValue(value) {
+        if (value) {
+            // Handle hyperlinks
+            if (value.text || value.hyperlink) {
+                return value.hyperlink || value.text || "";
+            }
+            // Handle formulas
+            if (value.formula || value.result) {
+                return value.result || "";
+            }
+            // Handle dates
+            if (value instanceof Date) {
+                return formatter.format(value);
+            }
+            // Handle errors
+            if (value.error) {
+                return value.error;
+            }
+            // Handle other objects
+            if (typeof value === "object") {
+                return JSON.stringify(value);
+            }
+        }
+        return value;
+    };
+}
+/**
+ * Parse CSV content into a worksheet
+ */
+function parseCsvToWorksheet(content, workbook, options = {}) {
+    const worksheet = workbook.addWorksheet(options.sheetName);
+    const dateFormats = options.dateFormats || [
+        "YYYY-MM-DD[T]HH:mm:ssZ",
+        "YYYY-MM-DD[T]HH:mm:ss",
+        "YYYY-MM-DD"
+    ];
+    const map = options.map || createDefaultValueMapper(dateFormats);
+    // Parse CSV
+    const rows = (0, csv_core_1.parseCsv)(content, options.parserOptions);
+    // Add rows to worksheet
+    for (const row of rows) {
+        worksheet.addRow(row.map(map));
+    }
+    return worksheet;
+}
+/**
+ * Format worksheet as CSV string
+ */
+function formatWorksheetToCsv(worksheet, options = {}) {
+    if (!worksheet) {
+        return "";
+    }
+    const { dateFormat, dateUTC } = options;
+    const map = options.map || createDefaultWriteMapper(dateFormat, dateUTC);
+    const includeEmptyRows = options.includeEmptyRows !== false;
+    const rows = [];
+    let lastRow = 1;
+    worksheet.eachRow((row, rowNumber) => {
+        // Add empty rows if needed
+        if (includeEmptyRows) {
+            while (lastRow++ < rowNumber - 1) {
+                rows.push([]);
+            }
+        }
+        const { values } = row;
+        values.shift(); // Remove first empty element (1-indexed)
+        rows.push(values.map(map));
+        lastRow = rowNumber;
+    });
+    return (0, csv_core_1.formatCsv)(rows, options.formatterOptions);
+}
+// Re-export core types
+var csv_core_2 = require("./csv-core");
+Object.defineProperty(exports, "parseCsv", { enumerable: true, get: function () { return csv_core_2.parseCsv; } });
+Object.defineProperty(exports, "formatCsv", { enumerable: true, get: function () { return csv_core_2.formatCsv; } });
+Object.defineProperty(exports, "parseCsvStream", { enumerable: true, get: function () { return csv_core_2.parseCsvStream; } });

package/dist/cjs/csv/csv.browser.js

@@ -0,0 +1,68 @@
+"use strict";
+/**
+ * CSV class for Browser - No file system dependencies
+ *
+ * Provides:
+ * - load: Load from string or ArrayBuffer
+ * - writeString: Write to string
+ * - writeBuffer: Write to Uint8Array
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CSV = void 0;
+const csv_base_1 = require("./csv.base");
+class CSV {
+    constructor(workbook) {
+        this.workbook = workbook;
+    }
+    /**
+     * Load CSV from string or ArrayBuffer
+     */
+    load(data, options) {
+        let content;
+        if (typeof data === "string") {
+            content = data;
+        }
+        else if (data instanceof ArrayBuffer) {
+            content = new TextDecoder("utf-8").decode(data);
+        }
+        else if (data instanceof Uint8Array) {
+            content = new TextDecoder("utf-8").decode(data);
+        }
+        else {
+            throw new Error("Invalid data type. Expected string, ArrayBuffer, or Uint8Array.");
+        }
+        return (0, csv_base_1.parseCsvToWorksheet)(content, this.workbook, options);
+    }
+    /**
+     * Write CSV to string
+     */
+    writeString(options) {
+        const worksheet = this.workbook.getWorksheet(options?.sheetName || options?.sheetId);
+        return (0, csv_base_1.formatWorksheetToCsv)(worksheet, options);
+    }
+    /**
+     * Write CSV to Uint8Array buffer
+     */
+    writeBuffer(options) {
+        const content = this.writeString(options);
+        return new TextEncoder().encode(content);
+    }
+    // Stubs for unsupported methods - throw helpful errors
+    async readFile(_filename, _options) {
+        throw new Error("CSV.readFile() is not available in browser. " +
+            "Use CSV.load() with string or ArrayBuffer instead.");
+    }
+    async read(_stream, _options) {
+        throw new Error("CSV.read() stream is not available in browser. " +
+            "Use CSV.load() with string or ArrayBuffer instead.");
+    }
+    async writeFile(_filename, _options) {
+        throw new Error("CSV.writeFile() is not available in browser. " +
+            "Use CSV.writeString() or CSV.writeBuffer() and handle download manually.");
+    }
+    write(_stream, _options) {
+        throw new Error("CSV.write() stream is not available in browser. " +
+            "Use CSV.writeString() or CSV.writeBuffer() instead.");
+    }
+}
+exports.CSV = CSV;

package/dist/cjs/csv/csv.js

@@ -1,193 +1,249 @@
 "use strict";
+/**
+ * CSV class for Node.js - Full streaming and file system support
+ *
+ * Features:
+ * - readFile: Read from file path (streaming)
+ * - writeFile: Write to file path (streaming)
+ * - read: Read from Node.js stream
+ * - write: Write to Node.js stream
+ * - createReadStream: Create a readable stream from worksheet
+ * - createWriteStream: Create a writable stream that writes to worksheet
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.CSV = void 0;
+exports.CsvFormatterStream = exports.CsvParserStream = exports.CSV = void 0;
 const fs_1 = __importDefault(require("fs"));
-const stream_buf_js_1 = require("../utils/stream-buf");
-const fast_csv_1 = require("fast-csv");
-const customParseFormat_js_1 = __importDefault(require("dayjs/plugin/customParseFormat"));
-const utc_js_1 = __importDefault(require("dayjs/plugin/utc"));
-const dayjs_1 = __importDefault(require("dayjs"));
-const utils_js_1 = require("../utils/utils");
-const SpecialValues = {
-    true: true,
-    false: false,
-    "#N/A": { error: "#N/A" },
-    "#REF!": { error: "#REF!" },
-    "#NAME?": { error: "#NAME?" },
-    "#DIV/0!": { error: "#DIV/0!" },
-    "#NULL!": { error: "#NULL!" },
-    "#VALUE!": { error: "#VALUE!" },
-    "#NUM!": { error: "#NUM!" }
-};
-dayjs_1.default.extend(customParseFormat_js_1.default);
-dayjs_1.default.extend(utc_js_1.default);
+const utils_1 = require("../utils/utils");
+const csv_base_1 = require("./csv.base");
+const csv_stream_1 = require("./csv-stream");
 class CSV {
     constructor(workbook) {
         this.workbook = workbook;
-        this.worksheet = null;
     }
+    /**
+     * Read CSV from file using streaming
+     *
+     * @example
+     * ```ts
+     * const worksheet = await workbook.csv.readFile('data.csv');
+     * ```
+     */
     async readFile(filename, options) {
-        options = options || {};
-        if (!(await (0, utils_js_1.fileExists)(filename))) {
+        if (!(await (0, utils_1.fileExists)(filename))) {
             throw new Error(`File not found: ${filename}`);
         }
-        const stream = fs_1.default.createReadStream(filename);
-        try {
-            const worksheet = await this.read(stream, options);
-            stream.close();
-            return worksheet;
-        }
-        catch (error) {
-            stream.close();
-            throw error;
-        }
+        const readStream = fs_1.default.createReadStream(filename, {
+            encoding: "utf8",
+            highWaterMark: options?.highWaterMark ?? 64 * 1024
+        });
+        return this.read(readStream, options);
     }
-    read(stream, options) {
-        options = options || {};
+    /**
+     * Read CSV from Node.js readable stream
+     *
+     * Uses true streaming - processes data row by row without loading entire file into memory.
+     *
+     * @example
+     * ```ts
+     * const stream = fs.createReadStream('data.csv');
+     * const worksheet = await workbook.csv.read(stream);
+     * ```
+     */
+    async read(stream, options) {
+        const worksheet = this.workbook.addWorksheet(options?.sheetName);
+        const dateFormats = options?.dateFormats ??
+            ["YYYY-MM-DD[T]HH:mm:ssZ", "YYYY-MM-DD[T]HH:mm:ss", "MM-DD-YYYY", "YYYY-MM-DD"];
+        const map = options?.map || (0, csv_base_1.createDefaultValueMapper)(dateFormats);
+        const parser = new csv_stream_1.CsvParserStream(options?.parserOptions);
         return new Promise((resolve, reject) => {
-            const worksheet = this.workbook.addWorksheet(options.sheetName);
-            const dateFormats = options.dateFormats || [
-                "YYYY-MM-DD[T]HH:mm:ssZ",
-                "YYYY-MM-DD[T]HH:mm:ss",
-                "MM-DD-YYYY",
-                "YYYY-MM-DD"
-            ];
-            const map = options.map ||
-                function (datum) {
-                    if (datum === "") {
-                        return null;
-                    }
-                    const datumNumber = Number(datum);
-                    if (!Number.isNaN(datumNumber) && datumNumber !== Infinity) {
-                        return datumNumber;
-                    }
-                    const dt = dateFormats.reduce((matchingDate, currentDateFormat) => {
-                        if (matchingDate) {
-                            return matchingDate;
-                        }
-                        const dayjsObj = (0, dayjs_1.default)(datum, currentDateFormat, true);
-                        if (dayjsObj.isValid()) {
-                            return dayjsObj;
-                        }
-                        return null;
-                    }, null);
-                    if (dt) {
-                        return new Date(dt.valueOf());
-                    }
-                    const special = SpecialValues[datum];
-                    if (special !== undefined) {
-                        return special;
-                    }
-                    return datum;
-                };
-            const onData = (data) => {
-                worksheet.addRow(data.map(map));
-            };
-            const onEnd = () => {
-                csvStream.emit("worksheet", worksheet);
-            };
-            const cleanup = () => {
-                csvStream.removeListener("data", onData);
-                csvStream.removeListener("end", onEnd);
-                csvStream.removeListener("worksheet", onWorksheet);
-                csvStream.removeListener("error", onError);
-            };
-            const onWorksheet = (ws) => {
-                cleanup();
-                resolve(ws);
-            };
-            const onError = (err) => {
-                cleanup();
-                reject(err);
-            };
-            const csvStream = (0, fast_csv_1.parse)(options.parserOptions).on("data", onData).on("end", onEnd);
-            csvStream.once("worksheet", onWorksheet).on("error", onError);
-            stream.pipe(csvStream);
+            stream.pipe(parser);
+            parser.on("data", (row) => {
+                worksheet.addRow(row.map(map));
+            });
+            parser.on("end", () => {
+                resolve(worksheet);
+            });
+            parser.on("error", reject);
+            stream.on("error", reject);
         });
     }
-    write(stream, options) {
+    /**
+     * Write CSV to file using streaming
+     *
+     * @example
+     * ```ts
+     * await workbook.csv.writeFile('output.csv');
+     * ```
+     */
+    async writeFile(filename, options) {
+        const writeStream = fs_1.default.createWriteStream(filename, {
+            encoding: (options?.encoding || "utf8"),
+            highWaterMark: options?.highWaterMark ?? 64 * 1024
+        });
+        return this.write(writeStream, options);
+    }
+    /**
+     * Write CSV to Node.js writable stream
+     *
+     * Uses true streaming - writes data row by row.
+     *
+     * @example
+     * ```ts
+     * const stream = fs.createWriteStream('output.csv');
+     * await workbook.csv.write(stream);
+     * ```
+     */
+    async write(stream, options) {
+        const worksheet = this.workbook.getWorksheet(options?.sheetName || options?.sheetId);
+        if (!worksheet) {
+            stream.end();
+            return;
+        }
+        const { dateFormat, dateUTC } = options || {};
+        const map = options?.map || (0, csv_base_1.createDefaultWriteMapper)(dateFormat, dateUTC);
+        const includeEmptyRows = options?.includeEmptyRows !== false;
+        const formatterOptions = {
+            ...options?.formatterOptions
+        };
+        const formatter = new csv_stream_1.CsvFormatterStream(formatterOptions);
+        formatter.pipe(stream);
+        let lastRow = 1;
+        worksheet.eachRow((row, rowNumber) => {
+            // Add empty rows if needed
+            if (includeEmptyRows) {
+                while (lastRow++ < rowNumber - 1) {
+                    formatter.write([]);
+                }
+            }
+            const { values } = row;
+            values.shift(); // Remove first empty element (1-indexed)
+            formatter.write(values.map(map));
+            lastRow = rowNumber;
+        });
         return new Promise((resolve, reject) => {
-            options = options || {};
-            // const encoding = options.encoding || 'utf8';
-            // const separator = options.separator || ',';
-            // const quoteChar = options.quoteChar || '\'';
-            const worksheet = this.workbook.getWorksheet(options.sheetName || options.sheetId);
-            const csvStream = (0, fast_csv_1.format)(options.formatterOptions);
-            const cleanup = () => {
-                stream.removeListener("finish", onFinish);
-                csvStream.removeListener("error", onError);
-            };
-            const onFinish = () => {
-                cleanup();
-                resolve();
-            };
-            const onError = (err) => {
-                cleanup();
-                reject(err);
-            };
-            stream.once("finish", onFinish);
-            csvStream.on("error", onError);
-            csvStream.pipe(stream);
-            const { dateFormat, dateUTC } = options;
-            const map = options.map ||
-                (value => {
-                    if (value) {
-                        if (value.text || value.hyperlink) {
-                            return value.hyperlink || value.text || "";
-                        }
-                        if (value.formula || value.result) {
-                            return value.result || "";
-                        }
-                        if (value instanceof Date) {
-                            if (dateFormat) {
-                                return dateUTC
-                                    ? dayjs_1.default.utc(value).format(dateFormat)
-                                    : (0, dayjs_1.default)(value).format(dateFormat);
-                            }
-                            return dateUTC ? dayjs_1.default.utc(value).format() : (0, dayjs_1.default)(value).format();
-                        }
-                        if (value.error) {
-                            return value.error;
-                        }
-                        if (typeof value === "object") {
-                            return JSON.stringify(value);
-                        }
-                    }
-                    return value;
-                });
-            const includeEmptyRows = options.includeEmptyRows === undefined || options.includeEmptyRows;
-            let lastRow = 1;
-            if (worksheet) {
+            formatter.on("error", reject);
+            stream.on("error", reject);
+            stream.on("finish", () => resolve());
+            formatter.end();
+        });
+    }
+    /**
+     * Write CSV to buffer
+     *
+     * Note: This loads the entire CSV into memory. For large files, use write() with a stream.
+     */
+    async writeBuffer(options) {
+        const chunks = [];
+        const { Writable } = await Promise.resolve().then(() => __importStar(require("stream")));
+        const bufferStream = new Writable({
+            write(chunk, encoding, callback) {
+                chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk, encoding));
+                callback();
+            }
+        });
+        await this.write(bufferStream, options);
+        return Buffer.concat(chunks);
+    }
+    /**
+     * Create a readable stream that outputs CSV rows from the worksheet
+     *
+     * @example
+     * ```ts
+     * const csvStream = workbook.csv.createReadStream();
+     * csvStream.pipe(fs.createWriteStream('output.csv'));
+     * ```
+     */
+    createReadStream(options) {
+        const worksheet = this.workbook.getWorksheet(options?.sheetName || options?.sheetId);
+        const { dateFormat, dateUTC } = options || {};
+        const map = options?.map || (0, csv_base_1.createDefaultWriteMapper)(dateFormat, dateUTC);
+        const includeEmptyRows = options?.includeEmptyRows !== false;
+        const formatterOptions = {
+            ...options?.formatterOptions
+        };
+        const formatter = new csv_stream_1.CsvFormatterStream(formatterOptions);
+        if (worksheet) {
+            // Use setImmediate to allow piping before data flows
+            setImmediate(() => {
+                let lastRow = 1;
                 worksheet.eachRow((row, rowNumber) => {
                     if (includeEmptyRows) {
                         while (lastRow++ < rowNumber - 1) {
-                            csvStream.write([]);
+                            formatter.write([]);
                         }
                     }
                     const { values } = row;
                     values.shift();
-                    csvStream.write(values.map(map));
+                    formatter.write(values.map(map));
                     lastRow = rowNumber;
                 });
-            }
-            csvStream.end();
-        });
-    }
-    writeFile(filename, options) {
-        options = options || {};
-        const streamOptions = {
-            encoding: (options.encoding || "utf8")
-        };
-        const stream = fs_1.default.createWriteStream(filename, streamOptions);
-        return this.write(stream, options);
+                formatter.end();
+            });
+        }
+        else {
+            setImmediate(() => formatter.end());
+        }
+        return formatter;
     }
-    async writeBuffer(options) {
-        const stream = new stream_buf_js_1.StreamBuf();
-        await this.write(stream, options);
-        return stream.read();
+    /**
+     * Create a writable stream that parses CSV and adds rows to a worksheet
+     *
+     * @example
+     * ```ts
+     * const csvWriter = workbook.csv.createWriteStream({ sheetName: 'Data' });
+     * fs.createReadStream('input.csv').pipe(csvWriter);
+     * await new Promise(resolve => csvWriter.on('finish', resolve));
+     * ```
+     */
+    createWriteStream(options) {
+        const worksheet = this.workbook.addWorksheet(options?.sheetName);
+        const dateFormats = options?.dateFormats ??
+            ["YYYY-MM-DD[T]HH:mm:ssZ", "YYYY-MM-DD[T]HH:mm:ss", "MM-DD-YYYY", "YYYY-MM-DD"];
+        const map = options?.map || (0, csv_base_1.createDefaultValueMapper)(dateFormats);
+        const parser = new csv_stream_1.CsvParserStream(options?.parserOptions);
+        parser.on("data", (row) => {
+            worksheet.addRow(row.map(map));
+        });
+        return parser;
     }
 }
 exports.CSV = CSV;
+var csv_stream_2 = require("./csv-stream");
+Object.defineProperty(exports, "CsvParserStream", { enumerable: true, get: function () { return csv_stream_2.CsvParserStream; } });
+Object.defineProperty(exports, "CsvFormatterStream", { enumerable: true, get: function () { return csv_stream_2.CsvFormatterStream; } });

package/dist/cjs/doc/anchor.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Anchor = void 0;
-const col_cache_js_1 = require("../utils/col-cache");
+const col_cache_1 = require("../utils/col-cache");
 function isAnchorModel(value) {
     return (typeof value === "object" &&
         "nativeCol" in value &&
@@ -22,7 +22,7 @@ class Anchor {
             this.nativeRowOff = 0;
         }
         else if (typeof address === "string") {
-            const decoded = col_cache_js_1.colCache.decodeAddress(address);
+            const decoded = col_cache_1.colCache.decodeAddress(address);
             this.nativeCol = decoded.col + offset;
             this.nativeColOff = 0;
             this.nativeRow = decoded.row + offset;