@cj-tech-master/excelts 0.1.0-canary.20251025023400.dff1908

package/dist/cjs/csv/csv.js

@@ -0,0 +1,193 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+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);
+class CSV {
+    constructor(workbook) {
+        this.workbook = workbook;
+        this.worksheet = null;
+    }
+    async readFile(filename, options) {
+        options = options || {};
+        if (!(await (0, utils_js_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;
+        }
+    }
+    read(stream, options) {
+        options = options || {};
+        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);
+        });
+    }
+    write(stream, options) {
+        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) {
+                worksheet.eachRow((row, rowNumber) => {
+                    if (includeEmptyRows) {
+                        while (lastRow++ < rowNumber - 1) {
+                            csvStream.write([]);
+                        }
+                    }
+                    const { values } = row;
+                    values.shift();
+                    csvStream.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);
+    }
+    async writeBuffer(options) {
+        const stream = new stream_buf_js_1.StreamBuf();
+        await this.write(stream, options);
+        return stream.read();
+    }
+}
+exports.CSV = CSV;

package/dist/cjs/doc/anchor.js

@@ -0,0 +1,86 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Anchor = void 0;
+const col_cache_js_1 = require("../utils/col-cache");
+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_js_1.colCache.decodeAddress(address);
+            this.nativeCol = decoded.col + offset;
+            this.nativeColOff = 0;
+            this.nativeRow = decoded.row + offset;
+            this.nativeRowOff = 0;
+        }
+        else if (address.nativeCol !== undefined) {
+            const anchor = address;
+            this.nativeCol = anchor.nativeCol || 0;
+            this.nativeColOff = anchor.nativeColOff || 0;
+            this.nativeRow = anchor.nativeRow || 0;
+            this.nativeRowOff = anchor.nativeRowOff || 0;
+        }
+        else if (address.col !== undefined) {
+            const simple = address;
+            this.col = simple.col + offset;
+            this.row = simple.row + offset;
+        }
+        else {
+            this.nativeCol = 0;
+            this.nativeColOff = 0;
+            this.nativeRow = 0;
+            this.nativeRowOff = 0;
+        }
+    }
+    static asInstance(model) {
+        return model instanceof Anchor || model == null ? model : 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;