@rowsncolumns/toolkit 24.4.1

package/dist/esm/csv-import.js

@@ -0,0 +1,132 @@
+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 const detectCSVBomEncoding = (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 const parseCSV = async (input) => {
+    let workbook;
+    // `dense: true` stores cells in a 2-D array rather than 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`.
+    if (typeof input === "string") {
+        // A string that was produced by reading a BOM'd UTF-8 file as text can
+        // still start with U+FEFF — strip it so it doesn't land in cell A1.
+        const text = input.charCodeAt(0) === 0xfeff ? input.slice(1) : input;
+        workbook = XLSX.read(text, { type: "string", raw: true, dense: true });
+    }
+    else {
+        // Handle File input
+        const arrayBuffer = await input.arrayBuffer();
+        const bomEncoding = detectCSVBomEncoding(new Uint8Array(arrayBuffer));
+        if (bomEncoding) {
+            // TextDecoder strips the BOM itself (default `ignoreBOM: false`).
+            const 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,
+            });
+        }
+    }
+    const worksheet = workbook.Sheets[workbook.SheetNames[0]];
+    const rows = XLSX.utils.sheet_to_json(worksheet, {
+        header: 1,
+    });
+    return rows;
+};
+/**
+ * Create sheet data from csv string
+ * @param csv
+ * @param delimiter
+ * @returns
+ */
+export const createRowDataFromCSVString = async (csv, preserveFormatting = true, locale) => {
+    const rows = (await parseCSV(csv)) ?? [];
+    const rowData = [];
+    const sheetCell = new SheetCell();
+    sheetCell.setLocale(locale);
+    for (let i = 0; i < rows.length; i++) {
+        const rowIndex = i;
+        if (!(rowIndex in rowData)) {
+            rowData[rowIndex] = { values: [] };
+        }
+        const rowValue = rows[i];
+        if (isNil(rowValue)) {
+            continue;
+        }
+        for (let j = 0; j < rows[i].length; j++) {
+            const columnIndex = j;
+            const text = rows[i][j];
+            sheetCell.assign(uuid(), { rowIndex, columnIndex });
+            sheetCell.setUserEnteredValue(text);
+            // Delete
+            if (!preserveFormatting) {
+                sheetCell.clearFormatting();
+            }
+            rowData[rowIndex].values[columnIndex] = sheetCell.getCellData();
+        }
+    }
+    return rowData;
+};
+/**
+ * Parse CSV file object
+ * @param file
+ * @returns
+ */
+export const createRowDataFromCSVFile = async (file, preserveFormatting = true, locale) => createRowDataFromCSVString(file, preserveFormatting, locale);
+/**
+ * Create sheet data from csv string
+ * @param csv
+ * @param delimiter
+ * @returns
+ */
+export const createCellDataArrayFromCSVString = async (csv, locale) => {
+    const rows = (await parseCSV(csv)) ?? [];
+    const rowValues = [];
+    const sheetCell = new SheetCell();
+    sheetCell.setLocale(locale);
+    for (let i = 0; i < rows.length; i++) {
+        const cells = [];
+        const rowValue = rows[i];
+        if (isNil(rowValue)) {
+            continue;
+        }
+        for (let j = 0; j < rows[i].length; j++) {
+            const text = rows[i][j];
+            sheetCell.setUserEnteredValue(text);
+            cells.push(sheetCell.getCellData());
+        }
+        rowValues.push(cells);
+    }
+    return rowValues;
+};

package/dist/esm/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/esm/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/esm/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/esm/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/esm/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/esm/csv-parser/worker.d.ts

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

package/dist/esm/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/esm/csv-parser/worker.js

@@ -0,0 +1,154 @@
+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";
+const queuedAcks = [];
+let pendingAck = null;
+const resolveRowAck = (chunkIndex) => {
+    if (pendingAck && pendingAck.chunkIndex === chunkIndex) {
+        const { resolve } = pendingAck;
+        pendingAck = null;
+        resolve();
+        return;
+    }
+    queuedAcks.push(chunkIndex);
+};
+const waitForRowAck = async (chunkIndex) => {
+    const queuedIndex = queuedAcks.findIndex((ack) => ack === chunkIndex);
+    if (queuedIndex >= 0) {
+        queuedAcks.splice(queuedIndex, 1);
+        return;
+    }
+    await new Promise((resolve) => {
+        pendingAck = { chunkIndex, resolve };
+    });
+};
+self.onmessage = async (e) => {
+    const { requestType } = e.data;
+    try {
+        if (requestType === CsvRequestType.ACK_ROW_DATA) {
+            resolveRowAck(e.data.chunkIndex);
+            return;
+        }
+        if (requestType !== CsvRequestType.PARSE_CSV) {
+            throw new Error(`Unknown action: ${requestType}`);
+        }
+        const buffer = await readExcelFile(e.data.file);
+        const 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,
+        });
+        const worksheet = workbook.Sheets[workbook.SheetNames[0]];
+        const rows = XLSX.utils.sheet_to_json(worksheet, {
+            header: 1,
+        });
+        const totalRows = rows.length;
+        let totalColumns = 0;
+        for (const row of rows) {
+            totalColumns = Math.max(totalColumns, row?.length ?? 0);
+        }
+        self.postMessage({
+            responseType: CsvResponseType.PARSE_CSV_SUCCESS,
+            totalRows,
+            totalColumns,
+        });
+        const pageSize = Math.max(1, e.data.pageSize);
+        const startRowIndex = e.data.startRowIndex;
+        const startColumnIndex = e.data.startColumnIndex;
+        const preserveFormatting = e.data.preserveFormatting ?? true;
+        const enableSharedStrings = e.data.enableSharedStrings ?? false;
+        const enableCellXfsRegistry = e.data.enableCellXfsRegistry ?? false;
+        const enableBackpressure = e.data.enableBackpressure ?? false;
+        const locale = e.data.locale;
+        const sharedStrings = createSharedStringState();
+        const cellXfs = new Map();
+        let lastCellXfsSize = 0;
+        let chunkIndex = 0;
+        for (let offset = 0; offset < rows.length; offset += pageSize) {
+            const rowData = [];
+            const rowIndices = [];
+            const chunk = rows.slice(offset, offset + pageSize);
+            for (let i = 0; i < chunk.length; i++) {
+                const rowIndex = startRowIndex + offset + i;
+                const rowValue = chunk[i];
+                const rowEntry = { values: [] };
+                if (rowValue) {
+                    for (let j = 0; j < rowValue.length; j++) {
+                        const columnIndex = startColumnIndex + j;
+                        const cellValue = rowValue[j];
+                        if (cellValue === undefined ||
+                            cellValue === null ||
+                            cellValue === "") {
+                            continue;
+                        }
+                        const cellData = buildCellData(cellValue, locale, preserveFormatting, enableSharedStrings, sharedStrings);
+                        if (!cellData) {
+                            continue;
+                        }
+                        let nextCellData = cellData;
+                        if (enableCellXfsRegistry &&
+                            nextCellData &&
+                            (nextCellData.ef || nextCellData.uf)) {
+                            nextCellData = applyCellXfsRegistry(nextCellData, cellXfs);
+                        }
+                        rowEntry.values[columnIndex] = nextCellData;
+                    }
+                }
+                rowData.push(rowEntry);
+                rowIndices.push(rowIndex);
+            }
+            const sharedStringsChunk = enableSharedStrings
+                ? drainSharedStringPending(sharedStrings)
+                : undefined;
+            let cellXfsChunk;
+            if (enableCellXfsRegistry && cellXfs.size > lastCellXfsSize) {
+                cellXfsChunk = Array.from(cellXfs.entries()).slice(lastCellXfsSize);
+                lastCellXfsSize = cellXfs.size;
+            }
+            self.postMessage({
+                responseType: CsvResponseType.ROW_DATA_CHUNK,
+                chunkIndex,
+                rows: rowData,
+                rowIndices,
+                totalRows,
+                totalColumns,
+                sharedStringsChunk,
+                cellXfsChunk,
+            });
+            if (enableBackpressure) {
+                await waitForRowAck(chunkIndex);
+            }
+            chunkIndex += 1;
+            await delay();
+        }
+        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,
+            });
+        }
+        self.postMessage({
+            responseType: CsvResponseType.PARSE_CSV_COMPLETE,
+        });
+    }
+    catch (error) {
+        console.trace(error);
+        self.postMessage({
+            responseType: CsvResponseType.ERROR,
+            error: error instanceof Error ? error.message : String(error),
+        });
+    }
+};

package/dist/esm/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/esm/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/esm/excel-export.js

@@ -0,0 +1,13 @@
+import { createExcelFile as createXlsxExport } from "./exporter/xlsx/xlsx-export";
+import { createDownloadableFile, toArrayBuffer } from "./helpers";
+/**
+ * Download excel file
+ * @returns
+ */
+export const exportToExcel = async ({ filename, ...rest }) => {
+    const buffer = await createXlsxExport(rest);
+    const blob = new Blob([toArrayBuffer(buffer)], {
+        type: "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
+    });
+    return createDownloadableFile(`${filename}.xlsx`, blob);
+};

package/dist/esm/excel-import-session.d.ts

@@ -0,0 +1,51 @@
+import type { WorkerResponse } from "./excel-parser/types";
+import { ResponseType } from "./excel-parser/types";
+type OpenCompleteMessage = Extract<WorkerResponse, {
+    responseType: ResponseType.OPEN_WORKBOOK_COMPLETE;
+}>;
+type SheetChunkMessage = Extract<WorkerResponse, {
+    responseType: ResponseType.SHEET_CHUNK;
+}>;
+type SheetCompleteMessage = Extract<WorkerResponse, {
+    responseType: ResponseType.SHEET_COMPLETE;
+}>;
+export type ExcelSessionOpenSuccess = {
+    status: "open";
+} & Omit<OpenCompleteMessage, "responseType" | "generation">;
+/**
+ * The workbook is encrypted. Prompt the user, then call
+ * `session.providePassword(password)` — it resolves with the same
+ * `ExcelSessionOpenResult` shape (another `password-required` on a wrong
+ * password), mirroring the eager flow's PASSWORD_REQUIRED loop.
+ */
+export type ExcelSessionPasswordRequired = {
+    status: "password-required";
+    message?: string;
+};
+export type ExcelSessionOpenResult = ExcelSessionOpenSuccess | ExcelSessionPasswordRequired;
+export type ExcelSessionSheetChunk = Omit<SheetChunkMessage, "responseType" | "generation" | "requestId">;
+export type ExcelSessionSheetComplete = Omit<SheetCompleteMessage, "responseType" | "generation" | "requestId">;
+export type ExcelSessionLoadSheetOptions = {
+    chunkSize?: number;
+    enableCellXfsRegistry?: boolean;
+    enableSharedStrings?: boolean;
+    signal?: AbortSignal;
+};
+export type ExcelImportSession = {
+    open(): Promise<ExcelSessionOpenResult>;
+    providePassword(password: string): Promise<ExcelSessionOpenResult>;
+    loadSheet(sheetId: number, options?: ExcelSessionLoadSheetOptions): AsyncGenerator<ExcelSessionSheetChunk, ExcelSessionSheetComplete, void>;
+    dispose(): void;
+};
+/**
+ * Typed client for the session import worker protocol (issue #336). Opens
+ * a workbook once, keeps it resident worker-side, and streams individual
+ * sheets on demand with automatic requestId allocation, chunk
+ * acknowledgement backpressure, cancellation, and generation management.
+ */
+export declare const createExcelImportSession: (file: File | ArrayBuffer, options?: {
+    minRowCount?: number;
+    minColumnCount?: number;
+}) => ExcelImportSession;
+export {};
+//# sourceMappingURL=excel-import-session.d.ts.map

package/dist/esm/excel-import-session.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"excel-import-session.d.ts","sourceRoot":"","sources":["../../excel-import-session.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,sBAAsB,CAAC;AAC3D,OAAO,EAAe,YAAY,EAAE,MAAM,sBAAsB,CAAC;AAEjE,KAAK,mBAAmB,GAAG,OAAO,CAChC,cAAc,EACd;IAAE,YAAY,EAAE,YAAY,CAAC,sBAAsB,CAAA;CAAE,CACtD,CAAC;AACF,KAAK,iBAAiB,GAAG,OAAO,CAC9B,cAAc,EACd;IAAE,YAAY,EAAE,YAAY,CAAC,WAAW,CAAA;CAAE,CAC3C,CAAC;AACF,KAAK,oBAAoB,GAAG,OAAO,CACjC,cAAc,EACd;IAAE,YAAY,EAAE,YAAY,CAAC,cAAc,CAAA;CAAE,CAC9C,CAAC;AAEF,MAAM,MAAM,uBAAuB,GAAG;IACpC,MAAM,EAAE,MAAM,CAAC;CAChB,GAAG,IAAI,CAAC,mBAAmB,EAAE,cAAc,GAAG,YAAY,CAAC,CAAC;AAE7D;;;;;GAKG;AACH,MAAM,MAAM,4BAA4B,GAAG;IACzC,MAAM,EAAE,mBAAmB,CAAC;IAC5B,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB,CAAC;AAEF,MAAM,MAAM,sBAAsB,GAC9B,uBAAuB,GACvB,4BAA4B,CAAC;AAEjC,MAAM,MAAM,sBAAsB,GAAG,IAAI,CACvC,iBAAiB,EACjB,cAAc,GAAG,YAAY,GAAG,WAAW,CAC5C,CAAC;AAEF,MAAM,MAAM,yBAAyB,GAAG,IAAI,CAC1C,oBAAoB,EACpB,cAAc,GAAG,YAAY,GAAG,WAAW,CAC5C,CAAC;AAEF,MAAM,MAAM,4BAA4B,GAAG;IACzC,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,qBAAqB,CAAC,EAAE,OAAO,CAAC;IAChC,mBAAmB,CAAC,EAAE,OAAO,CAAC;IAC9B,MAAM,CAAC,EAAE,WAAW,CAAC;CACtB,CAAC;AAEF,MAAM,MAAM,kBAAkB,GAAG;IAC/B,IAAI,IAAI,OAAO,CAAC,sBAAsB,CAAC,CAAC;IACxC,eAAe,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,sBAAsB,CAAC,CAAC;IACnE,SAAS,CACP,OAAO,EAAE,MAAM,EACf,OAAO,CAAC,EAAE,4BAA4B,GACrC,cAAc,CAAC,sBAAsB,EAAE,yBAAyB,EAAE,IAAI,CAAC,CAAC;IAC3E,OAAO,IAAI,IAAI,CAAC;CACjB,CAAC;AA2BF;;;;;GAKG;AACH,eAAO,MAAM,wBAAwB,GACnC,MAAM,IAAI,GAAG,WAAW,EACxB,UAAU;IAAE,WAAW,CAAC,EAAE,MAAM,CAAC;IAAC,cAAc,CAAC,EAAE,MAAM,CAAA;CAAE,KAC1D,kBAgRF,CAAC"}