@rowsncolumns/spreadsheet-state 28.0.66

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

@@ -0,0 +1,267 @@
+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 const useOnImportCSV = ({ locale, sheetId: activeSheetId, activeCell: currentActiveCell, createHistory, onChangeSheets, onChangeSheetData, onChangeSharedStrings, onChangeCellXfs, sharedStringRegistry, enabledSharedStrings, enableCellXfsRegistry, enqueueCalculation, clearRangeCache, getDependents, }) => {
+    const [showLoader, hideLoader] = useLoadingIndicator();
+    // Import csv
+    const importCSVFile = useCallback(async (file, sheetId = activeSheetId, activeCell = currentActiveCell, options) => {
+        const { preserveFormatting = true, replaceSheetData = false, enabledSharedStrings: optionsEnabledSharedStrings, enableCellXfsRegistry: optionsEnableCellXfsRegistry, } = options ?? {};
+        const shouldUseSharedStrings = !!sharedStringRegistry &&
+            (optionsEnabledSharedStrings ??
+                enabledSharedStrings ??
+                sharedStringRegistry.active);
+        const shouldUseCellXfsRegistry = optionsEnableCellXfsRegistry ?? enableCellXfsRegistry ?? 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?.();
+        const saveHistory = createHistory();
+        const { observable, sendMessage } = createCSVImportWorker(file, {
+            pageSize: 200,
+            startRowIndex: activeCell.rowIndex,
+            startColumnIndex: activeCell.columnIndex,
+            preserveFormatting,
+            locale,
+            enableSharedStrings: shouldUseSharedStrings,
+            enableCellXfsRegistry: shouldUseCellXfsRegistry,
+            enableBackpressure: true,
+        });
+        let hasSharedStringChunks = false;
+        await new Promise((resolve) => {
+            let subscription = null;
+            subscription = observable.subscribe((response) => {
+                if (response.responseType === CsvResponseType.PARSE_CSV_SUCCESS) {
+                    const newRowCount = activeCell.rowIndex + response.totalRows;
+                    const newColumnCount = activeCell.columnIndex + response.totalColumns;
+                    onChangeSheets?.((prevSheets) => {
+                        const [nextState, patches, inversePatches] = produceWithPatches(prevSheets, (draft) => {
+                            const sheet = draft.find((sheet) => sheet.sheetId === sheetId);
+                            if (sheet) {
+                                sheet.rowCount = Math.max(sheet.rowCount ?? DEFAULT_ROW_COUNT, newRowCount);
+                                sheet.columnCount = Math.max(sheet.columnCount ?? DEFAULT_COLUMN_COUNT, newColumnCount);
+                            }
+                        });
+                        saveHistory({
+                            sheets: { patches, inversePatches },
+                        });
+                        return nextState;
+                    });
+                }
+                if (response.responseType === CsvResponseType.ROW_DATA_CHUNK) {
+                    const { rows, rowIndices, chunkIndex, totalRows, sharedStringsChunk, sharedStringsStartIndex, cellXfsChunk, } = response;
+                    const recalcCells = new Map();
+                    for (let i = 0; i < rowIndices.length; i++) {
+                        const rowIndex = rowIndices[i];
+                        const rowValues = rows[i]?.values ?? [];
+                        for (let columnIndex = 0; columnIndex < rowValues.length; columnIndex++) {
+                            const cell = rowValues[columnIndex];
+                            if (isNil(cell)) {
+                                continue;
+                            }
+                            if (getExtendedValueFormula(getCellUserEnteredValue(cell)) &&
+                                enqueueCalculation) {
+                                enqueueCalculation({
+                                    position: { rowIndex, columnIndex, sheetId },
+                                    type: "add",
+                                });
+                                recalcCells.set(createSheetCellIdentifier(sheetId, rowIndex, columnIndex), {
+                                    rowIndex,
+                                    columnIndex,
+                                    sheetId,
+                                });
+                                continue;
+                            }
+                            if (getDependents &&
+                                enqueueCalculation &&
+                                getDependents({ rowIndex, columnIndex, sheetId }).length) {
+                                enqueueCalculation({
+                                    position: { rowIndex, columnIndex, sheetId },
+                                    type: "add",
+                                });
+                                recalcCells.set(createSheetCellIdentifier(sheetId, rowIndex, columnIndex), {
+                                    rowIndex,
+                                    columnIndex,
+                                    sheetId,
+                                });
+                            }
+                        }
+                    }
+                    onChangeSheetData?.((prevSheetData) => {
+                        const [nextState, patches, inversePatches] = produceWithPatches(prevSheetData, (draft) => {
+                            if (replaceSheetData && chunkIndex === 0) {
+                                draft[sheetId] = [];
+                            }
+                            if (!draft[sheetId]) {
+                                draft[sheetId] = [];
+                            }
+                            for (let i = 0; i < rowIndices.length; i++) {
+                                const rowIndex = rowIndices[i];
+                                const nextRow = rows[i];
+                                const nextValues = nextRow?.values ?? [];
+                                const existingRow = draft[sheetId][rowIndex] ??
+                                    {};
+                                const existingValues = existingRow.values ?? [];
+                                const mergedValues = existingValues.slice();
+                                for (const key of Object.keys(nextValues)) {
+                                    const columnIndex = Number(key);
+                                    mergedValues[columnIndex] = nextValues[columnIndex];
+                                }
+                                existingRow.values = mergedValues;
+                                draft[sheetId][rowIndex] = existingRow;
+                            }
+                        });
+                        saveHistory({
+                            sheetData: {
+                                patches,
+                                inversePatches,
+                            },
+                            recalcCells: { undo: recalcCells, redo: recalcCells },
+                        });
+                        return nextState;
+                    });
+                    if (shouldUseCellXfsRegistry && cellXfsChunk?.length) {
+                        onChangeCellXfs?.((prev) => {
+                            const base = prev ?? new Map();
+                            const [nextState, patches, inversePatches] = produceWithPatches(base, (draft) => {
+                                for (const [key, value] of cellXfsChunk) {
+                                    draft.set(key, value);
+                                }
+                            });
+                            if (patches.length) {
+                                saveHistory({
+                                    cellXfs: { patches, inversePatches },
+                                });
+                            }
+                            return nextState;
+                        });
+                    }
+                    if (shouldUseSharedStrings &&
+                        onChangeSharedStrings &&
+                        sharedStringsChunk?.length) {
+                        hasSharedStringChunks = true;
+                        onChangeSharedStrings((prev) => {
+                            const base = prev ?? new Map();
+                            const [nextState, patches, inversePatches] = produceWithPatches(base, (draft) => {
+                                const isTuple = Array.isArray(sharedStringsChunk[0]);
+                                if (isTuple) {
+                                    // New worker shape: cells already reference these ids.
+                                    // Merge entries; existing keys with matching values stay.
+                                    for (const entry of sharedStringsChunk) {
+                                        const [id, value] = entry;
+                                        if (draft.get(id) !== value) {
+                                            draft.set(id, value);
+                                        }
+                                    }
+                                }
+                                else {
+                                    // Legacy worker shape: numeric ids assigned by position.
+                                    // Cells reference `startIndex + i`. Preserve to avoid
+                                    // breaking older workers / serialized chunks.
+                                    const startIndex = sharedStringsStartIndex ?? draft.size;
+                                    for (let i = 0; i < sharedStringsChunk.length; i++) {
+                                        draft.set(String(startIndex + i), sharedStringsChunk[i]);
+                                    }
+                                }
+                            });
+                            saveHistory({
+                                sharedStrings: { patches, inversePatches },
+                            });
+                            return nextState;
+                        });
+                    }
+                    if (totalRows > 0) {
+                        const currentRow = rowIndices[rowIndices.length - 1] ?? 0;
+                        const relativeRow = currentRow - activeCell.rowIndex + 1;
+                        const displayRow = Math.min(relativeRow, totalRows);
+                        showLoader(`Processing CSV: Row ${displayRow}/${totalRows}`);
+                    }
+                    sendMessage({
+                        requestType: CsvRequestType.ACK_ROW_DATA,
+                        chunkIndex,
+                    });
+                }
+                if (response.responseType === CsvResponseType.CELL_XFS) {
+                    if (shouldUseCellXfsRegistry) {
+                        onChangeCellXfs?.((prev) => {
+                            const base = prev ?? new Map();
+                            const [nextState, patches, inversePatches] = produceWithPatches(base, (draft) => {
+                                if (replaceSheetData) {
+                                    draft.clear();
+                                }
+                                response.cellXfs?.forEach?.((value, key) => {
+                                    draft.set(key, value);
+                                });
+                            });
+                            if (patches.length) {
+                                saveHistory({
+                                    cellXfs: { patches, 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).
+                    const newMap = new Map();
+                    const entries = response.sharedStrings;
+                    if (Array.isArray(entries[0])) {
+                        for (const [id, value] of entries) {
+                            newMap.set(id, value);
+                        }
+                    }
+                    else {
+                        entries.forEach((value, index) => {
+                            newMap.set(String(index), value);
+                        });
+                    }
+                    onChangeSharedStrings(newMap);
+                }
+                if (response.responseType === CsvResponseType.ERROR) {
+                    hideLoader();
+                    subscription?.unsubscribe();
+                    resolve();
+                }
+                if (response.responseType === CsvResponseType.PARSE_CSV_COMPLETE) {
+                    hideLoader();
+                    subscription?.unsubscribe();
+                    resolve();
+                }
+            });
+        });
+    }, [
+        createHistory,
+        onChangeSheetData,
+        onChangeSheets,
+        onChangeSharedStrings,
+        onChangeCellXfs,
+        hideLoader,
+        showLoader,
+        locale,
+        currentActiveCell,
+        activeSheetId,
+        sharedStringRegistry,
+        enabledSharedStrings,
+        enqueueCalculation,
+        clearRangeCache,
+        getDependents,
+        enableCellXfsRegistry,
+    ]);
+    return {
+        importCSVFile,
+    };
+};

package/dist/esm/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/esm/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":"AAAA,OAAO,KAAK,EAAE,2BAA2B,EAAE,MAAM,4BAA4B,CAAC;AAE9E,OAAO,KAAK,EACV,QAAQ,EAKR,KAAK,EACN,MAAM,2BAA2B,CAAC;AAoBnC,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,mBAAmB,CAAC;AACxD,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,8BAA8B,CAAC;AAC7E,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,6BAA6B,CAAC;AAC1E,OAAO,EAEL,KAAK,mBAAmB,EACzB,MAAM,yBAAyB,CAAC;AACjC,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,iBAAiB,CAAC;AAExD,MAAM,MAAM,yBAAyB,CAAC,CAAC,SAAS,QAAQ,EAAE,CAAC,SAAS,KAAK,IAAI;IAC3E,cAAc,IAAI,IAAI,CAAC;IACvB,wBAAwB,CAAC,EAAE,OAAO,CAAC;IACnC,eAAe,EAAE,mBAAmB,CAAC,iBAAiB,CAAC,CAAC;IACxD,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,EAAE,mBAAmB,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,uBAAuB,CAAC,CAAC;IAC1E,cAAc,EAAE,mBAAmB,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,gBAAgB,CAAC,CAAC;IAC5D,cAAc,EAAE,mBAAmB,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,gBAAgB,CAAC,CAAC;IAC5D,cAAc,CAAC,EAAE,mBAAmB,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,gBAAgB,CAAC,CAAC;IAC7D,mBAAmB,CAAC,EAAE,mBAAmB,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,qBAAqB,CAAC,CAAC;IACvE,eAAe,CAAC,EAAE,mBAAmB,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,iBAAiB,CAAC,CAAC;IAC/D,cAAc,EAAE,mBAAmB,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,gBAAgB,CAAC,CAAC;IAC5D,aAAa,EAAE,mBAAmB,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,eAAe,CAAC,CAAC;IAC1D,eAAe,EAAE,mBAAmB,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,iBAAiB,CAAC,CAAC;IAC9D;;;;;OAKG;IACH,mBAAmB,CAAC,EAAE,mBAAmB,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,qBAAqB,CAAC,CAAC;IACvE,0BAA0B,EAAE,UAAU,CACpC,OAAO,sBAAsB,CAC9B,CAAC,4BAA4B,CAAC,CAAC;IAChC,uBAAuB,CAAC,EAAE,mBAAmB,CAC3C,CAAC,EACD,CAAC,CACF,CAAC,yBAAyB,CAAC,CAAC;IAC7B,0BAA0B,CAAC,EAAE,mBAAmB,CAC9C,CAAC,EACD,CAAC,CACF,CAAC,4BAA4B,CAAC,CAAC;IAChC,6BAA6B,CAAC,EAAE,UAAU,CACxC,OAAO,wBAAwB,CAChC,CAAC,+BAA+B,CAAC,CAAC;IACnC,uBAAuB,CAAC,EAAE,UAAU,CAClC,OAAO,wBAAwB,CAChC,CAAC,yBAAyB,CAAC,CAAC;IAC7B,eAAe,CAAC,EAAE,UAAU,CAAC,OAAO,cAAc,CAAC,CAAC,iBAAiB,CAAC,CAAC;IACvE,SAAS,CAAC,EAAE,mBAAmB,CAAC,WAAW,CAAC,CAAC;IAC7C,QAAQ,CAAC,EAAE,mBAAmB,CAAC,UAAU,CAAC,CAAC;CAC5C,CAAC;AAEF,MAAM,MAAM,mBAAmB,GAAG;IAChC,cAAc,CAAC,EAAE,OAAO,CAAC;IACzB,2BAA2B,CAAC,EAAE,2BAA2B,CAAC;IAC1D,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,OAAO,EAAE,OAAO,CAAC;IACjB,mBAAmB,CAAC,EAAE,OAAO,CAAC;CAC/B,CAAC;AAEF,MAAM,MAAM,kBAAkB,GAAG;IAC/B,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,qBAAqB,CAAC,EAAE,OAAO,CAAC;IAChC,oBAAoB,CAAC,EAAE,OAAO,CAAC;IAC/B,kBAAkB,CAAC,EAAE,OAAO,CAAC;IAC7B,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB;;OAEG;IACH,OAAO,CAAC,EAAE,mBAAmB,CAAC,WAAW,CAAC,CAAC;IAC3C;;OAEG;IACH,MAAM,CAAC,EAAE,mBAAmB,CAAC,UAAU,CAAC,CAAC;CAC1C,CAAC;AAIF,eAAO,MAAM,oBAAoB,GAAI,CAAC,SAAS,QAAQ,EAAE,CAAC,SAAS,KAAK,EAAE,ocAwBvE,yBAAyB,CAAC,CAAC,EAAE,CAAC,CAAC;4BA+Sf,IAAI,GAAG,WAAW,YAAY,kBAAkB;;;CAyflE,CAAC"}