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

package/dist/cjs/csv/csv.js

@@ -1,257 +1,193 @@
 "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.CsvFormatterStream = exports.CsvParserStream = exports.CSV = void 0;
+exports.CSV = void 0;
 const fs_1 = __importDefault(require("fs"));
-const utils_1 = require("../utils/utils");
-const csv_base_1 = require("./csv.base");
-const csv_stream_1 = require("./csv-stream");
+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);
 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) {
-        if (!(await (0, utils_1.fileExists)(filename))) {
+        options = options || {};
+        if (!(await (0, utils_js_1.fileExists)(filename))) {
             throw new Error(`File not found: ${filename}`);
         }
-        const readStream = fs_1.default.createReadStream(filename, {
-            encoding: "utf8",
-            highWaterMark: options?.highWaterMark ?? 64 * 1024
-        });
-        return this.read(readStream, options);
+        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;
+        }
     }
-    /**
-     * 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);
+    read(stream, options) {
+        options = options || {};
         return new Promise((resolve, reject) => {
-            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 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
+            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);
         });
-        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;
-        });
+    write(stream, options) {
         return new Promise((resolve, reject) => {
-            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;
+            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) {
                 worksheet.eachRow((row, rowNumber) => {
                     if (includeEmptyRows) {
                         while (lastRow++ < rowNumber - 1) {
-                            formatter.write([]);
+                            csvStream.write([]);
                         }
                     }
                     const { values } = row;
                     values.shift();
-                    formatter.write(values.map(map));
+                    csvStream.write(values.map(map));
                     lastRow = rowNumber;
                 });
-                formatter.end();
-            });
-        }
-        else {
-            setImmediate(() => formatter.end());
-        }
-        return formatter;
-    }
-    /**
-     * 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));
+            }
+            csvStream.end();
         });
-        return parser;
+    }
+    writeFile(filename, options) {
+        options = options || {};
+        const streamOptions = {
+            encoding: (options.encoding || "utf8")
+        };
+        const stream = fs_1.default.createWriteStream(filename, streamOptions);
+        return this.write(stream, options);
+    }
+    async writeBuffer(options) {
+        const stream = new stream_buf_js_1.StreamBuf();
+        await this.write(stream, options);
+        return stream.read();
     }
 }
 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_1 = require("../utils/col-cache");
+const col_cache_js_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_1.colCache.decodeAddress(address);
+            const decoded = col_cache_js_1.colCache.decodeAddress(address);
             this.nativeCol = decoded.col + offset;
             this.nativeColOff = 0;
             this.nativeRow = decoded.row + offset;

package/dist/cjs/doc/cell.js

@@ -1,11 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Cell = void 0;
-const col_cache_1 = require("../utils/col-cache");
-const enums_1 = require("./enums");
-const note_1 = require("./note");
-const under_dash_1 = require("../utils/under-dash");
-const shared_formula_1 = require("../utils/shared-formula");
+const col_cache_js_1 = require("../utils/col-cache");
+const enums_js_1 = require("./enums");
+const note_js_1 = require("./note");
+const under_dash_js_1 = require("../utils/under-dash");
+const shared_formula_js_1 = require("../utils/shared-formula");
 // Cell requirements
 //  Operate inside a worksheet
 //  Store and retrieve a value with a range of types: text, number, date, hyperlink, reference, formula, etc.
@@ -17,7 +17,7 @@ class Cell {
         }
         this._row = row;
         this._column = column;
-        col_cache_1.colCache.validateAddress(address);
+        col_cache_js_1.colCache.validateAddress(address);
         this._address = address;
         // TODO: lazy evaluation of this._value
         this._value = Value.create(Cell.Types.Null, this);
@@ -194,7 +194,7 @@ class Cell {
         return noteValue;
     }
     set note(note) {
-        this._comment = new note_1.Note(note);
+        this._comment = new note_js_1.Note(note);
     }
     // Internal comment accessor for row operations
     get comment() {
@@ -204,18 +204,18 @@ class Cell {
         if (comment === undefined) {
             this._comment = undefined;
         }
-        else if (comment instanceof note_1.Note) {
+        else if (comment instanceof note_js_1.Note) {
             this._comment = comment;
         }
         else {
-            this._comment = new note_1.Note(comment);
+            this._comment = new note_js_1.Note(comment);
         }
     }
     get text() {
         return this._value.toString();
     }
     get html() {
-        return (0, under_dash_1.escapeHtml)(this.text);
+        return (0, under_dash_js_1.escapeHtml)(this.text);
     }
     toString() {
         return this.text;
@@ -304,7 +304,7 @@ class Cell {
         if (value.comment) {
             switch (value.comment.type) {
                 case "note":
-                    this._comment = note_1.Note.fromModel(value.comment);
+                    this._comment = note_js_1.Note.fromModel(value.comment);
                     break;
             }
         }
@@ -317,7 +317,7 @@ class Cell {
     }
 }
 exports.Cell = Cell;
-Cell.Types = enums_1.Enums.ValueType;
+Cell.Types = enums_js_1.Enums.ValueType;
 class NullValue {
     constructor(cell) {
         this.model = {
@@ -687,12 +687,12 @@ class FormulaValue {
     }
     get formulaType() {
         if (this.model.formula) {
-            return enums_1.Enums.FormulaType.Master;
+            return enums_js_1.Enums.FormulaType.Master;
         }
         if (this.model.sharedFormula) {
-            return enums_1.Enums.FormulaType.Shared;
+            return enums_js_1.Enums.FormulaType.Shared;
         }
-        return enums_1.Enums.FormulaType.None;
+        return enums_js_1.Enums.FormulaType.None;
     }
     get result() {
         return this.model.result;
@@ -706,21 +706,21 @@ class FormulaValue {
     get effectiveType() {
         const v = this.model.result;
         if (v === null || v === undefined) {
-            return enums_1.Enums.ValueType.Null;
+            return enums_js_1.Enums.ValueType.Null;
         }
         if (v instanceof String || typeof v === "string") {
-            return enums_1.Enums.ValueType.String;
+            return enums_js_1.Enums.ValueType.String;
         }
         if (typeof v === "number") {
-            return enums_1.Enums.ValueType.Number;
+            return enums_js_1.Enums.ValueType.Number;
         }
         if (v instanceof Date) {
-            return enums_1.Enums.ValueType.Date;
+            return enums_js_1.Enums.ValueType.Date;
         }
         if (typeof v === "object" && "error" in v) {
-            return enums_1.Enums.ValueType.Error;
+            return enums_js_1.Enums.ValueType.Error;
         }
-        return enums_1.Enums.ValueType.Null;
+        return enums_js_1.Enums.ValueType.Null;
     }
     get address() {
         return this.model.address;
@@ -733,7 +733,7 @@ class FormulaValue {
             const { worksheet } = this.cell;
             const master = worksheet.findCell(this.model.sharedFormula);
             this._translatedFormula =
-                master && (0, shared_formula_1.slideFormula)(master.formula, master.address, this.model.address);
+                master && (0, shared_formula_js_1.slideFormula)(master.formula, master.address, this.model.address);
         }
         return this._translatedFormula;
     }

package/dist/cjs/doc/column.js

@@ -1,9 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Column = void 0;
-const col_cache_1 = require("../utils/col-cache");
-const under_dash_1 = require("../utils/under-dash");
-const enums_1 = require("./enums");
+const col_cache_js_1 = require("../utils/col-cache");
+const under_dash_js_1 = require("../utils/under-dash");
+const enums_js_1 = require("./enums");
 const DEFAULT_COLUMN_WIDTH = 9;
 /**
  * Column defines the column properties for 1 column.
@@ -29,7 +29,7 @@ class Column {
      * Column letter key
      */
     get letter() {
-        return col_cache_1.colCache.n2l(this._number);
+        return col_cache_js_1.colCache.n2l(this._number);
     }
     get isCustomWidth() {
         return this.width !== undefined && this.width !== DEFAULT_COLUMN_WIDTH;
@@ -148,13 +148,13 @@ class Column {
         return (this.width === other.width &&
             this.hidden === other.hidden &&
             this.outlineLevel === other.outlineLevel &&
-            (0, under_dash_1.isEqual)(this.style, other.style));
+            (0, under_dash_js_1.isEqual)(this.style, other.style));
     }
     equivalentToModel(model) {
         return (this.width === model.width &&
             this.hidden === model.hidden &&
             this.outlineLevel === model.outlineLevel &&
-            (0, under_dash_1.isEqual)(this.style, model.style));
+            (0, under_dash_js_1.isEqual)(this.style, model.style));
     }
     get isDefault() {
         if (this.isCustomWidth) {
@@ -197,7 +197,7 @@ class Column {
     get values() {
         const v = [];
         this.eachCell((cell, rowNumber) => {
-            if (cell && cell.type !== enums_1.Enums.ValueType.Null) {
+            if (cell && cell.type !== enums_js_1.Enums.ValueType.Null) {
                 v[rowNumber] = cell.value;
             }
         });

package/dist/cjs/doc/data-validations.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.DataValidations = void 0;
-const col_cache_1 = require("../utils/col-cache");
+const col_cache_js_1 = require("../utils/col-cache");
 class DataValidations {
     constructor(model) {
         this.model = model || {};
@@ -22,10 +22,10 @@ class DataValidations {
         if (rangeKeys.length === 0) {
             return undefined;
         }
-        const decoded = col_cache_1.colCache.decodeAddress(address);
+        const decoded = col_cache_js_1.colCache.decodeAddress(address);
         for (const key of rangeKeys) {
             const rangeStr = key.slice(6); // Remove "range:" prefix
-            const rangeDecoded = col_cache_1.colCache.decodeEx(rangeStr);
+            const rangeDecoded = col_cache_js_1.colCache.decodeEx(rangeStr);
             if (rangeDecoded.dimensions) {
                 const tl = rangeDecoded.tl;
                 const br = rangeDecoded.br;