@rowsncolumns/spreadsheet-state 28.0.66

package/dist/cjs/hooks/use-on-import-csv-legacy.js

@@ -0,0 +1,165 @@
+import { __awaiter, __generator, __read, __spreadArray } from "tslib";
+import { DEFAULT_COLUMN_COUNT, DEFAULT_ROW_COUNT, useLoadingIndicator, } from "@rowsncolumns/spreadsheet";
+import { isNil } from "@rowsncolumns/utils";
+import { produceWithPatches } from "immer";
+import { useCallback, useRef } from "react";
+import * as XLSX from "xlsx";
+import { createSheetCellIdentifier } from "../api/formula";
+import { SheetCell } from "../sheet-cell";
+export var useOnImportCSVLegacy = function (_a) {
+    var locale = _a.locale, activeSheetId = _a.sheetId, currentActiveCell = _a.activeCell, createHistory = _a.createHistory, onChangeSheets = _a.onChangeSheets, onChangeSheetData = _a.onChangeSheetData, sharedStringRegistry = _a.sharedStringRegistry, enabledSharedStrings = _a.enabledSharedStrings, enqueueCalculation = _a.enqueueCalculation, getDependents = _a.getDependents;
+    var _b = __read(useLoadingIndicator(), 2), showLoader = _b[0], hideLoader = _b[1];
+    // Use a ref to track the current row index
+    var currentRowIndex = useRef(0);
+    // Import csv
+    var importCSVFile = useCallback(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, sheetId, activeCell, options) {
+            var _a, _b, preserveFormatting, _c, replaceSheetData, optionsEnabledSharedStrings, shouldUseSharedStrings, sheetCell, arrayBuffer, workbook, worksheet, rows, newRowCount, maxColumnCount, rowData, recalcCells, i, rowIndex, rowValue, j, columnIndex, text, cellData, chunkStartIndex, saveHistory;
+            var _d;
+            if (sheetId === void 0) { sheetId = activeSheetId; }
+            if (activeCell === void 0) { activeCell = currentActiveCell; }
+            return __generator(this, function (_e) {
+                switch (_e.label) {
+                    case 0:
+                        _a = options !== null && options !== void 0 ? options : {}, _b = _a.preserveFormatting, preserveFormatting = _b === void 0 ? true : _b, _c = _a.replaceSheetData, replaceSheetData = _c === void 0 ? false : _c, optionsEnabledSharedStrings = _a.enabledSharedStrings;
+                        shouldUseSharedStrings = !!sharedStringRegistry &&
+                            ((_d = optionsEnabledSharedStrings !== null && optionsEnabledSharedStrings !== void 0 ? optionsEnabledSharedStrings : enabledSharedStrings) !== null && _d !== void 0 ? _d : sharedStringRegistry.active);
+                        sheetCell = new SheetCell(sheetId, activeCell, undefined, {
+                            sharedStringRegistry: shouldUseSharedStrings
+                                ? sharedStringRegistry
+                                : undefined,
+                            locale: locale,
+                        });
+                        // Set start
+                        currentRowIndex.current = 0;
+                        // Show loader
+                        showLoader("Parsing CSV file");
+                        return [4 /*yield*/, file.arrayBuffer()];
+                    case 1:
+                        arrayBuffer = _e.sent();
+                        workbook = XLSX.read(arrayBuffer, {
+                            type: "array",
+                            raw: true,
+                            // UTF-8 encoding
+                            codepage: 65001,
+                        });
+                        worksheet = workbook.Sheets[workbook.SheetNames[0]];
+                        rows = XLSX.utils.sheet_to_json(worksheet, {
+                            header: 1,
+                        });
+                        newRowCount = activeCell.rowIndex + rows.length;
+                        maxColumnCount = 0;
+                        rowData = [];
+                        recalcCells = new Map();
+                        // Process current chunk
+                        for (i = 0; i < rows.length; i++) {
+                            rowIndex = currentRowIndex.current + i + activeCell.rowIndex;
+                            rowData[i] = { values: [] };
+                            rowValue = rows[i];
+                            if (isNil(rowValue))
+                                continue;
+                            maxColumnCount = Math.max(maxColumnCount, rowValue.length);
+                            for (j = 0; j < rows[i].length; j++) {
+                                columnIndex = j + activeCell.columnIndex;
+                                text = rows[i][j];
+                                sheetCell.assign(sheetId, { rowIndex: rowIndex, columnIndex: columnIndex }, undefined, {
+                                    sharedStringRegistry: sharedStringRegistry,
+                                    locale: locale,
+                                });
+                                sheetCell.setUserEnteredValue(text);
+                                // Remove formatting
+                                if (!preserveFormatting) {
+                                    sheetCell.clearFormatting();
+                                }
+                                // Register cell
+                                if (shouldUseSharedStrings) {
+                                    sharedStringRegistry === null || sharedStringRegistry === void 0 ? void 0 : sharedStringRegistry.registerCell(sheetCell);
+                                }
+                                cellData = sheetCell.getCellData();
+                                rowData[i].values[columnIndex] = cellData;
+                                if (getDependents &&
+                                    enqueueCalculation &&
+                                    getDependents({ rowIndex: rowIndex, columnIndex: columnIndex, sheetId: sheetId }).length) {
+                                    enqueueCalculation({
+                                        position: { rowIndex: rowIndex, columnIndex: columnIndex, sheetId: sheetId },
+                                        type: "add",
+                                    });
+                                    recalcCells.set(createSheetCellIdentifier(sheetId, rowIndex, columnIndex), {
+                                        rowIndex: rowIndex,
+                                        columnIndex: columnIndex,
+                                        sheetId: sheetId,
+                                    });
+                                }
+                            }
+                        }
+                        chunkStartIndex = currentRowIndex.current + activeCell.rowIndex;
+                        saveHistory = createHistory();
+                        // Update state
+                        onChangeSheetData === null || onChangeSheetData === void 0 ? void 0 : onChangeSheetData(function (prevSheetData) {
+                            var _a = __read(produceWithPatches(prevSheetData, function (draft) {
+                                // Clear sheet data if user is replacing
+                                if (replaceSheetData && draft[sheetId]) {
+                                    draft[sheetId].length = 0;
+                                }
+                                if (!draft[sheetId]) {
+                                    draft[sheetId] = [];
+                                }
+                                for (var i = 0; i < rowData.length; i++) {
+                                    var rowIndex = chunkStartIndex + i;
+                                    draft[sheetId][rowIndex] = rowData[i];
+                                }
+                            }), 3), nextState = _a[0], patches = _a[1], inversePatches = _a[2];
+                            saveHistory({
+                                sheetData: {
+                                    patches: patches,
+                                    inversePatches: inversePatches,
+                                },
+                                recalcCells: { undo: recalcCells, redo: recalcCells },
+                            });
+                            return nextState;
+                        });
+                        // Update rowCount
+                        onChangeSheets(function (prevSheets) {
+                            var _a = __read(produceWithPatches(prevSheets, function (draft) {
+                                var _a, _b;
+                                var sheet = draft.find(function (sheet) { return sheet.sheetId === sheetId; });
+                                if (sheet) {
+                                    sheet.rowCount = Math.max((_a = sheet.rowCount) !== null && _a !== void 0 ? _a : DEFAULT_ROW_COUNT, newRowCount);
+                                    sheet.columnCount = Math.max((_b = sheet.columnCount) !== null && _b !== void 0 ? _b : DEFAULT_COLUMN_COUNT, activeCell.columnIndex + maxColumnCount);
+                                }
+                            }), 3), nextState = _a[0], patches = _a[1], inversePatches = _a[2];
+                            saveHistory({
+                                sheets: { patches: patches, inversePatches: inversePatches },
+                            });
+                            return nextState;
+                        });
+                        if (shouldUseSharedStrings) {
+                            sharedStringRegistry === null || sharedStringRegistry === void 0 ? void 0 : sharedStringRegistry.getPatches(saveHistory);
+                        }
+                        hideLoader();
+                        return [2 /*return*/];
+                }
+            });
+        });
+    }, [
+        createHistory,
+        onChangeSheetData,
+        onChangeSheets,
+        hideLoader,
+        showLoader,
+        locale,
+        currentActiveCell,
+        activeSheetId,
+        sharedStringRegistry,
+        enabledSharedStrings,
+        enqueueCalculation,
+        getDependents,
+    ]);
+    return {
+        importCSVFile: importCSVFile,
+    };
+};

package/dist/cjs/hooks/use-on-import-csv.d.ts

@@ -0,0 +1,28 @@
+import type { CellInterface } from "@rowsncolumns/common-types";
+import type { CellData, Sheet } from "@rowsncolumns/spreadsheet";
+import type { CalculationOperation, useCalculation } from "./use-calculation";
+import type { InsertFileOptions } from "./use-on-drag-n-drop";
+import { type UseSpreadsheetProps } from "./use-spreadsheet-state";
+import type { SharedStringRegistry } from "./use-ss-registry";
+import type { SpreadsheetPatch } from "./use-undo-redo";
+export type UseOnImportCSVProps<T extends CellData, S extends Sheet> = {
+    locale?: string;
+    sheetId: number;
+    activeCell: CellInterface;
+    rowCount?: number;
+    createHistory: () => (patches: SpreadsheetPatch) => void;
+    onChangeSheetData: UseSpreadsheetProps<T, S>["onChangeSheetData"];
+    onChangeSheets: UseSpreadsheetProps<T, S>["onChangeSheets"];
+    onChangeSharedStrings?: UseSpreadsheetProps<T, S>["onChangeSharedStrings"];
+    onChangeCellXfs?: UseSpreadsheetProps<T, S>["onChangeCellXfs"];
+    sharedStringRegistry?: SharedStringRegistry;
+    enabledSharedStrings?: boolean;
+    enableCellXfsRegistry?: boolean;
+    enqueueCalculation?: (operation: CalculationOperation) => void;
+    clearRangeCache?: ReturnType<typeof useCalculation>["clearRangeCache"];
+    getDependents?: ReturnType<typeof useCalculation>["getDependents"];
+};
+export declare const useOnImportCSV: <T extends CellData, S extends Sheet>({ locale, sheetId: activeSheetId, activeCell: currentActiveCell, createHistory, onChangeSheets, onChangeSheetData, onChangeSharedStrings, onChangeCellXfs, sharedStringRegistry, enabledSharedStrings, enableCellXfsRegistry, enqueueCalculation, clearRangeCache, getDependents, }: UseOnImportCSVProps<T, S>) => {
+    importCSVFile: (file: File, sheetId?: number, activeCell?: CellInterface, options?: InsertFileOptions) => Promise<void>;
+};
+//# sourceMappingURL=use-on-import-csv.d.ts.map

package/dist/cjs/hooks/use-on-import-csv.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-on-import-csv.d.ts","sourceRoot":"","sources":["../../../hooks/use-on-import-csv.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,4BAA4B,CAAC;AAChE,OAAO,KAAK,EAAE,QAAQ,EAAE,KAAK,EAAE,MAAM,2BAA2B,CAAC;AAsBjE,OAAO,KAAK,EAAE,oBAAoB,EAAE,cAAc,EAAE,MAAM,mBAAmB,CAAC;AAC9E,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,sBAAsB,CAAC;AAC9D,OAAO,EAEL,KAAK,mBAAmB,EACzB,MAAM,yBAAyB,CAAC;AACjC,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,mBAAmB,CAAC;AAC9D,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,iBAAiB,CAAC;AAExD,MAAM,MAAM,mBAAmB,CAAC,CAAC,SAAS,QAAQ,EAAE,CAAC,SAAS,KAAK,IAAI;IACrE,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,MAAM,CAAC;IAChB,UAAU,EAAE,aAAa,CAAC;IAC1B,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,aAAa,EAAE,MAAM,CAAC,OAAO,EAAE,gBAAgB,KAAK,IAAI,CAAC;IACzD,iBAAiB,EAAE,mBAAmB,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,mBAAmB,CAAC,CAAC;IAClE,cAAc,EAAE,mBAAmB,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,gBAAgB,CAAC,CAAC;IAC5D,qBAAqB,CAAC,EAAE,mBAAmB,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,uBAAuB,CAAC,CAAC;IAC3E,eAAe,CAAC,EAAE,mBAAmB,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,iBAAiB,CAAC,CAAC;IAC/D,oBAAoB,CAAC,EAAE,oBAAoB,CAAC;IAC5C,oBAAoB,CAAC,EAAE,OAAO,CAAC;IAC/B,qBAAqB,CAAC,EAAE,OAAO,CAAC;IAChC,kBAAkB,CAAC,EAAE,CAAC,SAAS,EAAE,oBAAoB,KAAK,IAAI,CAAC;IAC/D,eAAe,CAAC,EAAE,UAAU,CAAC,OAAO,cAAc,CAAC,CAAC,iBAAiB,CAAC,CAAC;IACvE,aAAa,CAAC,EAAE,UAAU,CAAC,OAAO,cAAc,CAAC,CAAC,eAAe,CAAC,CAAC;CACpE,CAAC;AAEF,eAAO,MAAM,cAAc,GAAI,CAAC,SAAS,QAAQ,EAAE,CAAC,SAAS,KAAK,EAAE,qRAejE,mBAAmB,CAAC,CAAC,EAAE,CAAC,CAAC;0BAMhB,IAAI,iCAEE,aAAa,YACf,iBAAiB;CAwWhC,CAAC"}

package/dist/cjs/hooks/use-on-import-csv.js

@@ -0,0 +1,332 @@
+import { __awaiter, __generator, __read, __spreadArray, __values } from "tslib";
+import { DEFAULT_COLUMN_COUNT, DEFAULT_ROW_COUNT, useLoadingIndicator, } from "@rowsncolumns/spreadsheet";
+import { createCSVImportWorker, CsvRequestType, CsvResponseType, } from "@rowsncolumns/toolkit";
+import { getCellUserEnteredValue, getExtendedValueFormula, isNil, } from "@rowsncolumns/utils";
+import { produceWithPatches } from "immer";
+import { useCallback } from "react";
+import { createSheetCellIdentifier } from "../api/formula";
+export var useOnImportCSV = function (_a) {
+    var locale = _a.locale, activeSheetId = _a.sheetId, currentActiveCell = _a.activeCell, createHistory = _a.createHistory, onChangeSheets = _a.onChangeSheets, onChangeSheetData = _a.onChangeSheetData, onChangeSharedStrings = _a.onChangeSharedStrings, onChangeCellXfs = _a.onChangeCellXfs, sharedStringRegistry = _a.sharedStringRegistry, enabledSharedStrings = _a.enabledSharedStrings, enableCellXfsRegistry = _a.enableCellXfsRegistry, enqueueCalculation = _a.enqueueCalculation, clearRangeCache = _a.clearRangeCache, getDependents = _a.getDependents;
+    var _b = __read(useLoadingIndicator(), 2), showLoader = _b[0], hideLoader = _b[1];
+    // Import csv
+    var importCSVFile = useCallback(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, sheetId, activeCell, options) {
+            var _a, _b, preserveFormatting, _c, replaceSheetData, optionsEnabledSharedStrings, optionsEnableCellXfsRegistry, shouldUseSharedStrings, shouldUseCellXfsRegistry, saveHistory, _d, observable, sendMessage, hasSharedStringChunks;
+            var _e, _f;
+            if (sheetId === void 0) { sheetId = activeSheetId; }
+            if (activeCell === void 0) { activeCell = currentActiveCell; }
+            return __generator(this, function (_g) {
+                switch (_g.label) {
+                    case 0:
+                        _a = options !== null && options !== void 0 ? options : {}, _b = _a.preserveFormatting, preserveFormatting = _b === void 0 ? true : _b, _c = _a.replaceSheetData, replaceSheetData = _c === void 0 ? false : _c, optionsEnabledSharedStrings = _a.enabledSharedStrings, optionsEnableCellXfsRegistry = _a.enableCellXfsRegistry;
+                        shouldUseSharedStrings = !!sharedStringRegistry &&
+                            ((_e = optionsEnabledSharedStrings !== null && optionsEnabledSharedStrings !== void 0 ? optionsEnabledSharedStrings : enabledSharedStrings) !== null && _e !== void 0 ? _e : sharedStringRegistry.active);
+                        shouldUseCellXfsRegistry = (_f = optionsEnableCellXfsRegistry !== null && optionsEnableCellXfsRegistry !== void 0 ? optionsEnableCellXfsRegistry : enableCellXfsRegistry) !== null && _f !== void 0 ? _f : false;
+                        // Show loader
+                        showLoader("Parsing CSV file");
+                        // Import writes rows directly through `onChangeSheetData` (and may
+                        // wipe the sheet entirely when `replaceSheetData` is true). The
+                        // calculator's per-cell invalidation never fires for these
+                        // positions, so any cached range overlapping the imported region
+                        // would stay stale. Clear wholesale — imports are rare and the
+                        // cache repopulates lazily.
+                        clearRangeCache === null || clearRangeCache === void 0 ? void 0 : clearRangeCache();
+                        saveHistory = createHistory();
+                        _d = createCSVImportWorker(file, {
+                            pageSize: 200,
+                            startRowIndex: activeCell.rowIndex,
+                            startColumnIndex: activeCell.columnIndex,
+                            preserveFormatting: preserveFormatting,
+                            locale: locale,
+                            enableSharedStrings: shouldUseSharedStrings,
+                            enableCellXfsRegistry: shouldUseCellXfsRegistry,
+                            enableBackpressure: true,
+                        }), observable = _d.observable, sendMessage = _d.sendMessage;
+                        hasSharedStringChunks = false;
+                        return [4 /*yield*/, new Promise(function (resolve) {
+                                var subscription = null;
+                                subscription = observable.subscribe(function (response) {
+                                    var e_1, _a;
+                                    var _b, _c, _d;
+                                    if (response.responseType === CsvResponseType.PARSE_CSV_SUCCESS) {
+                                        var newRowCount_1 = activeCell.rowIndex + response.totalRows;
+                                        var newColumnCount_1 = activeCell.columnIndex + response.totalColumns;
+                                        onChangeSheets === null || onChangeSheets === void 0 ? void 0 : onChangeSheets(function (prevSheets) {
+                                            var _a = __read(produceWithPatches(prevSheets, function (draft) {
+                                                var _a, _b;
+                                                var sheet = draft.find(function (sheet) { return sheet.sheetId === sheetId; });
+                                                if (sheet) {
+                                                    sheet.rowCount = Math.max((_a = sheet.rowCount) !== null && _a !== void 0 ? _a : DEFAULT_ROW_COUNT, newRowCount_1);
+                                                    sheet.columnCount = Math.max((_b = sheet.columnCount) !== null && _b !== void 0 ? _b : DEFAULT_COLUMN_COUNT, newColumnCount_1);
+                                                }
+                                            }), 3), nextState = _a[0], patches = _a[1], inversePatches = _a[2];
+                                            saveHistory({
+                                                sheets: { patches: patches, inversePatches: inversePatches },
+                                            });
+                                            return nextState;
+                                        });
+                                    }
+                                    if (response.responseType === CsvResponseType.ROW_DATA_CHUNK) {
+                                        var rows_1 = response.rows, rowIndices_1 = response.rowIndices, chunkIndex_1 = response.chunkIndex, totalRows = response.totalRows, sharedStringsChunk_1 = response.sharedStringsChunk, sharedStringsStartIndex_1 = response.sharedStringsStartIndex, cellXfsChunk_1 = response.cellXfsChunk;
+                                        var recalcCells_1 = new Map();
+                                        for (var i = 0; i < rowIndices_1.length; i++) {
+                                            var rowIndex = rowIndices_1[i];
+                                            var rowValues = (_c = (_b = rows_1[i]) === null || _b === void 0 ? void 0 : _b.values) !== null && _c !== void 0 ? _c : [];
+                                            for (var columnIndex = 0; columnIndex < rowValues.length; columnIndex++) {
+                                                var cell = rowValues[columnIndex];
+                                                if (isNil(cell)) {
+                                                    continue;
+                                                }
+                                                if (getExtendedValueFormula(getCellUserEnteredValue(cell)) &&
+                                                    enqueueCalculation) {
+                                                    enqueueCalculation({
+                                                        position: { rowIndex: rowIndex, columnIndex: columnIndex, sheetId: sheetId },
+                                                        type: "add",
+                                                    });
+                                                    recalcCells_1.set(createSheetCellIdentifier(sheetId, rowIndex, columnIndex), {
+                                                        rowIndex: rowIndex,
+                                                        columnIndex: columnIndex,
+                                                        sheetId: sheetId,
+                                                    });
+                                                    continue;
+                                                }
+                                                if (getDependents &&
+                                                    enqueueCalculation &&
+                                                    getDependents({ rowIndex: rowIndex, columnIndex: columnIndex, sheetId: sheetId }).length) {
+                                                    enqueueCalculation({
+                                                        position: { rowIndex: rowIndex, columnIndex: columnIndex, sheetId: sheetId },
+                                                        type: "add",
+                                                    });
+                                                    recalcCells_1.set(createSheetCellIdentifier(sheetId, rowIndex, columnIndex), {
+                                                        rowIndex: rowIndex,
+                                                        columnIndex: columnIndex,
+                                                        sheetId: sheetId,
+                                                    });
+                                                }
+                                            }
+                                        }
+                                        onChangeSheetData === null || onChangeSheetData === void 0 ? void 0 : onChangeSheetData(function (prevSheetData) {
+                                            var _a = __read(produceWithPatches(prevSheetData, function (draft) {
+                                                var e_2, _a;
+                                                var _b, _c, _d;
+                                                if (replaceSheetData && chunkIndex_1 === 0) {
+                                                    draft[sheetId] = [];
+                                                }
+                                                if (!draft[sheetId]) {
+                                                    draft[sheetId] = [];
+                                                }
+                                                for (var i = 0; i < rowIndices_1.length; i++) {
+                                                    var rowIndex = rowIndices_1[i];
+                                                    var nextRow = rows_1[i];
+                                                    var nextValues = (_b = nextRow === null || nextRow === void 0 ? void 0 : nextRow.values) !== null && _b !== void 0 ? _b : [];
+                                                    var existingRow = (_c = draft[sheetId][rowIndex]) !== null && _c !== void 0 ? _c : {};
+                                                    var existingValues = (_d = existingRow.values) !== null && _d !== void 0 ? _d : [];
+                                                    var mergedValues = existingValues.slice();
+                                                    try {
+                                                        for (var _e = (e_2 = void 0, __values(Object.keys(nextValues))), _f = _e.next(); !_f.done; _f = _e.next()) {
+                                                            var key = _f.value;
+                                                            var columnIndex = Number(key);
+                                                            mergedValues[columnIndex] = nextValues[columnIndex];
+                                                        }
+                                                    }
+                                                    catch (e_2_1) { e_2 = { error: e_2_1 }; }
+                                                    finally {
+                                                        try {
+                                                            if (_f && !_f.done && (_a = _e.return)) _a.call(_e);
+                                                        }
+                                                        finally { if (e_2) throw e_2.error; }
+                                                    }
+                                                    existingRow.values = mergedValues;
+                                                    draft[sheetId][rowIndex] = existingRow;
+                                                }
+                                            }), 3), nextState = _a[0], patches = _a[1], inversePatches = _a[2];
+                                            saveHistory({
+                                                sheetData: {
+                                                    patches: patches,
+                                                    inversePatches: inversePatches,
+                                                },
+                                                recalcCells: { undo: recalcCells_1, redo: recalcCells_1 },
+                                            });
+                                            return nextState;
+                                        });
+                                        if (shouldUseCellXfsRegistry && (cellXfsChunk_1 === null || cellXfsChunk_1 === void 0 ? void 0 : cellXfsChunk_1.length)) {
+                                            onChangeCellXfs === null || onChangeCellXfs === void 0 ? void 0 : onChangeCellXfs(function (prev) {
+                                                var base = prev !== null && prev !== void 0 ? prev : new Map();
+                                                var _a = __read(produceWithPatches(base, function (draft) {
+                                                    var e_3, _a;
+                                                    try {
+                                                        for (var cellXfsChunk_2 = __values(cellXfsChunk_1), cellXfsChunk_2_1 = cellXfsChunk_2.next(); !cellXfsChunk_2_1.done; cellXfsChunk_2_1 = cellXfsChunk_2.next()) {
+                                                            var _b = __read(cellXfsChunk_2_1.value, 2), key = _b[0], value = _b[1];
+                                                            draft.set(key, value);
+                                                        }
+                                                    }
+                                                    catch (e_3_1) { e_3 = { error: e_3_1 }; }
+                                                    finally {
+                                                        try {
+                                                            if (cellXfsChunk_2_1 && !cellXfsChunk_2_1.done && (_a = cellXfsChunk_2.return)) _a.call(cellXfsChunk_2);
+                                                        }
+                                                        finally { if (e_3) throw e_3.error; }
+                                                    }
+                                                }), 3), nextState = _a[0], patches = _a[1], inversePatches = _a[2];
+                                                if (patches.length) {
+                                                    saveHistory({
+                                                        cellXfs: { patches: patches, inversePatches: inversePatches },
+                                                    });
+                                                }
+                                                return nextState;
+                                            });
+                                        }
+                                        if (shouldUseSharedStrings &&
+                                            onChangeSharedStrings &&
+                                            (sharedStringsChunk_1 === null || sharedStringsChunk_1 === void 0 ? void 0 : sharedStringsChunk_1.length)) {
+                                            hasSharedStringChunks = true;
+                                            onChangeSharedStrings(function (prev) {
+                                                var base = prev !== null && prev !== void 0 ? prev : new Map();
+                                                var _a = __read(produceWithPatches(base, function (draft) {
+                                                    var e_4, _a;
+                                                    var isTuple = Array.isArray(sharedStringsChunk_1[0]);
+                                                    if (isTuple) {
+                                                        try {
+                                                            // New worker shape: cells already reference these ids.
+                                                            // Merge entries; existing keys with matching values stay.
+                                                            for (var _b = __values(sharedStringsChunk_1), _c = _b.next(); !_c.done; _c = _b.next()) {
+                                                                var entry = _c.value;
+                                                                var _d = __read(entry, 2), id = _d[0], value = _d[1];
+                                                                if (draft.get(id) !== value) {
+                                                                    draft.set(id, value);
+                                                                }
+                                                            }
+                                                        }
+                                                        catch (e_4_1) { e_4 = { error: e_4_1 }; }
+                                                        finally {
+                                                            try {
+                                                                if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+                                                            }
+                                                            finally { if (e_4) throw e_4.error; }
+                                                        }
+                                                    }
+                                                    else {
+                                                        // Legacy worker shape: numeric ids assigned by position.
+                                                        // Cells reference `startIndex + i`. Preserve to avoid
+                                                        // breaking older workers / serialized chunks.
+                                                        var startIndex = sharedStringsStartIndex_1 !== null && sharedStringsStartIndex_1 !== void 0 ? sharedStringsStartIndex_1 : draft.size;
+                                                        for (var i = 0; i < sharedStringsChunk_1.length; i++) {
+                                                            draft.set(String(startIndex + i), sharedStringsChunk_1[i]);
+                                                        }
+                                                    }
+                                                }), 3), nextState = _a[0], patches = _a[1], inversePatches = _a[2];
+                                                saveHistory({
+                                                    sharedStrings: { patches: patches, inversePatches: inversePatches },
+                                                });
+                                                return nextState;
+                                            });
+                                        }
+                                        if (totalRows > 0) {
+                                            var currentRow = (_d = rowIndices_1[rowIndices_1.length - 1]) !== null && _d !== void 0 ? _d : 0;
+                                            var relativeRow = currentRow - activeCell.rowIndex + 1;
+                                            var displayRow = Math.min(relativeRow, totalRows);
+                                            showLoader("Processing CSV: Row ".concat(displayRow, "/").concat(totalRows));
+                                        }
+                                        sendMessage({
+                                            requestType: CsvRequestType.ACK_ROW_DATA,
+                                            chunkIndex: chunkIndex_1,
+                                        });
+                                    }
+                                    if (response.responseType === CsvResponseType.CELL_XFS) {
+                                        if (shouldUseCellXfsRegistry) {
+                                            onChangeCellXfs === null || onChangeCellXfs === void 0 ? void 0 : onChangeCellXfs(function (prev) {
+                                                var base = prev !== null && prev !== void 0 ? prev : new Map();
+                                                var _a = __read(produceWithPatches(base, function (draft) {
+                                                    var _a, _b;
+                                                    if (replaceSheetData) {
+                                                        draft.clear();
+                                                    }
+                                                    (_b = (_a = response.cellXfs) === null || _a === void 0 ? void 0 : _a.forEach) === null || _b === void 0 ? void 0 : _b.call(_a, function (value, key) {
+                                                        draft.set(key, value);
+                                                    });
+                                                }), 3), nextState = _a[0], patches = _a[1], inversePatches = _a[2];
+                                                if (patches.length) {
+                                                    saveHistory({
+                                                        cellXfs: { patches: patches, inversePatches: inversePatches },
+                                                    });
+                                                }
+                                                return nextState;
+                                            });
+                                        }
+                                    }
+                                    if (response.responseType ===
+                                        CsvResponseType.GET_SHARED_STRINGS_SUCCESS &&
+                                        shouldUseSharedStrings &&
+                                        onChangeSharedStrings &&
+                                        !hasSharedStringChunks &&
+                                        response.sharedStrings.length) {
+                                        // Accept both the new [id, value][] shape and the legacy string[]
+                                        // shape (where the id is the array index).
+                                        var newMap_1 = new Map();
+                                        var entries = response.sharedStrings;
+                                        if (Array.isArray(entries[0])) {
+                                            try {
+                                                for (var _e = __values(entries), _f = _e.next(); !_f.done; _f = _e.next()) {
+                                                    var _g = __read(_f.value, 2), id = _g[0], value = _g[1];
+                                                    newMap_1.set(id, value);
+                                                }
+                                            }
+                                            catch (e_1_1) { e_1 = { error: e_1_1 }; }
+                                            finally {
+                                                try {
+                                                    if (_f && !_f.done && (_a = _e.return)) _a.call(_e);
+                                                }
+                                                finally { if (e_1) throw e_1.error; }
+                                            }
+                                        }
+                                        else {
+                                            entries.forEach(function (value, index) {
+                                                newMap_1.set(String(index), value);
+                                            });
+                                        }
+                                        onChangeSharedStrings(newMap_1);
+                                    }
+                                    if (response.responseType === CsvResponseType.ERROR) {
+                                        hideLoader();
+                                        subscription === null || subscription === void 0 ? void 0 : subscription.unsubscribe();
+                                        resolve();
+                                    }
+                                    if (response.responseType === CsvResponseType.PARSE_CSV_COMPLETE) {
+                                        hideLoader();
+                                        subscription === null || subscription === void 0 ? void 0 : subscription.unsubscribe();
+                                        resolve();
+                                    }
+                                });
+                            })];
+                    case 1:
+                        _g.sent();
+                        return [2 /*return*/];
+                }
+            });
+        });
+    }, [
+        createHistory,
+        onChangeSheetData,
+        onChangeSheets,
+        onChangeSharedStrings,
+        onChangeCellXfs,
+        hideLoader,
+        showLoader,
+        locale,
+        currentActiveCell,
+        activeSheetId,
+        sharedStringRegistry,
+        enabledSharedStrings,
+        enqueueCalculation,
+        clearRangeCache,
+        getDependents,
+        enableCellXfsRegistry,
+    ]);
+    return {
+        importCSVFile: importCSVFile,
+    };
+};

package/dist/cjs/hooks/use-on-import-excel.d.ts

@@ -0,0 +1,67 @@
+import type { IterativeCalculationOptions } from "@rowsncolumns/common-types";
+import type { CellData, Sheet } from "@rowsncolumns/spreadsheet";
+import type { useCalculation } from "./use-calculation";
+import type { useCalculationInitialize } from "./use-calculation-initialize";
+import type { useDataValidationRules } from "./use-data-validation-rules";
+import { type UseSpreadsheetProps } from "./use-spreadsheet-state";
+import type { SpreadsheetPatch } from "./use-undo-redo";
+export type UseOnImportExcelFileProps<T extends CellData, S extends Sheet> = {
+    onClearHistory(): void;
+    enableExcelImportHistory?: boolean;
+    onChangeHistory: UseSpreadsheetProps["onChangeHistory"];
+    onChangeSheetData: UseSpreadsheetProps<T, S>["onChangeSheetData"];
+    onChangeTables: UseSpreadsheetProps<T, S>["onChangeTables"];
+    onChangeSharedStrings: UseSpreadsheetProps<T, S>["onChangeSharedStrings"];
+    onChangeCharts: UseSpreadsheetProps<T, S>["onChangeCharts"];
+    onChangeSheets: UseSpreadsheetProps<T, S>["onChangeSheets"];
+    onChangeEmbeds?: UseSpreadsheetProps<T, S>["onChangeEmbeds"];
+    onChangeNamedRanges?: UseSpreadsheetProps<T, S>["onChangeNamedRanges"];
+    onChangeCellXfs?: UseSpreadsheetProps<T, S>["onChangeCellXfs"];
+    onRequestFonts: UseSpreadsheetProps<T, S>["onRequestFonts"];
+    onChangeTheme: UseSpreadsheetProps<T, S>["onChangeTheme"];
+    onChangeSlicers: UseSpreadsheetProps<T, S>["onChangeSlicers"];
+    /**
+     * Phase D1 — pivot table import. Worker emits
+     * GET_PIVOT_TABLES_SUCCESS with the parsed PivotTable[]; the
+     * host writes them into its `pivotTables` state via this
+     * setter. Omit to discard imported pivots.
+     */
+    onChangePivotTables?: UseSpreadsheetProps<T, S>["onChangePivotTables"];
+    onCreateDataValidationRule: ReturnType<typeof useDataValidationRules>["onCreateDataValidationRule"];
+    onChangeDataValidations?: UseSpreadsheetProps<T, S>["onChangeDataValidations"];
+    onChangeConditionalFormats?: UseSpreadsheetProps<T, S>["onChangeConditionalFormats"];
+    evaluateConditionalFormatting?: ReturnType<typeof useCalculationInitialize>["evaluateConditionalFormatting"];
+    evaluateDataValidations?: ReturnType<typeof useCalculationInitialize>["evaluateDataValidations"];
+    clearRangeCache?: ReturnType<typeof useCalculation>["clearRangeCache"];
+    onConfirm?: UseSpreadsheetProps["onConfirm"];
+    onPrompt?: UseSpreadsheetProps["onPrompt"];
+};
+export type ExcelImportResponse = {
+    requiresRecalc?: boolean;
+    iterativeCalculationOptions?: IterativeCalculationOptions;
+    use1904?: boolean;
+    success: boolean;
+    isPasswordProtected?: boolean;
+};
+export type ExcelImportOptions = {
+    minRowCount?: number;
+    minColumnCount?: number;
+    enableCellXfsRegistry?: boolean;
+    enabledSharedStrings?: boolean;
+    enableBackpressure?: boolean;
+    password?: string;
+    /**
+     * Custom confirm dialog function
+     */
+    confirm?: UseSpreadsheetProps["onConfirm"];
+    /**
+     * Custom prompt dialog function
+     */
+    prompt?: UseSpreadsheetProps["onPrompt"];
+};
+export declare const useOnImportExcelFile: <T extends CellData, S extends Sheet>({ enableExcelImportHistory, onChangeSheetData, onChangeSheets, onChangeTables, onChangeEmbeds, onChangeNamedRanges, onChangeSharedStrings, onChangeConditionalFormats, onChangeDataValidations, onChangeCellXfs, onChangeCharts, onRequestFonts, onChangeTheme, onCreateDataValidationRule, onClearHistory, onChangeHistory, onChangeSlicers, onChangePivotTables, evaluateConditionalFormatting, evaluateDataValidations, clearRangeCache, onConfirm, onPrompt, }: UseOnImportExcelFileProps<T, S>) => {
+    importExcelFile: (file: File | ArrayBuffer, options?: ExcelImportOptions) => Promise<ExcelImportResponse>;
+    isImportingExcelfile: boolean;
+    generateStatePatches: () => Promise<SpreadsheetPatch>;
+};
+//# sourceMappingURL=use-on-import-excel.d.ts.map

package/dist/cjs/hooks/use-on-import-excel.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-on-import-excel.d.ts","sourceRoot":"","sources":["../../../hooks/use-on-import-excel.ts"],"names":[],"mappings":"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"}