@rowsncolumns/toolkit 24.4.1

package/dist/cjs/csv-import.js

@@ -0,0 +1,166 @@
+import { __awaiter, __generator, __read, __spreadArray } from "tslib";
+import { SheetCell } from "@rowsncolumns/spreadsheet-state";
+import { isNil, uuid } from "@rowsncolumns/utils";
+import * as XLSX from "xlsx";
+/**
+ * Sniff a byte-order mark at the start of a CSV byte stream.
+ * Returns the encoding the BOM declares, or `undefined` when no BOM
+ * is present (in which case bytes are treated as UTF-8).
+ */
+export var detectCSVBomEncoding = function (bytes) {
+    if (bytes.length >= 2) {
+        if (bytes[0] === 0xff && bytes[1] === 0xfe)
+            return "utf-16le";
+        if (bytes[0] === 0xfe && bytes[1] === 0xff)
+            return "utf-16be";
+    }
+    if (bytes.length >= 3 &&
+        bytes[0] === 0xef &&
+        bytes[1] === 0xbb &&
+        bytes[2] === 0xbf) {
+        return "utf-8";
+    }
+    return undefined;
+};
+/**
+ * Parse csv string into a 2d array
+ * https://stackoverflow.com/a/14991797
+ * @param str
+ * @returns
+ */
+export var parseCSV = function (input) { return __awaiter(void 0, void 0, void 0, function () {
+    var workbook, text, arrayBuffer, bomEncoding, text, worksheet, rows;
+    return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0:
+                if (!(typeof input === "string")) return [3 /*break*/, 1];
+                text = input.charCodeAt(0) === 0xfeff ? input.slice(1) : input;
+                workbook = XLSX.read(text, { type: "string", raw: true, dense: true });
+                return [3 /*break*/, 3];
+            case 1: return [4 /*yield*/, input.arrayBuffer()];
+            case 2:
+                arrayBuffer = _a.sent();
+                bomEncoding = detectCSVBomEncoding(new Uint8Array(arrayBuffer));
+                if (bomEncoding) {
+                    text = new TextDecoder(bomEncoding).decode(arrayBuffer);
+                    workbook = XLSX.read(text, { type: "string", raw: true, dense: true });
+                }
+                else {
+                    workbook = XLSX.read(arrayBuffer, {
+                        type: "array",
+                        raw: true,
+                        // UTF-8 encoding
+                        codepage: 65001,
+                        dense: true,
+                    });
+                }
+                _a.label = 3;
+            case 3:
+                worksheet = workbook.Sheets[workbook.SheetNames[0]];
+                rows = XLSX.utils.sheet_to_json(worksheet, {
+                    header: 1,
+                });
+                return [2 /*return*/, rows];
+        }
+    });
+}); };
+/**
+ * Create sheet data from csv string
+ * @param csv
+ * @param delimiter
+ * @returns
+ */
+export var createRowDataFromCSVString = function (csv_1) {
+    var args_1 = [];
+    for (var _i = 1; _i < arguments.length; _i++) {
+        args_1[_i - 1] = arguments[_i];
+    }
+    return __awaiter(void 0, __spreadArray([csv_1], __read(args_1), false), void 0, function (csv, preserveFormatting, locale) {
+        var rows, rowData, sheetCell, i, rowIndex, rowValue, j, columnIndex, text;
+        var _a;
+        if (preserveFormatting === void 0) { preserveFormatting = true; }
+        return __generator(this, function (_b) {
+            switch (_b.label) {
+                case 0: return [4 /*yield*/, parseCSV(csv)];
+                case 1:
+                    rows = (_a = (_b.sent())) !== null && _a !== void 0 ? _a : [];
+                    rowData = [];
+                    sheetCell = new SheetCell();
+                    sheetCell.setLocale(locale);
+                    for (i = 0; i < rows.length; i++) {
+                        rowIndex = i;
+                        if (!(rowIndex in rowData)) {
+                            rowData[rowIndex] = { values: [] };
+                        }
+                        rowValue = rows[i];
+                        if (isNil(rowValue)) {
+                            continue;
+                        }
+                        for (j = 0; j < rows[i].length; j++) {
+                            columnIndex = j;
+                            text = rows[i][j];
+                            sheetCell.assign(uuid(), { rowIndex: rowIndex, columnIndex: columnIndex });
+                            sheetCell.setUserEnteredValue(text);
+                            // Delete
+                            if (!preserveFormatting) {
+                                sheetCell.clearFormatting();
+                            }
+                            rowData[rowIndex].values[columnIndex] = sheetCell.getCellData();
+                        }
+                    }
+                    return [2 /*return*/, rowData];
+            }
+        });
+    });
+};
+/**
+ * Parse CSV file object
+ * @param file
+ * @returns
+ */
+export var createRowDataFromCSVFile = function (file_1) {
+    var args_1 = [];
+    for (var _i = 1; _i < arguments.length; _i++) {
+        args_1[_i - 1] = arguments[_i];
+    }
+    return __awaiter(void 0, __spreadArray([file_1], __read(args_1), false), void 0, function (file, preserveFormatting, locale) {
+        if (preserveFormatting === void 0) { preserveFormatting = true; }
+        return __generator(this, function (_a) {
+            return [2 /*return*/, createRowDataFromCSVString(file, preserveFormatting, locale)];
+        });
+    });
+};
+/**
+ * Create sheet data from csv string
+ * @param csv
+ * @param delimiter
+ * @returns
+ */
+export var createCellDataArrayFromCSVString = function (csv, locale) { return __awaiter(void 0, void 0, void 0, function () {
+    var rows, rowValues, sheetCell, i, cells, rowValue, j, text;
+    var _a;
+    return __generator(this, function (_b) {
+        switch (_b.label) {
+            case 0: return [4 /*yield*/, parseCSV(csv)];
+            case 1:
+                rows = (_a = (_b.sent())) !== null && _a !== void 0 ? _a : [];
+                rowValues = [];
+                sheetCell = new SheetCell();
+                sheetCell.setLocale(locale);
+                for (i = 0; i < rows.length; i++) {
+                    cells = [];
+                    rowValue = rows[i];
+                    if (isNil(rowValue)) {
+                        continue;
+                    }
+                    for (j = 0; j < rows[i].length; j++) {
+                        text = rows[i][j];
+                        sheetCell.setUserEnteredValue(text);
+                        cells.push(sheetCell.getCellData());
+                    }
+                    rowValues.push(cells);
+                }
+                return [2 /*return*/, rowValues];
+        }
+    });
+}); };

package/dist/cjs/csv-parser/helpers.d.ts

@@ -0,0 +1,14 @@
+import type { CellData, CellFormat } from "@rowsncolumns/spreadsheet";
+export type SharedStringState = {
+    /** Content-hash id → value. Insertion order tracks emission order. */
+    byId: Map<string, string>;
+    /** Entries added since the last chunk drain. */
+    pending: Array<[string, string]>;
+};
+export declare const createSharedStringState: () => SharedStringState;
+export declare const drainSharedStringPending: (sharedStrings: SharedStringState) => Array<[string, string]> | undefined;
+export declare const buildCellData: (rawValue: string | number | boolean, locale: string | undefined, preserveFormatting: boolean, enableSharedStrings: boolean, sharedStrings: SharedStringState) => CellData | {
+    ss: string;
+} | null;
+export declare const applyCellXfsRegistry: (cellData: CellData, cellXfs: Map<string, CellFormat>) => CellData;
+//# sourceMappingURL=helpers.d.ts.map

package/dist/cjs/csv-parser/helpers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"helpers.d.ts","sourceRoot":"","sources":["../../../csv-parser/helpers.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,QAAQ,EACR,UAAU,EAEX,MAAM,2BAA2B,CAAC;AAKnC,MAAM,MAAM,iBAAiB,GAAG;IAC9B,sEAAsE;IACtE,IAAI,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAC1B,gDAAgD;IAChD,OAAO,EAAE,KAAK,CAAC,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC;CAClC,CAAC;AAEF,eAAO,MAAM,uBAAuB,QAAO,iBAGzC,CAAC;AAEH,eAAO,MAAM,wBAAwB,GACnC,eAAe,iBAAiB,KAC/B,KAAK,CAAC,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,GAAG,SAK5B,CAAC;AAgFF,eAAO,MAAM,aAAa,GACxB,UAAU,MAAM,GAAG,MAAM,GAAG,OAAO,EACnC,QAAQ,MAAM,GAAG,SAAS,EAC1B,oBAAoB,OAAO,EAC3B,qBAAqB,OAAO,EAC5B,eAAe,iBAAiB,KAC/B,QAAQ,GAAG;IAAE,EAAE,EAAE,MAAM,CAAA;CAAE,GAAG,IA2E9B,CAAC;AAKF,eAAO,MAAM,oBAAoB,GAC/B,UAAU,QAAQ,EAClB,SAAS,GAAG,CAAC,MAAM,EAAE,UAAU,CAAC,aAiBjC,CAAC"}

package/dist/cjs/csv-parser/helpers.js

@@ -0,0 +1,145 @@
+import { __assign, __read } from "tslib";
+import { contentHash, getCellXfsKey, ssfFormat } from "@rowsncolumns/utils";
+import { detectValueTypeAndPattern } from "../excel-parser/plugins/xlsx/value-type-detection";
+export var createSharedStringState = function () { return ({
+    byId: new Map(),
+    pending: [],
+}); };
+export var drainSharedStringPending = function (sharedStrings) {
+    if (sharedStrings.pending.length === 0)
+        return undefined;
+    var drained = sharedStrings.pending;
+    sharedStrings.pending = [];
+    return drained;
+};
+var URL_PATTERN = /^(https?:\/\/)?(localhost|([\da-z\.-]+)\.([a-z\.]{2,6}))(:\d+)?(\/[\/\w \.-]*)*(\?[^\s]*)?$/i;
+var EMAIL_PATTERN = /^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$/;
+var isValidURLorEmail = function (str) {
+    if (!str || typeof str !== "string")
+        return false;
+    if (str.includes("@"))
+        return EMAIL_PATTERN.test(str);
+    if (str.includes("://")) {
+        try {
+            new URL(str);
+            return true;
+        }
+        catch (_a) {
+            return URL_PATTERN.test(str);
+        }
+    }
+    return URL_PATTERN.test(str) || EMAIL_PATTERN.test(str);
+};
+var hasExcelTextPrefix = function (value) {
+    return typeof value === "string" && value.startsWith("'") && value.length > 1;
+};
+var getSharedStringIndex = function (value, sharedStrings) {
+    var id = contentHash(value);
+    // Hash collisions with a *different* value are astronomically rare with
+    // 62^8 ids, but disambiguate deterministically if it ever happens so two
+    // distinct strings never share an id within one parse.
+    var suffix = 0;
+    while (true) {
+        var existing = sharedStrings.byId.get(id);
+        if (existing === value)
+            return id;
+        if (existing === undefined)
+            break;
+        suffix += 1;
+        id = contentHash("".concat(value, "\0").concat(suffix));
+    }
+    sharedStrings.byId.set(id, value);
+    sharedStrings.pending.push([id, value]);
+    return id;
+};
+var buildExtendedValue = function (valueType, value, numberValue) {
+    switch (valueType) {
+        case "boolValue":
+            return { bv: String(value).toUpperCase() === "TRUE" };
+        case "numberValue":
+            return { nv: numberValue !== null && numberValue !== void 0 ? numberValue : Number(value) };
+        case "formulaValue":
+            return { fv: String(value) };
+        case "stringValue":
+            return { sv: String(value) };
+        default:
+            return undefined;
+    }
+};
+var buildFormattedValue = function (valueType, value, pattern, numberValue) {
+    if (valueType === "numberValue") {
+        return ssfFormat(pattern !== null && pattern !== void 0 ? pattern : "GENERAL", numberValue !== null && numberValue !== void 0 ? numberValue : Number(value));
+    }
+    if (valueType === "boolValue") {
+        return String(value).toUpperCase();
+    }
+    return String(value);
+};
+export var buildCellData = function (rawValue, locale, preserveFormatting, enableSharedStrings, sharedStrings) {
+    var _a;
+    var normalizedValue = rawValue;
+    var forcedString = false;
+    if (hasExcelTextPrefix(normalizedValue)) {
+        normalizedValue = normalizedValue.slice(1);
+        forcedString = true;
+    }
+    var _b = __read(detectValueTypeAndPattern(normalizedValue, locale), 4), detectedType = _b[0], numberFormatType = _b[1], numberValue = _b[2], pattern = _b[3];
+    var finalType = forcedString ? "stringValue" : detectedType;
+    var extendedValue = buildExtendedValue(finalType, normalizedValue, numberValue);
+    if (!extendedValue) {
+        return null;
+    }
+    var isStringValue = finalType === "stringValue";
+    var isFormulaValue = finalType === "formulaValue";
+    var stringValue = String(normalizedValue);
+    var urlLike = isStringValue && !forcedString && isValidURLorEmail(stringValue);
+    if (enableSharedStrings && isStringValue && !forcedString && !urlLike) {
+        var id = getSharedStringIndex(stringValue, sharedStrings);
+        return { ss: id };
+    }
+    var formattedValue = preserveFormatting
+        ? buildFormattedValue(finalType, normalizedValue, pattern, numberValue)
+        : String(normalizedValue);
+    if (isFormulaValue) {
+        return {
+            ue: extendedValue,
+        };
+    }
+    var cellData = {
+        ue: extendedValue,
+        ev: extendedValue,
+        fv: formattedValue,
+    };
+    if (forcedString) {
+        cellData.ue = { sv: String(rawValue) };
+        cellData.ev = { sv: String(normalizedValue) };
+    }
+    // Imported formats are persisted on `uf` (the renderer derives auto
+    // alignment / underline at read time from the value + uf, so we only
+    // need to record explicit number formats here).
+    if (urlLike) {
+        cellData.hyperlink = stringValue;
+    }
+    if (numberFormatType) {
+        cellData.uf = __assign(__assign({}, ((_a = cellData.uf) !== null && _a !== void 0 ? _a : {})), { numberFormat: __assign({ type: numberFormatType }, (pattern ? { pattern: pattern } : {})) });
+    }
+    return cellData;
+};
+var isStyleReference = function (value) {
+    return !!value && typeof value === "object" && "sid" in value;
+};
+export var applyCellXfsRegistry = function (cellData, cellXfs) {
+    var nextCellData = cellData;
+    var uf = cellData.uf;
+    // Only `uf` is registered now — `ef` is no longer persisted. Legacy
+    // saved data may still carry an `ef` reference; the renderer falls back
+    // to it via getCellEffectiveFormat for backwards compatibility.
+    if (uf && !isStyleReference(uf)) {
+        var ufKey = getCellXfsKey(uf);
+        if (!cellXfs.has(ufKey)) {
+            cellXfs.set(ufKey, uf);
+        }
+        nextCellData = __assign(__assign({}, nextCellData), { uf: { sid: ufKey } });
+    }
+    return nextCellData;
+};

package/dist/cjs/csv-parser/types.d.ts

@@ -0,0 +1,66 @@
+import type { CellData } from "@rowsncolumns/spreadsheet";
+import type { RowData, CellXfs } from "@rowsncolumns/common-types";
+export declare enum CsvRequestType {
+    PARSE_CSV = "PARSE_CSV",
+    ACK_ROW_DATA = "ACK_ROW_DATA"
+}
+export declare enum CsvResponseType {
+    PARSE_CSV_SUCCESS = "PARSE_CSV_SUCCESS",
+    ROW_DATA_CHUNK = "ROW_DATA_CHUNK",
+    CELL_XFS = "CELL_XFS",
+    GET_SHARED_STRINGS_SUCCESS = "GET_SHARED_STRINGS_SUCCESS",
+    PARSE_CSV_COMPLETE = "PARSE_CSV_COMPLETE",
+    ERROR = "ERROR"
+}
+export type CsvWorkerRequest = {
+    requestType: CsvRequestType.PARSE_CSV;
+    file: File | ArrayBuffer;
+    pageSize: number;
+    startRowIndex: number;
+    startColumnIndex: number;
+    preserveFormatting?: boolean;
+    locale?: string;
+    enableSharedStrings?: boolean;
+    enableCellXfsRegistry?: boolean;
+    enableBackpressure?: boolean;
+} | {
+    requestType: CsvRequestType.ACK_ROW_DATA;
+    chunkIndex: number;
+};
+export type CsvWorkerResponse = {
+    responseType: CsvResponseType.PARSE_CSV_SUCCESS;
+    totalRows: number;
+    totalColumns: number;
+} | {
+    responseType: CsvResponseType.ROW_DATA_CHUNK;
+    chunkIndex: number;
+    rows: RowData<CellData | null>[];
+    rowIndices: number[];
+    totalRows: number;
+    totalColumns: number;
+    /**
+     * New shape: [id, value][] where id is a content-hash string and cell.ss
+     * already references it. Legacy shape (string[] + sharedStringsStartIndex)
+     * is still accepted by the host for older worker builds.
+     */
+    sharedStringsChunk?: Array<[string, string]> | string[];
+    /** @deprecated Present only with legacy `string[]` chunk shape. */
+    sharedStringsStartIndex?: number;
+    cellXfsChunk?: Array<[string, any]>;
+} | {
+    responseType: CsvResponseType.CELL_XFS;
+    cellXfs: CellXfs;
+} | {
+    responseType: CsvResponseType.GET_SHARED_STRINGS_SUCCESS;
+    /**
+     * New shape: [id, value][]. Legacy `string[]` is still accepted by the
+     * host so older worker builds keep working.
+     */
+    sharedStrings: Array<[string, string]> | string[];
+} | {
+    responseType: CsvResponseType.PARSE_CSV_COMPLETE;
+} | {
+    responseType: CsvResponseType.ERROR;
+    error?: string;
+};
+//# sourceMappingURL=types.d.ts.map

package/dist/cjs/csv-parser/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../csv-parser/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,2BAA2B,CAAC;AAC1D,OAAO,KAAK,EAAE,OAAO,EAAE,OAAO,EAAE,MAAM,4BAA4B,CAAC;AAEnE,oBAAY,cAAc;IACxB,SAAS,cAAc;IACvB,YAAY,iBAAiB;CAC9B;AAED,oBAAY,eAAe;IACzB,iBAAiB,sBAAsB;IACvC,cAAc,mBAAmB;IACjC,QAAQ,aAAa;IACrB,0BAA0B,+BAA+B;IACzD,kBAAkB,uBAAuB;IACzC,KAAK,UAAU;CAChB;AAED,MAAM,MAAM,gBAAgB,GACxB;IACE,WAAW,EAAE,cAAc,CAAC,SAAS,CAAC;IACtC,IAAI,EAAE,IAAI,GAAG,WAAW,CAAC;IACzB,QAAQ,EAAE,MAAM,CAAC;IACjB,aAAa,EAAE,MAAM,CAAC;IACtB,gBAAgB,EAAE,MAAM,CAAC;IACzB,kBAAkB,CAAC,EAAE,OAAO,CAAC;IAC7B,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,mBAAmB,CAAC,EAAE,OAAO,CAAC;IAC9B,qBAAqB,CAAC,EAAE,OAAO,CAAC;IAChC,kBAAkB,CAAC,EAAE,OAAO,CAAC;CAC9B,GACD;IACE,WAAW,EAAE,cAAc,CAAC,YAAY,CAAC;IACzC,UAAU,EAAE,MAAM,CAAC;CACpB,CAAC;AAEN,MAAM,MAAM,iBAAiB,GACzB;IACE,YAAY,EAAE,eAAe,CAAC,iBAAiB,CAAC;IAChD,SAAS,EAAE,MAAM,CAAC;IAClB,YAAY,EAAE,MAAM,CAAC;CACtB,GACD;IACE,YAAY,EAAE,eAAe,CAAC,cAAc,CAAC;IAC7C,UAAU,EAAE,MAAM,CAAC;IACnB,IAAI,EAAE,OAAO,CAAC,QAAQ,GAAG,IAAI,CAAC,EAAE,CAAC;IACjC,UAAU,EAAE,MAAM,EAAE,CAAC;IACrB,SAAS,EAAE,MAAM,CAAC;IAClB,YAAY,EAAE,MAAM,CAAC;IACrB;;;;OAIG;IACH,kBAAkB,CAAC,EAAE,KAAK,CAAC,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,GAAG,MAAM,EAAE,CAAC;IACxD,mEAAmE;IACnE,uBAAuB,CAAC,EAAE,MAAM,CAAC;IACjC,YAAY,CAAC,EAAE,KAAK,CAAC,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC,CAAC;CACrC,GACD;IACE,YAAY,EAAE,eAAe,CAAC,QAAQ,CAAC;IACvC,OAAO,EAAE,OAAO,CAAC;CAClB,GACD;IACE,YAAY,EAAE,eAAe,CAAC,0BAA0B,CAAC;IACzD;;;OAGG;IACH,aAAa,EAAE,KAAK,CAAC,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,GAAG,MAAM,EAAE,CAAC;CACnD,GACD;IACE,YAAY,EAAE,eAAe,CAAC,kBAAkB,CAAC;CAClD,GACD;IACE,YAAY,EAAE,eAAe,CAAC,KAAK,CAAC;IACpC,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB,CAAC"}

package/dist/cjs/csv-parser/types.js

@@ -0,0 +1,14 @@
+export var CsvRequestType;
+(function (CsvRequestType) {
+    CsvRequestType["PARSE_CSV"] = "PARSE_CSV";
+    CsvRequestType["ACK_ROW_DATA"] = "ACK_ROW_DATA";
+})(CsvRequestType || (CsvRequestType = {}));
+export var CsvResponseType;
+(function (CsvResponseType) {
+    CsvResponseType["PARSE_CSV_SUCCESS"] = "PARSE_CSV_SUCCESS";
+    CsvResponseType["ROW_DATA_CHUNK"] = "ROW_DATA_CHUNK";
+    CsvResponseType["CELL_XFS"] = "CELL_XFS";
+    CsvResponseType["GET_SHARED_STRINGS_SUCCESS"] = "GET_SHARED_STRINGS_SUCCESS";
+    CsvResponseType["PARSE_CSV_COMPLETE"] = "PARSE_CSV_COMPLETE";
+    CsvResponseType["ERROR"] = "ERROR";
+})(CsvResponseType || (CsvResponseType = {}));

package/dist/cjs/csv-parser/worker.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=worker.d.ts.map

package/dist/cjs/csv-parser/worker.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"worker.d.ts","sourceRoot":"","sources":["../../../csv-parser/worker.ts"],"names":[],"mappings":""}

package/dist/cjs/csv-parser/worker.js

@@ -0,0 +1,200 @@
+import { __awaiter, __generator, __values } from "tslib";
+import * as XLSX from "xlsx";
+import { readExcelFile } from "../excel-parser/helpers";
+import { delay } from "../excel-parser/utils";
+import { applyCellXfsRegistry, buildCellData, createSharedStringState, drainSharedStringPending, } from "./helpers";
+import { CsvRequestType, CsvResponseType } from "./types";
+var queuedAcks = [];
+var pendingAck = null;
+var resolveRowAck = function (chunkIndex) {
+    if (pendingAck && pendingAck.chunkIndex === chunkIndex) {
+        var resolve = pendingAck.resolve;
+        pendingAck = null;
+        resolve();
+        return;
+    }
+    queuedAcks.push(chunkIndex);
+};
+var waitForRowAck = function (chunkIndex) { return __awaiter(void 0, void 0, void 0, function () {
+    var queuedIndex;
+    return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0:
+                queuedIndex = queuedAcks.findIndex(function (ack) { return ack === chunkIndex; });
+                if (queuedIndex >= 0) {
+                    queuedAcks.splice(queuedIndex, 1);
+                    return [2 /*return*/];
+                }
+                return [4 /*yield*/, new Promise(function (resolve) {
+                        pendingAck = { chunkIndex: chunkIndex, resolve: resolve };
+                    })];
+            case 1:
+                _a.sent();
+                return [2 /*return*/];
+        }
+    });
+}); };
+self.onmessage = function (e) { return __awaiter(void 0, void 0, void 0, function () {
+    var requestType, buffer, workbook, worksheet, rows, totalRows, totalColumns, rows_1, rows_1_1, row, pageSize, startRowIndex, startColumnIndex, preserveFormatting, enableSharedStrings, enableCellXfsRegistry, enableBackpressure, locale, sharedStrings, cellXfs, lastCellXfsSize, chunkIndex, offset, rowData, rowIndices, chunk, i, rowIndex, rowValue, rowEntry, j, columnIndex, cellValue, cellData, nextCellData, sharedStringsChunk, cellXfsChunk, error_1;
+    var e_1, _a;
+    var _b, _c, _d, _e, _f;
+    return __generator(this, function (_g) {
+        switch (_g.label) {
+            case 0:
+                requestType = e.data.requestType;
+                _g.label = 1;
+            case 1:
+                _g.trys.push([1, 9, , 10]);
+                if (requestType === CsvRequestType.ACK_ROW_DATA) {
+                    resolveRowAck(e.data.chunkIndex);
+                    return [2 /*return*/];
+                }
+                if (requestType !== CsvRequestType.PARSE_CSV) {
+                    throw new Error("Unknown action: ".concat(requestType));
+                }
+                return [4 /*yield*/, readExcelFile(e.data.file)];
+            case 2:
+                buffer = _g.sent();
+                workbook = XLSX.read(buffer, {
+                    type: "array",
+                    raw: true,
+                    codepage: 65001,
+                    // Dense mode stores cells in a 2-D array instead of one object keyed by
+                    // A1 address. Non-dense mode crashes on large CSVs once the cell count
+                    // exceeds V8's per-object enumerable-property cap (2^23 = 8,388,608):
+                    // `RangeError: Too many properties to enumerate`.
+                    dense: true,
+                });
+                worksheet = workbook.Sheets[workbook.SheetNames[0]];
+                rows = XLSX.utils.sheet_to_json(worksheet, {
+                    header: 1,
+                });
+                totalRows = rows.length;
+                totalColumns = 0;
+                try {
+                    for (rows_1 = __values(rows), rows_1_1 = rows_1.next(); !rows_1_1.done; rows_1_1 = rows_1.next()) {
+                        row = rows_1_1.value;
+                        totalColumns = Math.max(totalColumns, (_b = row === null || row === void 0 ? void 0 : row.length) !== null && _b !== void 0 ? _b : 0);
+                    }
+                }
+                catch (e_1_1) { e_1 = { error: e_1_1 }; }
+                finally {
+                    try {
+                        if (rows_1_1 && !rows_1_1.done && (_a = rows_1.return)) _a.call(rows_1);
+                    }
+                    finally { if (e_1) throw e_1.error; }
+                }
+                self.postMessage({
+                    responseType: CsvResponseType.PARSE_CSV_SUCCESS,
+                    totalRows: totalRows,
+                    totalColumns: totalColumns,
+                });
+                pageSize = Math.max(1, e.data.pageSize);
+                startRowIndex = e.data.startRowIndex;
+                startColumnIndex = e.data.startColumnIndex;
+                preserveFormatting = (_c = e.data.preserveFormatting) !== null && _c !== void 0 ? _c : true;
+                enableSharedStrings = (_d = e.data.enableSharedStrings) !== null && _d !== void 0 ? _d : false;
+                enableCellXfsRegistry = (_e = e.data.enableCellXfsRegistry) !== null && _e !== void 0 ? _e : false;
+                enableBackpressure = (_f = e.data.enableBackpressure) !== null && _f !== void 0 ? _f : false;
+                locale = e.data.locale;
+                sharedStrings = createSharedStringState();
+                cellXfs = new Map();
+                lastCellXfsSize = 0;
+                chunkIndex = 0;
+                offset = 0;
+                _g.label = 3;
+            case 3:
+                if (!(offset < rows.length)) return [3 /*break*/, 8];
+                rowData = [];
+                rowIndices = [];
+                chunk = rows.slice(offset, offset + pageSize);
+                for (i = 0; i < chunk.length; i++) {
+                    rowIndex = startRowIndex + offset + i;
+                    rowValue = chunk[i];
+                    rowEntry = { values: [] };
+                    if (rowValue) {
+                        for (j = 0; j < rowValue.length; j++) {
+                            columnIndex = startColumnIndex + j;
+                            cellValue = rowValue[j];
+                            if (cellValue === undefined ||
+                                cellValue === null ||
+                                cellValue === "") {
+                                continue;
+                            }
+                            cellData = buildCellData(cellValue, locale, preserveFormatting, enableSharedStrings, sharedStrings);
+                            if (!cellData) {
+                                continue;
+                            }
+                            nextCellData = cellData;
+                            if (enableCellXfsRegistry &&
+                                nextCellData &&
+                                (nextCellData.ef || nextCellData.uf)) {
+                                nextCellData = applyCellXfsRegistry(nextCellData, cellXfs);
+                            }
+                            rowEntry.values[columnIndex] = nextCellData;
+                        }
+                    }
+                    rowData.push(rowEntry);
+                    rowIndices.push(rowIndex);
+                }
+                sharedStringsChunk = enableSharedStrings
+                    ? drainSharedStringPending(sharedStrings)
+                    : undefined;
+                cellXfsChunk = void 0;
+                if (enableCellXfsRegistry && cellXfs.size > lastCellXfsSize) {
+                    cellXfsChunk = Array.from(cellXfs.entries()).slice(lastCellXfsSize);
+                    lastCellXfsSize = cellXfs.size;
+                }
+                self.postMessage({
+                    responseType: CsvResponseType.ROW_DATA_CHUNK,
+                    chunkIndex: chunkIndex,
+                    rows: rowData,
+                    rowIndices: rowIndices,
+                    totalRows: totalRows,
+                    totalColumns: totalColumns,
+                    sharedStringsChunk: sharedStringsChunk,
+                    cellXfsChunk: cellXfsChunk,
+                });
+                if (!enableBackpressure) return [3 /*break*/, 5];
+                return [4 /*yield*/, waitForRowAck(chunkIndex)];
+            case 4:
+                _g.sent();
+                _g.label = 5;
+            case 5:
+                chunkIndex += 1;
+                return [4 /*yield*/, delay()];
+            case 6:
+                _g.sent();
+                _g.label = 7;
+            case 7:
+                offset += pageSize;
+                return [3 /*break*/, 3];
+            case 8:
+                if (enableSharedStrings) {
+                    self.postMessage({
+                        responseType: CsvResponseType.GET_SHARED_STRINGS_SUCCESS,
+                        sharedStrings: Array.from(sharedStrings.byId),
+                    });
+                }
+                if (enableCellXfsRegistry && cellXfs.size) {
+                    self.postMessage({
+                        responseType: CsvResponseType.CELL_XFS,
+                        cellXfs: cellXfs,
+                    });
+                }
+                self.postMessage({
+                    responseType: CsvResponseType.PARSE_CSV_COMPLETE,
+                });
+                return [3 /*break*/, 10];
+            case 9:
+                error_1 = _g.sent();
+                console.trace(error_1);
+                self.postMessage({
+                    responseType: CsvResponseType.ERROR,
+                    error: error_1 instanceof Error ? error_1.message : String(error_1),
+                });
+                return [3 /*break*/, 10];
+            case 10: return [2 /*return*/];
+        }
+    });
+}); };

package/dist/cjs/excel-export.d.ts

@@ -0,0 +1,11 @@
+import { type CellData, type Sheet } from "@rowsncolumns/spreadsheet";
+import type { ExportExcelProps } from "./exporter/xlsx/xlsx-export";
+import { Citation } from "@rowsncolumns/common-types";
+/**
+ * Download excel file
+ * @returns
+ */
+export declare const exportToExcel: <S extends Sheet, T extends CellData, C extends Citation>({ filename, ...rest }: ExportExcelProps<S, T, C> & {
+    filename: string;
+}) => Promise<string | Blob | undefined>;
+//# sourceMappingURL=excel-export.d.ts.map

package/dist/cjs/excel-export.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"excel-export.d.ts","sourceRoot":"","sources":["../../excel-export.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,QAAQ,EAAE,KAAK,KAAK,EAAE,MAAM,2BAA2B,CAAC;AAEtE,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,6BAA6B,CAAC;AAGpE,OAAO,EAAE,QAAQ,EAAE,MAAM,4BAA4B,CAAC;AAEtD;;;GAGG;AACH,eAAO,MAAM,aAAa,GACxB,CAAC,SAAS,KAAK,EACf,CAAC,SAAS,QAAQ,EAClB,CAAC,SAAS,QAAQ,EAClB,uBAGC,gBAAgB,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,GAAG;IAAE,QAAQ,EAAE,MAAM,CAAA;CAAE,uCAMlD,CAAC"}

package/dist/cjs/excel-export.js

@@ -0,0 +1,22 @@
+import { __awaiter, __generator, __rest } from "tslib";
+import { createExcelFile as createXlsxExport } from "./exporter/xlsx/xlsx-export";
+import { createDownloadableFile, toArrayBuffer } from "./helpers";
+/**
+ * Download excel file
+ * @returns
+ */
+export var exportToExcel = function (_a) { return __awaiter(void 0, void 0, void 0, function () {
+    var buffer, blob;
+    var filename = _a.filename, rest = __rest(_a, ["filename"]);
+    return __generator(this, function (_b) {
+        switch (_b.label) {
+            case 0: return [4 /*yield*/, createXlsxExport(rest)];
+            case 1:
+                buffer = _b.sent();
+                blob = new Blob([toArrayBuffer(buffer)], {
+                    type: "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
+                });
+                return [2 /*return*/, createDownloadableFile("".concat(filename, ".xlsx"), blob)];
+        }
+    });
+}); };