@rowsncolumns/spreadsheet-state 28.0.66

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

@@ -0,0 +1,689 @@
+import { __awaiter, __generator, __read, __rest, __values } from "tslib";
+import { DEFAULT_COLUMN_COUNT, DEFAULT_ROW_COUNT, loadWebFont, scheduleNormalPriorityCallback, useCallbackRef, useGetViewPort, useLoadingIndicator, } from "@rowsncolumns/spreadsheet";
+import { createExcelImportWorker, RequestType, ResponseType, } from "@rowsncolumns/toolkit";
+import { useModal } from "@rowsncolumns/ui";
+import { produce, produceWithPatches } from "immer";
+import { useCallback, useState } from "react";
+import { SheetCell } from "../sheet-cell";
+var TIMEOUT_FONT_LOAD = 5000;
+export var useOnImportExcelFile = function (_a) {
+    var _b = _a.enableExcelImportHistory, enableExcelImportHistory = _b === void 0 ? false : _b, onChangeSheetData = _a.onChangeSheetData, onChangeSheets = _a.onChangeSheets, onChangeTables = _a.onChangeTables, onChangeEmbeds = _a.onChangeEmbeds, onChangeNamedRanges = _a.onChangeNamedRanges, onChangeSharedStrings = _a.onChangeSharedStrings, onChangeConditionalFormats = _a.onChangeConditionalFormats, onChangeDataValidations = _a.onChangeDataValidations, onChangeCellXfs = _a.onChangeCellXfs, onChangeCharts = _a.onChangeCharts, onRequestFonts = _a.onRequestFonts, onChangeTheme = _a.onChangeTheme, onCreateDataValidationRule = _a.onCreateDataValidationRule, onClearHistory = _a.onClearHistory, onChangeHistory = _a.onChangeHistory, onChangeSlicers = _a.onChangeSlicers, onChangePivotTables = _a.onChangePivotTables, evaluateConditionalFormatting = _a.evaluateConditionalFormatting, evaluateDataValidations = _a.evaluateDataValidations, clearRangeCache = _a.clearRangeCache, onConfirm = _a.onConfirm, onPrompt = _a.onPrompt;
+    var _c = __read(useState(false), 2), isImportingExcelfile = _c[0], setIsImporting = _c[1];
+    var _d = __read(useLoadingIndicator(), 2), showLoader = _d[0], hideLoader = _d[1];
+    var getViewPort = useGetViewPort();
+    var _e = useModal(), defaultConfirm = _e.confirm, defaultPrompt = _e.prompt;
+    // Use provided functions or fall back to defaults
+    var confirm = onConfirm !== null && onConfirm !== void 0 ? onConfirm : defaultConfirm;
+    var prompt = onPrompt !== null && onPrompt !== void 0 ? onPrompt : defaultPrompt;
+    // Create patches
+    var generateStatePatches = useCallbackRef(useCallback(function () { return __awaiter(void 0, void 0, void 0, function () {
+        var spreadsheetPatch, promises;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    spreadsheetPatch = {};
+                    promises = [];
+                    // Update state
+                    if (onChangeSheetData) {
+                        promises.push(new Promise(function (resolve) {
+                            onChangeSheetData === null || onChangeSheetData === void 0 ? void 0 : onChangeSheetData(function (prev) {
+                                var _a = __read(produceWithPatches({}, function () {
+                                    return prev;
+                                }), 3), _ = _a[0], patches = _a[1], inversePatches = _a[2];
+                                spreadsheetPatch.sheetData = { patches: patches, inversePatches: inversePatches };
+                                resolve();
+                                return prev;
+                            });
+                        }));
+                    }
+                    // onChangeSheets
+                    if (onChangeSheets) {
+                        promises.push(new Promise(function (resolve) {
+                            onChangeSheets === null || onChangeSheets === void 0 ? void 0 : onChangeSheets(function (prev) {
+                                var _a = __read(produceWithPatches([], function () {
+                                    return prev;
+                                }), 3), _ = _a[0], patches = _a[1], inversePatches = _a[2];
+                                spreadsheetPatch.sheets = { patches: patches, inversePatches: inversePatches };
+                                resolve();
+                                return prev;
+                            });
+                        }));
+                    }
+                    // onChangeTables
+                    if (onChangeTables) {
+                        promises.push(new Promise(function (resolve) {
+                            onChangeTables === null || onChangeTables === void 0 ? void 0 : onChangeTables(function (prev) {
+                                var _a = __read(produceWithPatches([], function () {
+                                    return prev;
+                                }), 3), _ = _a[0], patches = _a[1], inversePatches = _a[2];
+                                spreadsheetPatch.tables = { patches: patches, inversePatches: inversePatches };
+                                resolve();
+                                return prev;
+                            });
+                        }));
+                    }
+                    // onChangeCharts
+                    if (onChangeCharts) {
+                        promises.push(new Promise(function (resolve) {
+                            onChangeCharts === null || onChangeCharts === void 0 ? void 0 : onChangeCharts(function (prev) {
+                                var _a = __read(produceWithPatches([], function () {
+                                    return prev;
+                                }), 3), _ = _a[0], patches = _a[1], inversePatches = _a[2];
+                                spreadsheetPatch.charts = { patches: patches, inversePatches: inversePatches };
+                                resolve();
+                                return prev;
+                            });
+                        }));
+                    }
+                    // onChangeEmbeds
+                    if (onChangeEmbeds) {
+                        promises.push(new Promise(function (resolve) {
+                            onChangeEmbeds === null || onChangeEmbeds === void 0 ? void 0 : onChangeEmbeds(function (prev) {
+                                var _a = __read(produceWithPatches([], function () {
+                                    return prev;
+                                }), 3), _ = _a[0], patches = _a[1], inversePatches = _a[2];
+                                spreadsheetPatch.embeds = { patches: patches, inversePatches: inversePatches };
+                                resolve();
+                                return prev;
+                            });
+                        }));
+                    }
+                    // onChangeNamedRanges
+                    if (onChangeNamedRanges) {
+                        promises.push(new Promise(function (resolve) {
+                            onChangeNamedRanges === null || onChangeNamedRanges === void 0 ? void 0 : onChangeNamedRanges(function (prev) {
+                                var _a = __read(produceWithPatches([], function () {
+                                    return prev;
+                                }), 3), _ = _a[0], patches = _a[1], inversePatches = _a[2];
+                                spreadsheetPatch.namedRanges = { patches: patches, inversePatches: inversePatches };
+                                resolve();
+                                return prev;
+                            });
+                        }));
+                    }
+                    // onChangeDataValidations
+                    if (onChangeDataValidations) {
+                        promises.push(new Promise(function (resolve) {
+                            onChangeDataValidations === null || onChangeDataValidations === void 0 ? void 0 : onChangeDataValidations(function (prev) {
+                                var _a = __read(produceWithPatches([], function () {
+                                    return prev;
+                                }), 3), _ = _a[0], patches = _a[1], inversePatches = _a[2];
+                                spreadsheetPatch.dataValidations = { patches: patches, inversePatches: inversePatches };
+                                resolve();
+                                return prev;
+                            });
+                        }));
+                    }
+                    // onChangeConditionalFormats
+                    if (onChangeConditionalFormats) {
+                        promises.push(new Promise(function (resolve) {
+                            onChangeConditionalFormats === null || onChangeConditionalFormats === void 0 ? void 0 : onChangeConditionalFormats(function (prev) {
+                                var _a = __read(produceWithPatches([], function () {
+                                    return prev;
+                                }), 3), _ = _a[0], patches = _a[1], inversePatches = _a[2];
+                                spreadsheetPatch.conditionalFormats = { patches: patches, inversePatches: inversePatches };
+                                resolve();
+                                return prev;
+                            });
+                        }));
+                    }
+                    // onChangeCellXfs
+                    if (onChangeCellXfs) {
+                        promises.push(new Promise(function (resolve) {
+                            onChangeCellXfs === null || onChangeCellXfs === void 0 ? void 0 : onChangeCellXfs(function (prev) {
+                                var _a = __read(produceWithPatches([], function () {
+                                    return prev;
+                                }), 3), _ = _a[0], patches = _a[1], inversePatches = _a[2];
+                                spreadsheetPatch.cellXfs = { patches: patches, inversePatches: inversePatches };
+                                resolve();
+                                return prev;
+                            });
+                        }));
+                    }
+                    // onChangeSharedStrings
+                    if (onChangeSharedStrings) {
+                        promises.push(new Promise(function (resolve) {
+                            onChangeSharedStrings === null || onChangeSharedStrings === void 0 ? void 0 : onChangeSharedStrings(function (prev) {
+                                var _a = __read(produceWithPatches(new Map(), function () {
+                                    return prev;
+                                }), 3), _ = _a[0], patches = _a[1], inversePatches = _a[2];
+                                spreadsheetPatch.sharedStrings = { patches: patches, inversePatches: inversePatches };
+                                resolve();
+                                return prev;
+                            });
+                        }));
+                    }
+                    // onChangeSlicers
+                    if (onChangeSlicers) {
+                        promises.push(new Promise(function (resolve) {
+                            onChangeSlicers === null || onChangeSlicers === void 0 ? void 0 : onChangeSlicers(function (prev) {
+                                var _a = __read(produceWithPatches([], function () {
+                                    return prev;
+                                }), 3), _ = _a[0], patches = _a[1], inversePatches = _a[2];
+                                spreadsheetPatch.slicers = { patches: patches, inversePatches: inversePatches };
+                                resolve();
+                                return prev;
+                            });
+                        }));
+                    }
+                    // Wait for all callbacks to complete
+                    return [4 /*yield*/, Promise.all(promises)];
+                case 1:
+                    // Wait for all callbacks to complete
+                    _a.sent();
+                    return [2 /*return*/, spreadsheetPatch];
+            }
+        });
+    }); }, [
+        onChangeSheetData,
+        onChangeSheets,
+        onChangeCellXfs,
+        onChangeTables,
+        onChangeEmbeds,
+        onChangeNamedRanges,
+        onChangeConditionalFormats,
+        onChangeDataValidations,
+        onChangeCharts,
+        onChangeSharedStrings,
+        onChangeSlicers,
+    ]));
+    var getImportLabel = function (file) {
+        var _a, _b;
+        if (!(file instanceof File)) {
+            return "excel";
+        }
+        var type = file.type.toLowerCase();
+        var name = (_b = (_a = file.name) === null || _a === void 0 ? void 0 : _a.toLowerCase()) !== null && _b !== void 0 ? _b : "";
+        if (type.includes("spreadsheetml.sheet") || name.endsWith(".xlsx")) {
+            return "XLSX";
+        }
+        if (type.includes("sheet.binary.macroenabled.12") ||
+            name.endsWith(".xlsb")) {
+            return "XLSB";
+        }
+        if (type.includes("sheet.macroenabled.12") || name.endsWith(".xlsm")) {
+            return "XLSM";
+        }
+        if (type.includes("opendocument.spreadsheet") || name.endsWith(".ods")) {
+            return "ODS";
+        }
+        return "excel";
+    };
+    // Import excel file
+    var importExcelFile = useCallbackRef(useCallback(function (file, options) { return __awaiter(void 0, void 0, void 0, function () {
+        var pageSize, minRowCount, minColumnCount, enableCellXfsRegistry, enableSharedStrings, enableBackpressure, providedPassword, confirmFn, promptFn, dataValidations, conditionalFormats, confirmation;
+        var _a, _b, _c, _d, _e, _f, _g;
+        return __generator(this, function (_h) {
+            switch (_h.label) {
+                case 0:
+                    pageSize = 100;
+                    minRowCount = (_a = options === null || options === void 0 ? void 0 : options.minRowCount) !== null && _a !== void 0 ? _a : DEFAULT_ROW_COUNT;
+                    minColumnCount = (_b = options === null || options === void 0 ? void 0 : options.minColumnCount) !== null && _b !== void 0 ? _b : DEFAULT_COLUMN_COUNT;
+                    enableCellXfsRegistry = (_c = options === null || options === void 0 ? void 0 : options.enableCellXfsRegistry) !== null && _c !== void 0 ? _c : true;
+                    enableSharedStrings = (_d = options === null || options === void 0 ? void 0 : options.enabledSharedStrings) !== null && _d !== void 0 ? _d : !!onChangeSharedStrings;
+                    enableBackpressure = (_e = options === null || options === void 0 ? void 0 : options.enableBackpressure) !== null && _e !== void 0 ? _e : true;
+                    providedPassword = options === null || options === void 0 ? void 0 : options.password;
+                    confirmFn = (_f = options === null || options === void 0 ? void 0 : options.confirm) !== null && _f !== void 0 ? _f : confirm;
+                    promptFn = (_g = options === null || options === void 0 ? void 0 : options.prompt) !== null && _g !== void 0 ? _g : prompt;
+                    dataValidations = [];
+                    conditionalFormats = [];
+                    if (!enableExcelImportHistory) return [3 /*break*/, 2];
+                    return [4 /*yield*/, confirmFn("This will delete all your current data. You won't be able to undo this or recover your previous work.", {
+                            title: "Are you sure you want to replace your spreadsheet?",
+                        })];
+                case 1:
+                    confirmation = _h.sent();
+                    if (!confirmation) {
+                        return [2 /*return*/, {
+                                success: false,
+                            }];
+                    }
+                    _h.label = 2;
+                case 2: return [2 /*return*/, new Promise(function (resolve) {
+                        var viewPort = getViewPort === null || getViewPort === void 0 ? void 0 : getViewPort();
+                        var defaultPageSize = viewPort
+                            ? viewPort.visibleRowStopIndex - viewPort.visibleRowStartIndex
+                            : pageSize;
+                        var _a = createExcelImportWorker(file, minRowCount, minColumnCount), observable = _a.observable, sendMessage = _a.sendMessage;
+                        var requiresRecalc = false;
+                        var iterativeCalculationOptions;
+                        var use1904 = false;
+                        var isPromptingForPassword = false;
+                        var isPasswordProtected = false;
+                        // Set import
+                        setIsImporting(true);
+                        // Loader
+                        var label = getImportLabel(file);
+                        var isOdsImport = label === "ODS";
+                        showLoader("Parsing ".concat(label, " file"));
+                        // Clear history
+                        onClearHistory();
+                        // Excel import streams entire sheets through `onChangeSheetData`
+                        // directly, so the calculator's per-cell invalidation never runs
+                        // for the imported positions. Wipe the range cache up front;
+                        // it repopulates lazily as formulas re-evaluate.
+                        clearRangeCache === null || clearRangeCache === void 0 ? void 0 : clearRangeCache();
+                        // // Load sheet
+                        var subscription = observable.subscribe(function (response) { return __awaiter(void 0, void 0, void 0, function () {
+                            var password, fonts, fontFamiliesWithWeights, err_1, err_2, sheetId_1, chunkIndex_1, rowIndices_1, rows_1, cellXfs, title, totalSheets, currentSheetIndex_1, totalRows, sharedStringsChunk_1, sharedStringsStartIndex_1, currentRow, totalRowCount, displayRow, totalRowsLabel, newMap_1, entries, _a, _b, _c, id, value, _d, _e, rule, embeds, images_1, _f, _g, _h, isInsideCell, drawing, patches;
+                            var e_1, _j, e_2, _k, e_3, _l;
+                            var _m, _o, _p, _q;
+                            return __generator(this, function (_r) {
+                                switch (_r.label) {
+                                    case 0:
+                                        if (!(response.responseType === ResponseType.PASSWORD_REQUIRED)) return [3 /*break*/, 2];
+                                        // If password was provided in options, use it directly
+                                        if (providedPassword) {
+                                            isPasswordProtected = true;
+                                            showLoader("Decrypting file...");
+                                            sendMessage({
+                                                requestType: RequestType.PROVIDE_PASSWORD,
+                                                password: providedPassword,
+                                            });
+                                            return [2 /*return*/];
+                                        }
+                                        // Prevent multiple password prompts
+                                        if (isPromptingForPassword) {
+                                            return [2 /*return*/];
+                                        }
+                                        isPromptingForPassword = true;
+                                        hideLoader();
+                                        return [4 /*yield*/, promptFn(response.message ||
+                                                "This file is password protected. Please enter the password:", {
+                                                title: "Password Required",
+                                                inputType: "password",
+                                                placeholder: "Enter password",
+                                                confirmText: "Open",
+                                                cancelText: "Cancel",
+                                            })];
+                                    case 1:
+                                        password = _r.sent();
+                                        isPromptingForPassword = false;
+                                        if (password) {
+                                            isPasswordProtected = true;
+                                            showLoader("Decrypting file...");
+                                            sendMessage({
+                                                requestType: RequestType.PROVIDE_PASSWORD,
+                                                password: password,
+                                            });
+                                        }
+                                        else {
+                                            // User cancelled
+                                            subscription.unsubscribe();
+                                            setIsImporting(false);
+                                            resolve({ success: false });
+                                        }
+                                        return [2 /*return*/];
+                                    case 2:
+                                        if (!(response.responseType === ResponseType.ERROR)) return [3 /*break*/, 4];
+                                        hideLoader();
+                                        setIsImporting(false);
+                                        subscription.unsubscribe();
+                                        return [4 /*yield*/, confirmFn(response.error || "Failed to import file. Please try again.", {
+                                                title: "Import Error",
+                                                confirmText: "OK",
+                                                cancelText: "",
+                                            })];
+                                    case 3:
+                                        _r.sent();
+                                        resolve({ success: false });
+                                        return [2 /*return*/];
+                                    case 4:
+                                        if (!(response.responseType === ResponseType.GET_FONTS_SUCCESS)) return [3 /*break*/, 14];
+                                        fonts = response.fonts;
+                                        fontFamiliesWithWeights = response.fonts
+                                            .map(function (family) { return ["".concat(family, ":400"), "".concat(family, ":700")]; })
+                                            .flat();
+                                        _r.label = 5;
+                                    case 5:
+                                        _r.trys.push([5, 13, , 14]);
+                                        // Fonts loader
+                                        showLoader("Loading ".concat(fonts.length, " fonts..."));
+                                        _r.label = 6;
+                                    case 6:
+                                        _r.trys.push([6, 11, , 12]);
+                                        if (!onRequestFonts) return [3 /*break*/, 8];
+                                        return [4 /*yield*/, onRequestFonts(response.fonts)];
+                                    case 7:
+                                        _r.sent();
+                                        return [3 /*break*/, 10];
+                                    case 8: return [4 /*yield*/, Promise.race([
+                                            loadWebFont(fontFamiliesWithWeights),
+                                            new Promise(function (_, reject) {
+                                                return setTimeout(function () { return reject(new Error("Font loading timed out")); }, TIMEOUT_FONT_LOAD);
+                                            }),
+                                        ])];
+                                    case 9:
+                                        _r.sent();
+                                        _r.label = 10;
+                                    case 10: return [3 /*break*/, 12];
+                                    case 11:
+                                        err_1 = _r.sent();
+                                        console.log("Error loading fonts");
+                                        return [3 /*break*/, 12];
+                                    case 12:
+                                        showLoader("Loading sheet data...");
+                                        // Request sheet data
+                                        sendMessage({
+                                            requestType: RequestType.GET_SHEET_DATA,
+                                            pageSize: pageSize !== null && pageSize !== void 0 ? pageSize : defaultPageSize,
+                                            enableCellXfsRegistry: enableCellXfsRegistry,
+                                            enableSharedStrings: enableSharedStrings,
+                                            enableBackpressure: enableBackpressure,
+                                        });
+                                        return [3 /*break*/, 14];
+                                    case 13:
+                                        err_2 = _r.sent();
+                                        console.log("Error loading fonts", err_2, fonts);
+                                        return [3 /*break*/, 14];
+                                    case 14:
+                                        if (response.responseType === ResponseType.PARSE_EXCEL_SUCCESS) {
+                                            requiresRecalc = (_m = response.requiresRecalc) !== null && _m !== void 0 ? _m : false;
+                                            iterativeCalculationOptions =
+                                                (_o = response.iterativeCalculationOptions) !== null && _o !== void 0 ? _o : undefined;
+                                            use1904 = (_p = response.use1904) !== null && _p !== void 0 ? _p : false;
+                                        }
+                                        if (response.responseType === ResponseType.GET_SHEETS_SUCCESS) {
+                                            onChangeSheets(response.sheets);
+                                        }
+                                        if (response.responseType === ResponseType.BEGIN_GET_SHEETS) {
+                                            showLoader("Loading ".concat(response.totalSheets, " sheets..."));
+                                        }
+                                        if (response.responseType === ResponseType.GET_THEME_SUCCESS) {
+                                            if (response.theme) {
+                                                onChangeTheme === null || onChangeTheme === void 0 ? void 0 : onChangeTheme(response.theme);
+                                            }
+                                        }
+                                        if (response.responseType === ResponseType.GET_CONDITIONAL_FORMATTING) {
+                                            showLoader("Loading conditional formatting");
+                                        }
+                                        if (response.responseType === ResponseType.GET_DATAVALIDATION) {
+                                            showLoader("Loading data validations");
+                                        }
+                                        // Process row data chunk
+                                        if (response.responseType === ResponseType.ROW_DATA_CHUNK) {
+                                            sheetId_1 = response.sheetId, chunkIndex_1 = response.chunkIndex, rowIndices_1 = response.rowIndices, rows_1 = response.rows, cellXfs = response.cellXfs, title = response.title, totalSheets = response.totalSheets, currentSheetIndex_1 = response.currentSheetIndex, totalRows = response.totalRows, sharedStringsChunk_1 = response.sharedStringsChunk, sharedStringsStartIndex_1 = response.sharedStringsStartIndex;
+                                            currentRow = (_q = rowIndices_1[rowIndices_1.length - 1]) !== null && _q !== void 0 ? _q : 0;
+                                            totalRowCount = totalRows >= 0 ? totalRows + 1 : undefined;
+                                            displayRow = totalRowCount
+                                                ? Math.min(currentRow + 1, totalRowCount)
+                                                : currentRow + 1;
+                                            totalRowsLabel = totalRowCount ? "/".concat(totalRowCount) : "";
+                                            showLoader("Processing \"".concat(title, "\" (").concat(currentSheetIndex_1 + 1, "/").concat(totalSheets, "): Row ").concat(displayRow).concat(totalRowsLabel));
+                                            // Update cell formats
+                                            onChangeCellXfs === null || onChangeCellXfs === void 0 ? void 0 : onChangeCellXfs(cellXfs);
+                                            // Update shared strings too
+                                            if (enableSharedStrings &&
+                                                isOdsImport &&
+                                                (sharedStringsChunk_1 === null || sharedStringsChunk_1 === void 0 ? void 0 : sharedStringsChunk_1.length)) {
+                                                onChangeSharedStrings === null || onChangeSharedStrings === void 0 ? void 0 : onChangeSharedStrings(function (prev) {
+                                                    var base = prev !== null && prev !== void 0 ? prev : new Map();
+                                                    return produce(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.
+                                                                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.
+                                                            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]);
+                                                            }
+                                                        }
+                                                    });
+                                                });
+                                            }
+                                            // Update sheets
+                                            onChangeSheetData === null || onChangeSheetData === void 0 ? void 0 : onChangeSheetData(function (prev) {
+                                                if (chunkIndex_1 === 0 && currentSheetIndex_1 === 0) {
+                                                    prev = {};
+                                                }
+                                                if (chunkIndex_1 === 0) {
+                                                    prev[sheetId_1] = [];
+                                                }
+                                                for (var i = 0; i < rowIndices_1.length; i++) {
+                                                    prev[sheetId_1][rowIndices_1[i]] = rows_1[i];
+                                                }
+                                                return prev;
+                                            });
+                                            if (enableBackpressure) {
+                                                sendMessage({
+                                                    requestType: RequestType.ACK_ROW_DATA,
+                                                    sheetId: sheetId_1,
+                                                    chunkIndex: chunkIndex_1,
+                                                });
+                                            }
+                                        }
+                                        if (response.responseType === ResponseType.CELL_XFS) {
+                                            onChangeCellXfs === null || onChangeCellXfs === void 0 ? void 0 : onChangeCellXfs(response.cellXfs);
+                                        }
+                                        if (response.responseType === ResponseType.GET_TABLES_SUCCESS) {
+                                            onChangeTables === null || onChangeTables === void 0 ? void 0 : onChangeTables(response.tables);
+                                        }
+                                        if (response.responseType === ResponseType.GET_NAMEDRANGES_SUCCESS) {
+                                            onChangeNamedRanges === null || onChangeNamedRanges === void 0 ? void 0 : onChangeNamedRanges(response.namedRanges);
+                                        }
+                                        if (enableSharedStrings &&
+                                            response.responseType === ResponseType.GET_SHARED_STRINGS_SUCCESS) {
+                                            newMap_1 = new Map();
+                                            entries = response.sharedStrings;
+                                            if (entries.length && Array.isArray(entries[0])) {
+                                                try {
+                                                    for (_a = __values(entries), _b = _a.next(); !_b.done; _b = _a.next()) {
+                                                        _c = __read(_b.value, 2), id = _c[0], value = _c[1];
+                                                        newMap_1.set(id, value);
+                                                    }
+                                                }
+                                                catch (e_1_1) { e_1 = { error: e_1_1 }; }
+                                                finally {
+                                                    try {
+                                                        if (_b && !_b.done && (_j = _a.return)) _j.call(_a);
+                                                    }
+                                                    finally { if (e_1) throw e_1.error; }
+                                                }
+                                            }
+                                            else {
+                                                entries.forEach(function (value, index) {
+                                                    newMap_1.set(String(index), value);
+                                                });
+                                            }
+                                            onChangeSharedStrings === null || onChangeSharedStrings === void 0 ? void 0 : onChangeSharedStrings(newMap_1);
+                                        }
+                                        if (response.responseType ===
+                                            ResponseType.GET_CONDITIONAL_FORMATTING_SUCCESS) {
+                                            onChangeConditionalFormats === null || onChangeConditionalFormats === void 0 ? void 0 : onChangeConditionalFormats(response.conditionalFormatting);
+                                            // Schedule conditional format evaluation
+                                            conditionalFormats = response.conditionalFormatting;
+                                        }
+                                        if (response.responseType === ResponseType.GET_DATAVALIDATION_SUCCESS) {
+                                            try {
+                                                // Stamp cells with `dv` references but skip the per-cell
+                                                // `enqueueCalculation`. Imported workbooks can attach DV rules
+                                                // to thousands of cells across inactive sheets — letting
+                                                // `updateRule` enqueue each one would pin the calculator with
+                                                // off-viewport work before the user has interacted. The
+                                                // viewport-aware `evaluateDataValidations` call scheduled in
+                                                // PARSE_EXCEL_COMPLETE handles formula evaluation for the
+                                                // active sheet's visible range instead.
+                                                for (_d = __values(response.dataValidations), _e = _d.next(); !_e.done; _e = _d.next()) {
+                                                    rule = _e.value;
+                                                    onCreateDataValidationRule(rule, {
+                                                        skipEnqueue: true,
+                                                        importSource: true,
+                                                    });
+                                                }
+                                            }
+                                            catch (e_2_1) { e_2 = { error: e_2_1 }; }
+                                            finally {
+                                                try {
+                                                    if (_e && !_e.done && (_k = _d.return)) _k.call(_d);
+                                                }
+                                                finally { if (e_2) throw e_2.error; }
+                                            }
+                                            dataValidations = response.dataValidations;
+                                        }
+                                        if (response.responseType === ResponseType.GET_CHARTS_SUCCESS) {
+                                            onChangeCharts === null || onChangeCharts === void 0 ? void 0 : onChangeCharts(response.charts);
+                                        }
+                                        if (response.responseType === ResponseType.GET_SLICERS_SUCCESS) {
+                                            onChangeSlicers === null || onChangeSlicers === void 0 ? void 0 : onChangeSlicers(response.slicers);
+                                        }
+                                        if (response.responseType === ResponseType.GET_PIVOT_TABLES_SUCCESS) {
+                                            // Replace the whole pivot list — Excel files always
+                                            // declare their pivots upfront, so any pre-existing
+                                            // host-side pivot state from a previous file is stale.
+                                            onChangePivotTables === null || onChangePivotTables === void 0 ? void 0 : onChangePivotTables(function () { return response.pivotTables; });
+                                        }
+                                        if (response.responseType === ResponseType.GET_DRAWINGS_SUCCESS) {
+                                            embeds = [];
+                                            images_1 = [];
+                                            try {
+                                                for (_f = __values(response.drawings), _g = _f.next(); !_g.done; _g = _f.next()) {
+                                                    _h = _g.value;
+                                                    isInsideCell = _h.isInsideCell, drawing = __rest(_h, ["isInsideCell"]);
+                                                    if (isInsideCell) {
+                                                        images_1.push(drawing);
+                                                    }
+                                                    else {
+                                                        embeds.push(drawing);
+                                                    }
+                                                }
+                                            }
+                                            catch (e_3_1) { e_3 = { error: e_3_1 }; }
+                                            finally {
+                                                try {
+                                                    if (_g && !_g.done && (_l = _f.return)) _l.call(_f);
+                                                }
+                                                finally { if (e_3) throw e_3.error; }
+                                            }
+                                            // Embeds
+                                            onChangeEmbeds === null || onChangeEmbeds === void 0 ? void 0 : onChangeEmbeds(embeds);
+                                            // Sheet images
+                                            if (images_1.length) {
+                                                onChangeSheetData === null || onChangeSheetData === void 0 ? void 0 : onChangeSheetData(function (prev) {
+                                                    var e_5, _a;
+                                                    var _b, _c;
+                                                    try {
+                                                        for (var images_2 = __values(images_1), images_2_1 = images_2.next(); !images_2_1.done; images_2_1 = images_2.next()) {
+                                                            var image = images_2_1.value;
+                                                            var _d = image.position, sheetId = _d.sheetId, overlayPosition = _d.overlayPosition;
+                                                            var _e = overlayPosition.anchorCell, rowIndex = _e.rowIndex, columnIndex = _e.columnIndex;
+                                                            if (!prev[sheetId]) {
+                                                                prev[sheetId] = [];
+                                                            }
+                                                            var imageUrl = image.spec.imageUrl;
+                                                            var sheetCell = new SheetCell(sheetId, { rowIndex: rowIndex, columnIndex: columnIndex }, (_c = (_b = prev[sheetId]) === null || _b === void 0 ? void 0 : _b[rowIndex]) === null || _c === void 0 ? void 0 : _c.values[columnIndex]);
+                                                            sheetCell.setImage(imageUrl);
+                                                            if (!prev[sheetId][rowIndex]) {
+                                                                prev[sheetId][rowIndex] = { values: [] };
+                                                            }
+                                                            if (!prev[sheetId][rowIndex].values[columnIndex]) {
+                                                                prev[sheetId][rowIndex].values[columnIndex] = {};
+                                                            }
+                                                            prev[sheetId][rowIndex].values[columnIndex] =
+                                                                sheetCell.getCellData();
+                                                        }
+                                                    }
+                                                    catch (e_5_1) { e_5 = { error: e_5_1 }; }
+                                                    finally {
+                                                        try {
+                                                            if (images_2_1 && !images_2_1.done && (_a = images_2.return)) _a.call(images_2);
+                                                        }
+                                                        finally { if (e_5) throw e_5.error; }
+                                                    }
+                                                    return prev;
+                                                });
+                                            }
+                                        }
+                                        if (!(response.responseType === ResponseType.PARSE_EXCEL_COMPLETE)) return [3 /*break*/, 17];
+                                        hideLoader();
+                                        setIsImporting(false);
+                                        subscription.unsubscribe();
+                                        if (!enableExcelImportHistory) return [3 /*break*/, 16];
+                                        return [4 /*yield*/, generateStatePatches()];
+                                    case 15:
+                                        patches = _r.sent();
+                                        // Pass it on
+                                        onChangeHistory === null || onChangeHistory === void 0 ? void 0 : onChangeHistory([[patches]]);
+                                        _r.label = 16;
+                                    case 16:
+                                        // Schedule conditional format + data validation evaluation.
+                                        // DV rules were created with `skipEnqueue: true` above, so this
+                                        // is the only viewport-aware enqueue point post-import; without
+                                        // it the active sheet's formula-backed DV cells would not
+                                        // evaluate until the user scrolled or switched sheets (see
+                                        // `use-calculation-initialize`'s mount effect, which fires once
+                                        // before import resolves with empty initialDataValidations).
+                                        scheduleNormalPriorityCallback(function () {
+                                            var viewPort = getViewPort === null || getViewPort === void 0 ? void 0 : getViewPort();
+                                            if (conditionalFormats.length) {
+                                                evaluateConditionalFormatting === null || evaluateConditionalFormatting === void 0 ? void 0 : evaluateConditionalFormatting(conditionalFormats, viewPort);
+                                            }
+                                            if (dataValidations.length) {
+                                                evaluateDataValidations === null || evaluateDataValidations === void 0 ? void 0 : evaluateDataValidations(dataValidations, viewPort);
+                                            }
+                                        });
+                                        // Resolve the promise here when parsing is complete
+                                        resolve({
+                                            requiresRecalc: requiresRecalc,
+                                            iterativeCalculationOptions: iterativeCalculationOptions,
+                                            use1904: use1904,
+                                            success: true,
+                                            isPasswordProtected: isPasswordProtected,
+                                        });
+                                        _r.label = 17;
+                                    case 17: return [2 /*return*/];
+                                }
+                            });
+                        }); });
+                    })];
+            }
+        });
+    }); }, [
+        enableExcelImportHistory,
+        evaluateConditionalFormatting,
+        evaluateDataValidations,
+        showLoader,
+        hideLoader,
+        onChangeSheets,
+        onChangeSheetData,
+        onChangeCellXfs,
+        onChangeTables,
+        onChangeEmbeds,
+        onChangeNamedRanges,
+        onChangeConditionalFormats,
+        onChangeCharts,
+        getViewPort,
+        onRequestFonts,
+        onChangeTheme,
+        onCreateDataValidationRule,
+        onChangeHistory,
+        generateStatePatches,
+        onClearHistory,
+        onChangeSharedStrings,
+        confirm,
+        prompt,
+    ]));
+    return {
+        importExcelFile: importExcelFile,
+        isImportingExcelfile: isImportingExcelfile,
+        generateStatePatches: generateStatePatches,
+    };
+};