@cj-tech-master/excelts 3.1.0 → 4.0.0-canary.20260103013222.0e5d37f

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

@@ -1,141 +0,0 @@
-"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");
-const csv_number_1 = require("./csv-number");
-// 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, parserOptions) {
-    const dateParser = datetime_1.DateParser.create(dateFormats);
-    const decimalSeparator = parserOptions?.decimalSeparator ?? ".";
-    return function mapValue(datum) {
-        if (datum === "") {
-            return null;
-        }
-        // Try to parse as number
-        const datumNumber = typeof datum === "string" ? (0, csv_number_1.parseNumberFromCsv)(datum, decimalSeparator) : 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"
-    ];
-    // If using the default mapper, pass parserOptions for locale-aware number parsing.
-    // (Custom map overrides this behavior.)
-    const effectiveMap = options.map || createDefaultValueMapper(dateFormats, options.parserOptions);
-    // 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(effectiveMap));
-    }
-    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

@@ -1,68 +0,0 @@
-"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,249 +0,0 @@
-"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;
-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");
-class CSV {
-    constructor(workbook) {
-        this.workbook = workbook;
-    }
-    /**
-     * 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))) {
-            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);
-    }
-    /**
-     * 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, options?.parserOptions);
-        const parser = new csv_stream_1.CsvParserStream(options?.parserOptions);
-        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
-        });
-        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) => {
-            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) {
-                            formatter.write([]);
-                        }
-                    }
-                    const { values } = row;
-                    values.shift();
-                    formatter.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, options?.parserOptions);
-        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,100 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Anchor = void 0;
-const col_cache_1 = require("../utils/col-cache");
-function isAnchorModel(value) {
-    return (typeof value === "object" &&
-        "nativeCol" in value &&
-        "nativeRow" in value &&
-        "nativeColOff" in value &&
-        "nativeRowOff" in value);
-}
-function isSimpleAddress(value) {
-    return typeof value === "object" && "col" in value && "row" in value;
-}
-class Anchor {
-    constructor(worksheet, address, offset = 0) {
-        this.worksheet = worksheet;
-        if (!address) {
-            this.nativeCol = 0;
-            this.nativeColOff = 0;
-            this.nativeRow = 0;
-            this.nativeRowOff = 0;
-        }
-        else if (typeof address === "string") {
-            const decoded = col_cache_1.colCache.decodeAddress(address);
-            this.nativeCol = decoded.col + offset;
-            this.nativeColOff = 0;
-            this.nativeRow = decoded.row + offset;
-            this.nativeRowOff = 0;
-        }
-        else if (isAnchorModel(address)) {
-            this.nativeCol = address.nativeCol || 0;
-            this.nativeColOff = address.nativeColOff || 0;
-            this.nativeRow = address.nativeRow || 0;
-            this.nativeRowOff = address.nativeRowOff || 0;
-        }
-        else if (isSimpleAddress(address)) {
-            this.col = address.col + offset;
-            this.row = address.row + offset;
-        }
-        else {
-            this.nativeCol = 0;
-            this.nativeColOff = 0;
-            this.nativeRow = 0;
-            this.nativeRowOff = 0;
-        }
-    }
-    static asInstance(model) {
-        if (model == null) {
-            return null;
-        }
-        if (model instanceof Anchor) {
-            return model;
-        }
-        return new Anchor(undefined, model);
-    }
-    get col() {
-        return this.nativeCol + Math.min(this.colWidth - 1, this.nativeColOff) / this.colWidth;
-    }
-    set col(v) {
-        this.nativeCol = Math.floor(v);
-        this.nativeColOff = Math.floor((v - this.nativeCol) * this.colWidth);
-    }
-    get row() {
-        return this.nativeRow + Math.min(this.rowHeight - 1, this.nativeRowOff) / this.rowHeight;
-    }
-    set row(v) {
-        this.nativeRow = Math.floor(v);
-        this.nativeRowOff = Math.floor((v - this.nativeRow) * this.rowHeight);
-    }
-    get colWidth() {
-        return this.worksheet &&
-            this.worksheet.getColumn(this.nativeCol + 1) &&
-            this.worksheet.getColumn(this.nativeCol + 1).isCustomWidth
-            ? Math.floor(this.worksheet.getColumn(this.nativeCol + 1).width * 10000)
-            : 640000;
-    }
-    get rowHeight() {
-        return this.worksheet &&
-            this.worksheet.getRow(this.nativeRow + 1) &&
-            this.worksheet.getRow(this.nativeRow + 1).height
-            ? Math.floor(this.worksheet.getRow(this.nativeRow + 1).height * 10000)
-            : 180000;
-    }
-    get model() {
-        return {
-            nativeCol: this.nativeCol,
-            nativeColOff: this.nativeColOff,
-            nativeRow: this.nativeRow,
-            nativeRowOff: this.nativeRowOff
-        };
-    }
-    set model(value) {
-        this.nativeCol = value.nativeCol;
-        this.nativeColOff = value.nativeColOff;
-        this.nativeRow = value.nativeRow;
-        this.nativeRowOff = value.nativeRowOff;
-    }
-}
-exports.Anchor = Anchor;