@rowsncolumns/toolkit 24.4.1

package/dist/cjs/excel-parser/zip-parser-streaming.d.ts

@@ -0,0 +1,13 @@
+export declare class StreamingZipParser {
+    private reader;
+    private entries;
+    load(source: File | ArrayBuffer, password?: string): Promise<void>;
+    private createReader;
+    has(path: string): boolean;
+    getText(path: string): Promise<string>;
+    getBinary(path: string): Promise<Uint8Array>;
+    streamText(path: string, onChunk: (chunk: string) => void | Promise<void>): Promise<void>;
+    private getEntry;
+    dispose(): Promise<void>;
+}
+//# sourceMappingURL=zip-parser-streaming.d.ts.map

package/dist/cjs/excel-parser/zip-parser-streaming.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"zip-parser-streaming.d.ts","sourceRoot":"","sources":["../../../excel-parser/zip-parser-streaming.ts"],"names":[],"mappings":"AAkBA,qBAAa,kBAAkB;IAC7B,OAAO,CAAC,MAAM,CAAyD;IACvE,OAAO,CAAC,OAAO,CAAgC;IAEzC,IAAI,CAAC,MAAM,EAAE,IAAI,GAAG,WAAW,EAAE,QAAQ,CAAC,EAAE,MAAM;YAwC1C,YAAY;IAQ1B,GAAG,CAAC,IAAI,EAAE,MAAM;IAIV,OAAO,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC;IAatC,SAAS,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,UAAU,CAAC;IAQ5C,UAAU,CACd,IAAI,EAAE,MAAM,EACZ,OAAO,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC;IA0ClD,OAAO,CAAC,QAAQ;IAQV,OAAO;CAKd"}

package/dist/cjs/excel-parser/zip-parser-streaming.js

@@ -0,0 +1,200 @@
+import { __assign, __awaiter, __generator } from "tslib";
+import { BlobReader, TextWriter, Uint8ArrayReader, Uint8ArrayWriter, ZipReader, } from "@zip.js/zip.js";
+var isBun = typeof globalThis.Bun !== "undefined";
+var bunOptions = {
+    useWebWorkers: false,
+    useCompressionStream: false,
+    transferStreams: false,
+};
+var StreamingZipParser = /** @class */ (function () {
+    function StreamingZipParser() {
+        this.reader = null;
+        this.entries = new Map();
+    }
+    StreamingZipParser.prototype.load = function (source, password) {
+        return __awaiter(this, void 0, void 0, function () {
+            var reader, readerOptions, entries, error_1, hasEncrypted;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.createReader(source)];
+                    case 1:
+                        reader = _a.sent();
+                        readerOptions = isBun
+                            ? __assign(__assign({}, bunOptions), (password ? { password: password } : {})) : password
+                            ? { password: password }
+                            : undefined;
+                        this.reader = new ZipReader(reader, readerOptions);
+                        _a.label = 2;
+                    case 2:
+                        _a.trys.push([2, 4, , 5]);
+                        return [4 /*yield*/, this.reader.getEntries(isBun ? bunOptions : undefined)];
+                    case 3:
+                        // Don't pass password to getEntries - it's only needed for the reader
+                        entries = _a.sent();
+                        return [3 /*break*/, 5];
+                    case 4:
+                        error_1 = _a.sent();
+                        // Only classify as password-required when the reader explicitly reports
+                        // encryption/password. Central directory failures can also mean corruption
+                        // or unsupported container formats.
+                        if (error_1 instanceof Error && !password) {
+                            if (error_1.message.includes("encrypted") ||
+                                error_1.message.includes("password")) {
+                                throw new Error("PASSWORD_REQUIRED");
+                            }
+                        }
+                        // Re-throw other errors or errors when password was already provided
+                        throw error_1;
+                    case 5:
+                        hasEncrypted = entries.some(function (entry) { return entry.encrypted; });
+                        if (hasEncrypted && !password) {
+                            throw new Error("PASSWORD_REQUIRED");
+                        }
+                        this.entries = new Map(entries.filter(isFileEntry).map(function (entry) { return [entry.filename, entry]; }));
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    StreamingZipParser.prototype.createReader = function (source) {
+        return __awaiter(this, void 0, void 0, function () {
+            var buffer, _a;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        if (source instanceof File && !isBun) {
+                            return [2 /*return*/, new BlobReader(source)];
+                        }
+                        if (!(source instanceof File)) return [3 /*break*/, 2];
+                        return [4 /*yield*/, source.arrayBuffer()];
+                    case 1:
+                        _a = _b.sent();
+                        return [3 /*break*/, 3];
+                    case 2:
+                        _a = source;
+                        _b.label = 3;
+                    case 3:
+                        buffer = _a;
+                        return [2 /*return*/, new Uint8ArrayReader(new Uint8Array(buffer))];
+                }
+            });
+        });
+    };
+    StreamingZipParser.prototype.has = function (path) {
+        return this.entries.has(path);
+    };
+    StreamingZipParser.prototype.getText = function (path) {
+        return __awaiter(this, void 0, void 0, function () {
+            var entry, data;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        entry = this.getEntry(path);
+                        if (!isBun) return [3 /*break*/, 2];
+                        return [4 /*yield*/, entry.getData(new Uint8ArrayWriter(), bunOptions)];
+                    case 1:
+                        data = _a.sent();
+                        return [2 /*return*/, new TextDecoder().decode(data)];
+                    case 2: return [2 /*return*/, entry.getData(new TextWriter())];
+                }
+            });
+        });
+    };
+    StreamingZipParser.prototype.getBinary = function (path) {
+        return __awaiter(this, void 0, void 0, function () {
+            var entry;
+            return __generator(this, function (_a) {
+                entry = this.getEntry(path);
+                return [2 /*return*/, entry.getData(new Uint8ArrayWriter(), isBun ? bunOptions : undefined)];
+            });
+        });
+    };
+    StreamingZipParser.prototype.streamText = function (path, onChunk) {
+        return __awaiter(this, void 0, void 0, function () {
+            var _a, entry, decoder, delivered, writable, err_1, _b;
+            return __generator(this, function (_c) {
+                switch (_c.label) {
+                    case 0:
+                        if (!(isBun || typeof WritableStream === "undefined")) return [3 /*break*/, 3];
+                        _a = onChunk;
+                        return [4 /*yield*/, this.getText(path)];
+                    case 1: return [4 /*yield*/, _a.apply(void 0, [_c.sent()])];
+                    case 2:
+                        _c.sent();
+                        return [2 /*return*/];
+                    case 3:
+                        entry = this.getEntry(path);
+                        decoder = new TextDecoder();
+                        delivered = false;
+                        writable = new WritableStream({
+                            write: function (chunk) {
+                                var _a;
+                                var text = decoder.decode(chunk, { stream: true });
+                                if (text) {
+                                    delivered = true;
+                                    return (_a = onChunk(text)) !== null && _a !== void 0 ? _a : undefined;
+                                }
+                            },
+                            close: function () {
+                                var _a;
+                                var text = decoder.decode();
+                                if (text) {
+                                    delivered = true;
+                                    return (_a = onChunk(text)) !== null && _a !== void 0 ? _a : undefined;
+                                }
+                            },
+                        });
+                        _c.label = 4;
+                    case 4:
+                        _c.trys.push([4, 6, , 9]);
+                        return [4 /*yield*/, entry.getData(writable)];
+                    case 5:
+                        _c.sent();
+                        return [3 /*break*/, 9];
+                    case 6:
+                        err_1 = _c.sent();
+                        // Only fall back to a whole-file read when nothing was streamed yet;
+                        // re-emitting after partial delivery would duplicate content.
+                        if (delivered) {
+                            throw err_1;
+                        }
+                        _b = onChunk;
+                        return [4 /*yield*/, this.getText(path)];
+                    case 7: return [4 /*yield*/, _b.apply(void 0, [_c.sent()])];
+                    case 8:
+                        _c.sent();
+                        return [3 /*break*/, 9];
+                    case 9: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    StreamingZipParser.prototype.getEntry = function (path) {
+        var entry = this.entries.get(path);
+        if (!entry) {
+            throw new Error("path not in zip file: ".concat(path));
+        }
+        return entry;
+    };
+    StreamingZipParser.prototype.dispose = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            var _a;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        this.entries.clear();
+                        return [4 /*yield*/, ((_a = this.reader) === null || _a === void 0 ? void 0 : _a.close())];
+                    case 1:
+                        _b.sent();
+                        this.reader = null;
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    return StreamingZipParser;
+}());
+export { StreamingZipParser };
+function isFileEntry(entry) {
+    return !entry.directory;
+}

package/dist/cjs/excel-parser/zip-parser.d.ts

@@ -0,0 +1,11 @@
+import { type Unzipped } from "fflate";
+export declare class ZipParser {
+    records: Unzipped | undefined;
+    text: Map<string, string>;
+    load(buffer: ArrayBuffer, _password?: string): void;
+    Get(path: string): string;
+    Has(path: string): boolean;
+    Dispose(): void;
+    GetBinary(path: string): Uint8Array<ArrayBuffer>;
+}
+//# sourceMappingURL=zip-parser.d.ts.map

package/dist/cjs/excel-parser/zip-parser.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"zip-parser.d.ts","sourceRoot":"","sources":["../../../excel-parser/zip-parser.ts"],"names":[],"mappings":"AAAA,OAAO,EAAa,KAAK,QAAQ,EAAE,MAAM,QAAQ,CAAC;AAElD,qBAAa,SAAS;IACpB,OAAO,EAAE,QAAQ,GAAG,SAAS,CAAC;IACvB,IAAI,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAa;IAC7C,IAAI,CAAC,MAAM,EAAE,WAAW,EAAE,SAAS,CAAC,EAAE,MAAM;IASrC,GAAG,CAAC,IAAI,EAAE,MAAM;IAehB,GAAG,CAAC,IAAI,EAAE,MAAM;IAIhB,OAAO;IAKP,SAAS,CAAC,IAAI,EAAE,MAAM;CAO9B"}

package/dist/cjs/excel-parser/zip-parser.js

@@ -0,0 +1,49 @@
+import { unzipSync } from "fflate";
+var ZipParser = /** @class */ (function () {
+    function ZipParser() {
+        this.text = new Map();
+    }
+    ZipParser.prototype.load = function (buffer, _password) {
+        // Note: uzip library doesn't support password-protected archives
+        // Password parameter is accepted for API compatibility but not used
+        try {
+            this.records = unzipSync(new Uint8Array(buffer));
+        }
+        catch (err) {
+            throw err;
+        }
+    };
+    ZipParser.prototype.Get = function (path) {
+        var _a, _b;
+        var text = this.text.get(path);
+        if (text) {
+            return text;
+        }
+        var data = (_a = this.records) === null || _a === void 0 ? void 0 : _a[path];
+        if (data) {
+            text = new TextDecoder().decode(data);
+            this.text.set(path, text);
+            (_b = this.records) === null || _b === void 0 ? true : delete _b[path];
+            return text;
+        }
+        throw new Error("path not in zip file: " + path);
+    };
+    ZipParser.prototype.Has = function (path) {
+        var _a;
+        return this.text.has(path) || !!((_a = this.records) === null || _a === void 0 ? void 0 : _a[path]);
+    };
+    ZipParser.prototype.Dispose = function () {
+        this.text = new Map();
+        this.records = {};
+    };
+    ZipParser.prototype.GetBinary = function (path) {
+        var _a;
+        var data = (_a = this.records) === null || _a === void 0 ? void 0 : _a[path];
+        if (data) {
+            return new Uint8Array(data);
+        }
+        throw new Error("path not in records: " + path);
+    };
+    return ZipParser;
+}());
+export { ZipParser };

package/dist/cjs/exporter/invalid-data-validation.d.ts

@@ -0,0 +1,19 @@
+/**
+ * The UI-only marker stamped into a cell's `effectiveValue.ev` when its
+ * contents fail a data-validation rule
+ * (`{ type: "Invalid", message: "This cell's contents violate its validation rule" }`).
+ * It is not a real spreadsheet error: the cell keeps its underlying
+ * sv/nv/bv value and the grid renders a red indicator from the marker.
+ * Exporters must never write it as an error cell — Excel would read it
+ * back as a literal error (e.g. `#VALUE!`) and cascade that into every
+ * referencing formula.
+ */
+export declare const isInvalidDataValidationError: (errorValue?: Record<string, any> | string | null) => boolean;
+/**
+ * Strip the data-validation Invalid marker from an extended value so
+ * exporters see the cell's real value. Returns `undefined` when nothing
+ * but the marker remains (a blank cell that fails validation), letting
+ * callers fall back to `userEnteredValue` or export a blank cell.
+ */
+export declare const omitInvalidDataValidationError: <T extends Record<string, any>>(extValue?: T | null) => T | undefined;
+//# sourceMappingURL=invalid-data-validation.d.ts.map

package/dist/cjs/exporter/invalid-data-validation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"invalid-data-validation.d.ts","sourceRoot":"","sources":["../../../exporter/invalid-data-validation.ts"],"names":[],"mappings":"AAEA;;;;;;;;;GASG;AACH,eAAO,MAAM,4BAA4B,GACvC,aAAa,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,GAAG,MAAM,GAAG,IAAI,KAC/C,OAIF,CAAC;AAEF;;;;;GAKG;AACH,eAAO,MAAM,8BAA8B,GAAI,CAAC,SAAS,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,EAC1E,WAAW,CAAC,GAAG,IAAI,KAClB,CAAC,GAAG,SASN,CAAC"}

package/dist/cjs/exporter/invalid-data-validation.js

@@ -0,0 +1,39 @@
+import { __assign } from "tslib";
+import { getExtendedValueError } from "@rowsncolumns/utils";
+/**
+ * The UI-only marker stamped into a cell's `effectiveValue.ev` when its
+ * contents fail a data-validation rule
+ * (`{ type: "Invalid", message: "This cell's contents violate its validation rule" }`).
+ * It is not a real spreadsheet error: the cell keeps its underlying
+ * sv/nv/bv value and the grid renders a red indicator from the marker.
+ * Exporters must never write it as an error cell — Excel would read it
+ * back as a literal error (e.g. `#VALUE!`) and cascade that into every
+ * referencing formula.
+ */
+export var isInvalidDataValidationError = function (errorValue) {
+    var _a;
+    if (errorValue == null)
+        return false;
+    if (typeof errorValue === "string")
+        return errorValue === "Invalid";
+    return ((_a = errorValue.name) !== null && _a !== void 0 ? _a : errorValue.type) === "Invalid";
+};
+/**
+ * Strip the data-validation Invalid marker from an extended value so
+ * exporters see the cell's real value. Returns `undefined` when nothing
+ * but the marker remains (a blank cell that fails validation), letting
+ * callers fall back to `userEnteredValue` or export a blank cell.
+ */
+export var omitInvalidDataValidationError = function (extValue) {
+    if (extValue == null)
+        return undefined;
+    if (!isInvalidDataValidationError(getExtendedValueError(extValue))) {
+        return extValue;
+    }
+    var rest = __assign({}, extValue);
+    if (isInvalidDataValidationError(rest.ev))
+        delete rest.ev;
+    if (isInvalidDataValidationError(rest.errorValue))
+        delete rest.errorValue;
+    return Object.keys(rest).length > 0 ? rest : undefined;
+};

package/dist/cjs/exporter/ods/ods-export.d.ts

@@ -0,0 +1,26 @@
+import type { CellData, DataValidationRuleRecord, SheetData, IterativeCalculationOptions, Citation } from "@rowsncolumns/common-types";
+import type { ConditionalFormatRule, EmbeddedChart, EmbeddedObject, NamedRange, Sheet, SpreadsheetTheme, TableView } from "@rowsncolumns/spreadsheet";
+import { type SharedStrings } from "@rowsncolumns/spreadsheet-state";
+import type { CellXfs } from "@rowsncolumns/common-types";
+export type ExportOdsProps<S extends Sheet, T extends CellData, C extends Citation> = {
+    sheets: S[];
+    sheetData: SheetData<T>;
+    sharedStrings?: SharedStrings;
+    tables?: TableView[];
+    conditionalFormats?: ConditionalFormatRule[];
+    dataValidations?: DataValidationRuleRecord[];
+    cellXfs?: CellXfs | null;
+    theme?: SpreadsheetTheme;
+    embeds?: EmbeddedObject[];
+    charts?: EmbeddedChart[];
+    namedRanges?: NamedRange[];
+    iterativeCalculationOptions?: IterativeCalculationOptions;
+    ignoreFormulaPatterns?: RegExp | RegExp[];
+    citations?: Citation[];
+    /**
+     * Locale used by formula-cell number-format derivation at export time.
+     */
+    locale?: string;
+};
+export declare const createODSFile: <S extends Sheet, T extends CellData, C extends Citation>({ conditionalFormats: _conditionalFormats, dataValidations: _dataValidations, sheets, sheetData, sharedStrings: sourceSharedStrings, tables: _tables, cellXfs, theme: _theme, embeds, charts, namedRanges, iterativeCalculationOptions, ignoreFormulaPatterns, citations, locale, }: ExportOdsProps<S, T, C>) => Promise<ArrayBuffer>;
+//# sourceMappingURL=ods-export.d.ts.map

package/dist/cjs/exporter/ods/ods-export.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ods-export.d.ts","sourceRoot":"","sources":["../../../../exporter/ods/ods-export.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,QAAQ,EACR,wBAAwB,EAMxB,SAAS,EAET,2BAA2B,EAC3B,QAAQ,EACT,MAAM,4BAA4B,CAAC;AACpC,OAAO,KAAK,EAGV,qBAAqB,EAErB,aAAa,EACb,cAAc,EAGd,UAAU,EACV,KAAK,EAEL,gBAAgB,EAChB,SAAS,EAGV,MAAM,2BAA2B,CAAC;AAEnC,OAAO,EAGL,KAAK,aAAa,EACnB,MAAM,iCAAiC,CAAC;AACzC,OAAO,KAAK,EAAE,OAAO,EAAiB,MAAM,4BAA4B,CAAC;AAoHzE,MAAM,MAAM,cAAc,CACxB,CAAC,SAAS,KAAK,EACf,CAAC,SAAS,QAAQ,EAClB,CAAC,SAAS,QAAQ,IAChB;IACF,MAAM,EAAE,CAAC,EAAE,CAAC;IACZ,SAAS,EAAE,SAAS,CAAC,CAAC,CAAC,CAAC;IACxB,aAAa,CAAC,EAAE,aAAa,CAAC;IAC9B,MAAM,CAAC,EAAE,SAAS,EAAE,CAAC;IACrB,kBAAkB,CAAC,EAAE,qBAAqB,EAAE,CAAC;IAC7C,eAAe,CAAC,EAAE,wBAAwB,EAAE,CAAC;IAC7C,OAAO,CAAC,EAAE,OAAO,GAAG,IAAI,CAAC;IACzB,KAAK,CAAC,EAAE,gBAAgB,CAAC;IACzB,MAAM,CAAC,EAAE,cAAc,EAAE,CAAC;IAC1B,MAAM,CAAC,EAAE,aAAa,EAAE,CAAC;IACzB,WAAW,CAAC,EAAE,UAAU,EAAE,CAAC;IAC3B,2BAA2B,CAAC,EAAE,2BAA2B,CAAC;IAC1D,qBAAqB,CAAC,EAAE,MAAM,GAAG,MAAM,EAAE,CAAC;IAC1C,SAAS,CAAC,EAAE,QAAQ,EAAE,CAAC;IACvB;;OAEG;IACH,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB,CAAC;AA0RF,eAAO,MAAM,aAAa,GACxB,CAAC,SAAS,KAAK,EACf,CAAC,SAAS,QAAQ,EAClB,CAAC,SAAS,QAAQ,EAClB,qRAgBC,cAAc,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,yBAyJzB,CAAC"}