@rowsncolumns/spreadsheet-state 28.0.66

package/dist/cjs/hooks/use-on-filter-table.js

@@ -0,0 +1,429 @@
+import { __assign, __awaiter, __generator, __read, __spreadArray, __values } from "tslib";
+import { BLANK_LABEL, checkFilterRule, getStringifiedColor, ICON_SET_GLYPHS, pickIconBucket, resolveThreshold, } from "@rowsncolumns/spreadsheet";
+import { cellToAddress, isNil } from "@rowsncolumns/utils";
+import { produceWithPatches } from "immer";
+import set from "lodash/set";
+import { useCallback } from "react";
+import { buildDataValidationExpression, isDataValidationFormulaRule, } from "../api/data-validation";
+import { createFilterSpecs, createFilterSpecsByColumnIndex, } from "../api/filter";
+import { formulaToRelativeReference } from "../api/formula";
+import { useShowError } from "../atoms/error-state.atom";
+import { SHEET_PROTECTION_ERROR_TITLE, useCanEditSheet, useCanPerformSheetAction, } from "./use-can-edit-cellrange";
+/**
+ * Sorts a column
+ * @param param0
+ * @returns
+ */
+export var useOnFilterTable = function (_a) {
+    var createHistory = _a.createHistory, onChangeTables = _a.onChangeTables, onChangeSheets = _a.onChangeSheets, getEffectiveValue = _a.getEffectiveValue, getFormattedValue = _a.getFormattedValue, getEffectiveFormat = _a.getEffectiveFormat, conditionalFormats = _a.conditionalFormats, getActiveCell = _a.getActiveCell, onRequestCalculate = _a.onRequestCalculate, getSheetName = _a.getSheetName, locale = _a.locale, theme = _a.theme, onCommand = _a.onCommand, onRowVisibilityChange = _a.onRowVisibilityChange;
+    var canEditSheet = useCanEditSheet();
+    var canPerformSheetAction = useCanPerformSheetAction();
+    var showError = useShowError();
+    var onFilterTable = useCallback(function (sheetId_1, filter_1, columnIndex_1, conditionType_1, conditionValue_1, visibleValues_1) {
+        var args_1 = [];
+        for (var _i = 6; _i < arguments.length; _i++) {
+            args_1[_i - 6] = arguments[_i];
+        }
+        return __awaiter(void 0, __spreadArray([sheetId_1, filter_1, columnIndex_1, conditionType_1, conditionValue_1, visibleValues_1], __read(args_1), false), void 0, function (sheetId, filter, 
+        // This is the relative columnIndex to the table
+        // and not relative to grid
+        columnIndex, conditionType, conditionValue, visibleValues, extras) {
+            var saveHistory, filterSpecs, hiddenRows, range;
+            var _a;
+            if (extras === void 0) { extras = {}; }
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        // Protection — filter doesn't rewrite cell values but it does
+                        // hide rows. The sheet's `<sheetProtection autoFilter>` flag is
+                        // consulted first; the host's `isSheetProtected` policy via
+                        // `canEditSheet` still gets a veto.
+                        if (!canPerformSheetAction(sheetId, "autoFilter")) {
+                            showError({
+                                title: SHEET_PROTECTION_ERROR_TITLE,
+                                message: "You can't change filters on a protected sheet.",
+                            });
+                            return [2 /*return*/];
+                        }
+                        if (!canEditSheet(sheetId)) {
+                            console.debug("This sheet is protected, users cannot change table filters.");
+                            return [2 /*return*/];
+                        }
+                        saveHistory = createHistory();
+                        filterSpecs = createFilterSpecs((_a = filter.filterSpecs) !== null && _a !== void 0 ? _a : undefined, columnIndex, conditionType, conditionValue, visibleValues, extras);
+                        return [4 /*yield*/, getHiddenRowsFromFilterSpecs(sheetId, filter, filterSpecs, onRequestCalculate, getEffectiveValue, getFormattedValue, getSheetName, theme, locale, getEffectiveFormat, conditionalFormats, extras.getCellConditionalFormat)];
+                    case 1:
+                        hiddenRows = _b.sent();
+                        range = filter.range;
+                        // Change sheets
+                        onChangeSheets === null || onChangeSheets === void 0 ? void 0 : onChangeSheets(function (prevSheets) {
+                            var _a = __read(produceWithPatches(prevSheets, function (draft) {
+                                var _a;
+                                var sheet = draft.find(function (sheet) { return sheet.sheetId === sheetId; });
+                                if (sheet) {
+                                    if (!sheet.rowMetadata) {
+                                        sheet.rowMetadata = [];
+                                    }
+                                    for (var rowIndex = range.startRowIndex; rowIndex <= range.endRowIndex; rowIndex++) {
+                                        sheet.rowMetadata[rowIndex] = __assign(__assign({}, sheet.rowMetadata[rowIndex]), { hiddenByFilter: hiddenRows.has(rowIndex) ? true : false });
+                                    }
+                                }
+                                // Update filter specs
+                                if (((_a = sheet === null || sheet === void 0 ? void 0 : sheet.basicFilter) === null || _a === void 0 ? void 0 : _a.id) === filter.id) {
+                                    set(sheet, "basicFilter.filterSpecs", filterSpecs);
+                                }
+                            }), 3), nextState = _a[0], patches = _a[1], inversePatches = _a[2];
+                            // Save history
+                            saveHistory({
+                                sheets: { patches: patches, inversePatches: inversePatches },
+                                activeCell: { undo: getActiveCell(), redo: getActiveCell() },
+                            });
+                            return nextState;
+                        });
+                        // Update table sort specs
+                        onChangeTables === null || onChangeTables === void 0 ? void 0 : onChangeTables(function (prevTables) {
+                            var _a = __read(produceWithPatches(prevTables, function (draft) {
+                                var table = draft.find(function (table) { return table.id === filter.id; });
+                                if (table) {
+                                    table.filterSpecs = filterSpecs;
+                                }
+                            }), 3), nextState = _a[0], patches = _a[1], inversePatches = _a[2];
+                            // Save history
+                            saveHistory({
+                                tables: { patches: patches, inversePatches: inversePatches },
+                            });
+                            return nextState;
+                        });
+                        // Filtering changed which rows are visible — recalc SUBTOTALs
+                        onRowVisibilityChange === null || onRowVisibilityChange === void 0 ? void 0 : onRowVisibilityChange();
+                        onCommand === null || onCommand === void 0 ? void 0 : onCommand({
+                            command: "filter-table",
+                            sheetId: sheetId,
+                            filter: filter,
+                            columnIndex: columnIndex,
+                            conditionType: conditionType,
+                            conditionValue: conditionValue,
+                            visibleValues: visibleValues,
+                            colorFilter: extras.colorFilter,
+                            iconFilter: extras.iconFilter,
+                        });
+                        return [2 /*return*/];
+                }
+            });
+        });
+    }, [
+        createHistory,
+        onChangeTables,
+        onChangeSheets,
+        getEffectiveValue,
+        getFormattedValue,
+        getEffectiveFormat,
+        conditionalFormats,
+        getActiveCell,
+        onRequestCalculate,
+        getSheetName,
+        locale,
+        onCommand,
+        canEditSheet,
+        canPerformSheetAction,
+        showError,
+        onRowVisibilityChange,
+    ]);
+    var onDeleteFilter = useCallback(function (sheetId, filter, columnIndex) { return __awaiter(void 0, void 0, void 0, function () {
+        var result;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0: return [4 /*yield*/, (onFilterTable === null || onFilterTable === void 0 ? void 0 : onFilterTable(sheetId, filter, columnIndex, undefined, undefined, []))];
+                case 1:
+                    result = _a.sent();
+                    onCommand === null || onCommand === void 0 ? void 0 : onCommand({
+                        command: "delete-filter",
+                        sheetId: sheetId,
+                        filter: filter,
+                        columnIndex: columnIndex,
+                    });
+                    return [2 /*return*/, result];
+            }
+        });
+    }); }, [onFilterTable, onCommand]);
+    return [onFilterTable, onDeleteFilter];
+};
+/**
+ * Does the cell's rendered color match the colorFilter criterion?
+ * The CF overlay wins over the effective format — mirroring the
+ * renderer's precedence — because CF-painted fills/font colors never
+ * appear on the effective format. Returns true when no relevant color is
+ * set on the cell — Excel hides such rows when a color filter is active.
+ */
+var matchesCellColor = function (colorFilter, format, conditionalFormat, theme) {
+    var _a, _b, _c, _d;
+    var target = getStringifiedColor(colorFilter.color, theme);
+    if (!target)
+        return true;
+    var cellColor = colorFilter.mode === "cellColor"
+        ? (_a = conditionalFormat === null || conditionalFormat === void 0 ? void 0 : conditionalFormat.backgroundColor) !== null && _a !== void 0 ? _a : format === null || format === void 0 ? void 0 : format.backgroundColor
+        : (_c = (_b = conditionalFormat === null || conditionalFormat === void 0 ? void 0 : conditionalFormat.textFormat) === null || _b === void 0 ? void 0 : _b.color) !== null && _c !== void 0 ? _c : (_d = format === null || format === void 0 ? void 0 : format.textFormat) === null || _d === void 0 ? void 0 : _d.color;
+    var actual = getStringifiedColor(cellColor, theme);
+    if (!actual)
+        return false;
+    // Case-insensitive: hex casing differs between user-entered fills,
+    // theme palettes, and interpolated gradient colors.
+    return actual.toLowerCase() === target.toLowerCase();
+};
+/**
+ * Walk `conditionalFormats` once and build an iconSet evaluation context
+ * keyed by absolute columnIndex for every column that has an active
+ * `iconFilter`. Computing range min/max here (instead of per-row) keeps
+ * the filter cost O(rule range size) regardless of how many rows the
+ * filter scans.
+ */
+var buildIconEvalByColumn = function (sheetId, filterRange, filterSpecs, conditionalFormats, getEffectiveValue) {
+    var e_1, _a;
+    var _b, _c, _d;
+    var byColumn = new Map();
+    if (!(conditionalFormats === null || conditionalFormats === void 0 ? void 0 : conditionalFormats.length))
+        return byColumn;
+    var _loop_1 = function (spec) {
+        var e_2, _e;
+        var iconFilter = (_b = spec.filterCriteria) === null || _b === void 0 ? void 0 : _b.iconFilter;
+        if (!iconFilter)
+            return "continue";
+        var absoluteColumnIndex = filterRange.startColumnIndex + spec.columnIndex;
+        var _loop_2 = function (rule) {
+            var e_3, _f;
+            if (rule.enabled === false)
+                return "continue";
+            var iconSetRule = rule.iconSetRule;
+            if (!iconSetRule || iconSetRule.iconSet !== iconFilter.iconSet)
+                return "continue";
+            var coveringRanges = rule.ranges.filter(function (r) {
+                return r.sheetId === sheetId &&
+                    r.startColumnIndex <= absoluteColumnIndex &&
+                    r.endColumnIndex >= absoluteColumnIndex;
+            });
+            if (coveringRanges.length === 0)
+                return "continue";
+            var rangeMin = Infinity;
+            var rangeMax = -Infinity;
+            try {
+                for (var coveringRanges_1 = (e_3 = void 0, __values(coveringRanges)), coveringRanges_1_1 = coveringRanges_1.next(); !coveringRanges_1_1.done; coveringRanges_1_1 = coveringRanges_1.next()) {
+                    var r = coveringRanges_1_1.value;
+                    for (var rr = r.startRowIndex; rr <= r.endRowIndex; rr++) {
+                        for (var cc = r.startColumnIndex; cc <= r.endColumnIndex; cc++) {
+                            var v = getEffectiveValue(sheetId, rr, cc);
+                            if (isNil(v))
+                                continue;
+                            var num = Number(v);
+                            if (!Number.isFinite(num))
+                                continue;
+                            if (num < rangeMin)
+                                rangeMin = num;
+                            if (num > rangeMax)
+                                rangeMax = num;
+                        }
+                    }
+                }
+            }
+            catch (e_3_1) { e_3 = { error: e_3_1 }; }
+            finally {
+                try {
+                    if (coveringRanges_1_1 && !coveringRanges_1_1.done && (_f = coveringRanges_1.return)) _f.call(coveringRanges_1);
+                }
+                finally { if (e_3) throw e_3.error; }
+            }
+            if (!Number.isFinite(rangeMin))
+                return "continue";
+            var sortedThresholds = iconSetRule.thresholds
+                .map(function (t) { return resolveThreshold(t, rangeMin, rangeMax); })
+                .filter(function (n) { return Number.isFinite(n); })
+                .sort(function (a, b) { return a - b; });
+            byColumn.set(absoluteColumnIndex, {
+                iconSet: iconFilter.iconSet,
+                sortedThresholds: sortedThresholds,
+                ranges: coveringRanges,
+                glyphCount: (_d = (_c = ICON_SET_GLYPHS[iconFilter.iconSet]) === null || _c === void 0 ? void 0 : _c.length) !== null && _d !== void 0 ? _d : 0,
+            });
+            return "break";
+        };
+        try {
+            for (var conditionalFormats_1 = (e_2 = void 0, __values(conditionalFormats)), conditionalFormats_1_1 = conditionalFormats_1.next(); !conditionalFormats_1_1.done; conditionalFormats_1_1 = conditionalFormats_1.next()) {
+                var rule = conditionalFormats_1_1.value;
+                var state_1 = _loop_2(rule);
+                if (state_1 === "break")
+                    break;
+            }
+        }
+        catch (e_2_1) { e_2 = { error: e_2_1 }; }
+        finally {
+            try {
+                if (conditionalFormats_1_1 && !conditionalFormats_1_1.done && (_e = conditionalFormats_1.return)) _e.call(conditionalFormats_1);
+            }
+            finally { if (e_2) throw e_2.error; }
+        }
+    };
+    try {
+        for (var filterSpecs_1 = __values(filterSpecs), filterSpecs_1_1 = filterSpecs_1.next(); !filterSpecs_1_1.done; filterSpecs_1_1 = filterSpecs_1.next()) {
+            var spec = filterSpecs_1_1.value;
+            _loop_1(spec);
+        }
+    }
+    catch (e_1_1) { e_1 = { error: e_1_1 }; }
+    finally {
+        try {
+            if (filterSpecs_1_1 && !filterSpecs_1_1.done && (_a = filterSpecs_1.return)) _a.call(filterSpecs_1);
+        }
+        finally { if (e_1) throw e_1.error; }
+    }
+    return byColumn;
+};
+/**
+ * Does this cell's CF iconSet rule produce the icon the user filtered on?
+ * Returns false when the cell isn't in the rule's range or has no numeric
+ * value (Excel hides both cases when an icon filter is active).
+ */
+var matchesCellIcon = function (iconFilter, ctx, sheetId, rowIndex, columnIndex, getEffectiveValue) {
+    var inRange = ctx.ranges.some(function (r) {
+        return rowIndex >= r.startRowIndex &&
+            rowIndex <= r.endRowIndex &&
+            columnIndex >= r.startColumnIndex &&
+            columnIndex <= r.endColumnIndex;
+    });
+    if (!inRange)
+        return false;
+    var v = getEffectiveValue(sheetId, rowIndex, columnIndex);
+    if (isNil(v))
+        return false;
+    var num = Number(v);
+    if (!Number.isFinite(num))
+        return false;
+    var bucket = pickIconBucket(num, ctx.sortedThresholds);
+    var glyphIndex = Math.min(bucket, Math.max(0, ctx.glyphCount - 1));
+    return glyphIndex === iconFilter.iconId;
+};
+/**
+ * Get hidden rows from a filter
+ * @param filterSpecs
+ */
+export var getHiddenRowsFromFilterSpecs = function (sheetId, filterView, filterSpecs, onRequestCalculate, getEffectiveValue, getFormattedValue, getSheetName, theme, locale, 
+// Optional — only required when a column filter uses `colorFilter`.
+// Receives the cell's effective format so we can match cell or font color.
+getEffectiveFormat, 
+// Optional — required for `iconFilter` to work. See the prop docs on
+// `UseOnFilterTableProps.conditionalFormats` for the migration plan.
+conditionalFormats, 
+// Optional — reader for the rendered CF overlay (injected per-call via
+// `FilterTableExtras`). Lets `colorFilter` match CF-painted fills/font
+// colors, which the effective format doesn't carry.
+getCellConditionalFormat) { return __awaiter(void 0, void 0, void 0, function () {
+    var activeSheetName, hiddenRows, filterSpecByColumnIndex, range, iconEvalByColumn, headerRow, totalRow, startRowIndex, endRowIndex, rowIndex, columnIndex, dimensionIndex, columnFilter, filterApplied, formulaRule, isFormulaRule, baseCellRef, baseFormula, formulaValue, currentVisibleValues, visibleValuesSet, showBlanks, effectiveValue, formattedValue, validationResult, _a, _b, isBlanksVisible, isRowVisible, colorFilter, iconFilter, effectiveFormat, cellConditionalFormat, matchesColorFilter, iconCtx, matchesIconFilter, isHidden;
+    var _c, _d, _e, _f, _g, _h;
+    return __generator(this, function (_j) {
+        switch (_j.label) {
+            case 0:
+                activeSheetName = getSheetName(sheetId);
+                hiddenRows = new Set();
+                filterSpecByColumnIndex = createFilterSpecsByColumnIndex(filterSpecs);
+                range = filterView.range;
+                iconEvalByColumn = buildIconEvalByColumn(sheetId, range, filterSpecs, conditionalFormats, getEffectiveValue);
+                headerRow = (_c = filterView.headerRow) !== null && _c !== void 0 ? _c : true;
+                totalRow = filterView.totalRow;
+                startRowIndex = range.startRowIndex + (headerRow ? 1 : 0);
+                endRowIndex = range.endRowIndex - (totalRow ? 1 : 0);
+                rowIndex = startRowIndex;
+                _j.label = 1;
+            case 1:
+                if (!(rowIndex <= endRowIndex)) return [3 /*break*/, 10];
+                columnIndex = range.startColumnIndex;
+                _j.label = 2;
+            case 2:
+                if (!(columnIndex <= range.endColumnIndex)) return [3 /*break*/, 9];
+                dimensionIndex = columnIndex - range.startColumnIndex;
+                columnFilter = filterSpecByColumnIndex[dimensionIndex];
+                filterApplied = Boolean(((_d = columnFilter === null || columnFilter === void 0 ? void 0 : columnFilter.filterCriteria.condition) === null || _d === void 0 ? void 0 : _d.type) ||
+                    ((_e = columnFilter === null || columnFilter === void 0 ? void 0 : columnFilter.filterCriteria.visibleValues) === null || _e === void 0 ? void 0 : _e.length) ||
+                    (columnFilter === null || columnFilter === void 0 ? void 0 : columnFilter.filterCriteria.colorFilter) ||
+                    (columnFilter === null || columnFilter === void 0 ? void 0 : columnFilter.filterCriteria.iconFilter));
+                if (!columnFilter || !filterApplied) {
+                    return [3 /*break*/, 8];
+                }
+                formulaRule = (columnFilter === null || columnFilter === void 0 ? void 0 : columnFilter.filterCriteria.condition)
+                    ? {
+                        condition: columnFilter.filterCriteria.condition,
+                    }
+                    : undefined;
+                isFormulaRule = isDataValidationFormulaRule(formulaRule);
+                baseCellRef = (_f = cellToAddress({ rowIndex: startRowIndex, columnIndex: columnIndex })) !== null && _f !== void 0 ? _f : "A1";
+                baseFormula = isFormulaRule
+                    ? buildDataValidationExpression(formulaRule, baseCellRef, locale)
+                    : undefined;
+                formulaValue = baseFormula
+                    ? formulaToRelativeReference(baseFormula, { rowIndex: startRowIndex, columnIndex: columnIndex }, { rowIndex: rowIndex, columnIndex: columnIndex }, activeSheetName, { ignoreCircular: true })
+                    : undefined;
+                currentVisibleValues = columnFilter === null || columnFilter === void 0 ? void 0 : columnFilter.filterCriteria.visibleValues;
+                visibleValuesSet = currentVisibleValues
+                    ? new Set(currentVisibleValues)
+                    : undefined;
+                showBlanks = (_g = visibleValuesSet === null || visibleValuesSet === void 0 ? void 0 : visibleValuesSet.has(BLANK_LABEL)) !== null && _g !== void 0 ? _g : false;
+                effectiveValue = getEffectiveValue(sheetId, rowIndex, columnIndex);
+                formattedValue = getFormattedValue(sheetId, rowIndex, columnIndex);
+                if (!((_h = columnFilter.filterCriteria.condition) === null || _h === void 0 ? void 0 : _h.type)) return [3 /*break*/, 6];
+                if (!formulaValue) return [3 /*break*/, 4];
+                return [4 /*yield*/, onRequestCalculate(formulaValue, sheetId, rowIndex, columnIndex)];
+            case 3:
+                _b = _j.sent();
+                return [3 /*break*/, 5];
+            case 4:
+                _b = checkFilterRule(columnFilter.filterCriteria, effectiveValue);
+                _j.label = 5;
+            case 5:
+                _a = _b;
+                return [3 /*break*/, 7];
+            case 6:
+                _a = true;
+                _j.label = 7;
+            case 7:
+                validationResult = _a;
+                isBlanksVisible = showBlanks
+                    ? isNil(formattedValue) || formattedValue === ""
+                    : false;
+                isRowVisible = currentVisibleValues
+                    ? isBlanksVisible ||
+                        (formattedValue && (visibleValuesSet === null || visibleValuesSet === void 0 ? void 0 : visibleValuesSet.has(formattedValue)))
+                    : true;
+                colorFilter = columnFilter.filterCriteria.colorFilter;
+                iconFilter = columnFilter.filterCriteria.iconFilter;
+                effectiveFormat = colorFilter && getEffectiveFormat
+                    ? getEffectiveFormat(sheetId, rowIndex, columnIndex)
+                    : undefined;
+                cellConditionalFormat = colorFilter && getCellConditionalFormat
+                    ? getCellConditionalFormat(sheetId, rowIndex, columnIndex)
+                    : undefined;
+                matchesColorFilter = !colorFilter || (!getEffectiveFormat && !getCellConditionalFormat)
+                    ? true
+                    : matchesCellColor(colorFilter, effectiveFormat, cellConditionalFormat, theme);
+                iconCtx = iconFilter
+                    ? iconEvalByColumn.get(columnIndex)
+                    : undefined;
+                matchesIconFilter = !iconFilter
+                    ? true
+                    : !iconCtx
+                        ? false
+                        : matchesCellIcon(iconFilter, iconCtx, sheetId, rowIndex, columnIndex, getEffectiveValue);
+                isHidden = !isRowVisible ||
+                    validationResult === false ||
+                    !matchesColorFilter ||
+                    !matchesIconFilter;
+                if (isHidden) {
+                    hiddenRows.add(rowIndex);
+                }
+                _j.label = 8;
+            case 8:
+                columnIndex++;
+                return [3 /*break*/, 2];
+            case 9:
+                rowIndex++;
+                return [3 /*break*/, 1];
+            case 10: return [2 /*return*/, hiddenRows];
+        }
+    });
+}); };

package/dist/cjs/hooks/use-on-find-replace.d.ts

@@ -0,0 +1,19 @@
+import type { CellData, Sheet, SheetRange } from "@rowsncolumns/spreadsheet";
+import type { useCalculation } from "./use-calculation";
+import type { SearchOptions } from "./use-search";
+import type { UseSpreadsheetProps } from "./use-spreadsheet-state";
+import type { SharedStringRegistry } from "./use-ss-registry";
+import type { SpreadsheetPatch } from "./use-undo-redo";
+import type { OnCommand } from "../commands";
+type UseOnFindReplaceProps<T extends CellData, S extends Sheet> = {
+    locale?: string;
+    createHistory: () => (patches: SpreadsheetPatch) => void;
+    enqueueCalculation: ReturnType<typeof useCalculation>["enqueueCalculation"];
+    enqueueStructureChange?: ReturnType<typeof useCalculation>["enqueueStructureChange"];
+    onChangeSheetData: UseSpreadsheetProps<T, S>["onChangeSheetData"];
+    sharedStringRegistry?: SharedStringRegistry;
+    onCommand?: OnCommand;
+};
+export declare const useOnFindReplace: <T extends CellData, S extends Sheet>({ locale, createHistory, onChangeSheetData, enqueueCalculation, enqueueStructureChange, sharedStringRegistry, onCommand, }: UseOnFindReplaceProps<T, S>) => (lookupRanges: SheetRange[], searchStr: string, replaceWith: string | undefined, options?: SearchOptions) => void;
+export {};
+//# sourceMappingURL=use-on-find-replace.d.ts.map

package/dist/cjs/hooks/use-on-find-replace.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-on-find-replace.d.ts","sourceRoot":"","sources":["../../../hooks/use-on-find-replace.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,KAAK,EAAE,UAAU,EAAE,MAAM,2BAA2B,CAAC;AAU7E,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,mBAAmB,CAAC;AACxD,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,cAAc,CAAC;AAElD,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,yBAAyB,CAAC;AACnE,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,mBAAmB,CAAC;AAC9D,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,iBAAiB,CAAC;AACxD,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AAE7C,KAAK,qBAAqB,CAAC,CAAC,SAAS,QAAQ,EAAE,CAAC,SAAS,KAAK,IAAI;IAChE,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,aAAa,EAAE,MAAM,CAAC,OAAO,EAAE,gBAAgB,KAAK,IAAI,CAAC;IACzD,kBAAkB,EAAE,UAAU,CAAC,OAAO,cAAc,CAAC,CAAC,oBAAoB,CAAC,CAAC;IAC5E,sBAAsB,CAAC,EAAE,UAAU,CACjC,OAAO,cAAc,CACtB,CAAC,wBAAwB,CAAC,CAAC;IAC5B,iBAAiB,EAAE,mBAAmB,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,mBAAmB,CAAC,CAAC;IAClE,oBAAoB,CAAC,EAAE,oBAAoB,CAAC;IAC5C,SAAS,CAAC,EAAE,SAAS,CAAC;CACvB,CAAC;AAEF,eAAO,MAAM,gBAAgB,GAAI,CAAC,SAAS,QAAQ,EAAE,CAAC,SAAS,KAAK,EAAE,4HAQnE,qBAAqB,CAAC,CAAC,EAAE,CAAC,CAAC,oBAGV,UAAU,EAAE,aACf,MAAM,eACJ,MAAM,GAAG,SAAS,YACrB,aAAa,SAgJ5B,CAAC"}

package/dist/cjs/hooks/use-on-find-replace.js

@@ -0,0 +1,150 @@
+import { __read, __values } from "tslib";
+import { isNil, iterateCellsInRange } from "@rowsncolumns/utils";
+import { produceWithPatches } from "immer";
+import { useCallback } from "react";
+import { createSheetCellIdentifier } from "../api/formula";
+import { createSheetDraft } from "../api/immer-utils";
+import { SheetCell } from "../sheet-cell";
+import { buildSearchRegex } from "./use-search";
+export var useOnFindReplace = function (_a) {
+    var locale = _a.locale, createHistory = _a.createHistory, onChangeSheetData = _a.onChangeSheetData, enqueueCalculation = _a.enqueueCalculation, enqueueStructureChange = _a.enqueueStructureChange, sharedStringRegistry = _a.sharedStringRegistry, onCommand = _a.onCommand;
+    return useCallback(function (lookupRanges, searchStr, replaceWith, options) {
+        var e_1, _a;
+        // Build the matcher once with the same helper `useSearch` uses, so
+        // case-insensitivity / whole-word / user-regex stay in sync between
+        // find and replace. Bail early on a compile failure (regex mode
+        // with a malformed pattern) — matches `useSearch`'s zero-matches
+        // behaviour.
+        var regex = buildSearchRegex(searchStr, options);
+        if (!regex)
+            return;
+        // Find-replace scans the WHOLE scope — which a windowed UI doesn't hold. Stream the INTENT to
+        // an engine consumer (the Rust model has the complete document) and let it do the find+replace
+        // and recompute, streaming back the changed cells. The local pass below is the legacy
+        // non-engine path (the UI holds all data only when no engine is attached).
+        onCommand === null || onCommand === void 0 ? void 0 : onCommand({
+            command: "find-replace",
+            ranges: lookupRanges,
+            find: searchStr,
+            replace: replaceWith !== null && replaceWith !== void 0 ? replaceWith : "",
+            matchCase: options === null || options === void 0 ? void 0 : options.matchCase,
+            wholeWord: options === null || options === void 0 ? void 0 : options.wholeWord,
+            useRegex: options === null || options === void 0 ? void 0 : options.useRegex,
+        });
+        var sheetCell = new SheetCell();
+        var saveHistory = createHistory();
+        // We need to track this for history. Precedent cells
+        var recalcCells = new Map();
+        // Replace writes through `onChangeSheetData` directly. Conservatively
+        // invalidate each entire lookup range — every match is within it,
+        // and tracking individual hits would mean a second pass to bound them.
+        if (!isNil(replaceWith)) {
+            try {
+                for (var lookupRanges_1 = __values(lookupRanges), lookupRanges_1_1 = lookupRanges_1.next(); !lookupRanges_1_1.done; lookupRanges_1_1 = lookupRanges_1.next()) {
+                    var range = lookupRanges_1_1.value;
+                    enqueueStructureChange === null || enqueueStructureChange === void 0 ? void 0 : enqueueStructureChange({
+                        kind: "invalidate-range",
+                        sheetId: range.sheetId,
+                        startRowIndex: range.startRowIndex,
+                        endRowIndex: range.endRowIndex,
+                        startColumnIndex: range.startColumnIndex,
+                        endColumnIndex: range.endColumnIndex,
+                    });
+                }
+            }
+            catch (e_1_1) { e_1 = { error: e_1_1 }; }
+            finally {
+                try {
+                    if (lookupRanges_1_1 && !lookupRanges_1_1.done && (_a = lookupRanges_1.return)) _a.call(lookupRanges_1);
+                }
+                finally { if (e_1) throw e_1.error; }
+            }
+        }
+        // Callback
+        onChangeSheetData === null || onChangeSheetData === void 0 ? void 0 : onChangeSheetData(function (prevSheetData) {
+            var _a = __read(produceWithPatches(prevSheetData, function (draft) {
+                var e_2, _a, e_3, _b;
+                var _c, _d, _e;
+                try {
+                    for (var lookupRanges_2 = __values(lookupRanges), lookupRanges_2_1 = lookupRanges_2.next(); !lookupRanges_2_1.done; lookupRanges_2_1 = lookupRanges_2.next()) {
+                        var range = lookupRanges_2_1.value;
+                        try {
+                            for (var _f = (e_3 = void 0, __values(iterateCellsInRange(range))), _g = _f.next(); !_g.done; _g = _f.next()) {
+                                var _h = __read(_g.value, 2), rowIndex = _h[0], columnIndex = _h[1];
+                                var currentSheet = createSheetDraft(draft, range.sheetId, rowIndex);
+                                var cellData = (_e = (_d = (_c = draft[range.sheetId]) === null || _c === void 0 ? void 0 : _c[rowIndex]) === null || _d === void 0 ? void 0 : _d.values) === null || _e === void 0 ? void 0 : _e[columnIndex];
+                                sheetCell.assign(range.sheetId, { rowIndex: rowIndex, columnIndex: columnIndex }, cellData, { locale: locale });
+                                // Match AND replace against the formatted value — what
+                                // the user sees and what `useSearch` matched. The
+                                // user-entered value can be a number / formula whose
+                                // display form ("$100.00") doesn't contain the literal
+                                // search string ("100"), so trying to replace in `sv`
+                                // alone misses those cells. Writing the replaced
+                                // formatted text back as the new user-entered value
+                                // mirrors Excel / Google Sheets — a cell that was
+                                // numeric with a currency format becomes the plain
+                                // string the user typed in the Replace box.
+                                var formattedValue = sheetCell.formattedValue;
+                                if (isNil(formattedValue))
+                                    continue;
+                                // `g` flag is set by `buildSearchRegex`; reset lastIndex
+                                // before .test so a stateful regex doesn't skip the
+                                // first character on a re-run.
+                                regex.lastIndex = 0;
+                                if (!regex.test(formattedValue))
+                                    continue;
+                                regex.lastIndex = 0;
+                                var next = formattedValue.replace(regex, replaceWith !== null && replaceWith !== void 0 ? replaceWith : "");
+                                sheetCell.setUserEnteredValue(next);
+                                sharedStringRegistry === null || sharedStringRegistry === void 0 ? void 0 : sharedStringRegistry.registerCell(sheetCell);
+                                currentSheet[rowIndex].values[columnIndex] =
+                                    sheetCell.getCellData();
+                                enqueueCalculation({
+                                    type: "add",
+                                    position: {
+                                        rowIndex: rowIndex,
+                                        columnIndex: columnIndex,
+                                        sheetId: range.sheetId,
+                                    },
+                                });
+                                recalcCells.set(createSheetCellIdentifier(range.sheetId, rowIndex, columnIndex), {
+                                    columnIndex: columnIndex,
+                                    rowIndex: rowIndex,
+                                    sheetId: range.sheetId,
+                                });
+                            }
+                        }
+                        catch (e_3_1) { e_3 = { error: e_3_1 }; }
+                        finally {
+                            try {
+                                if (_g && !_g.done && (_b = _f.return)) _b.call(_f);
+                            }
+                            finally { if (e_3) throw e_3.error; }
+                        }
+                    }
+                }
+                catch (e_2_1) { e_2 = { error: e_2_1 }; }
+                finally {
+                    try {
+                        if (lookupRanges_2_1 && !lookupRanges_2_1.done && (_a = lookupRanges_2.return)) _a.call(lookupRanges_2);
+                    }
+                    finally { if (e_2) throw e_2.error; }
+                }
+            }), 3), nextState = _a[0], patches = _a[1], inversePatches = _a[2];
+            saveHistory({
+                sheetData: { patches: patches, inversePatches: inversePatches },
+                recalcCells: { undo: recalcCells, redo: recalcCells },
+            });
+            return nextState;
+        });
+        sharedStringRegistry === null || sharedStringRegistry === void 0 ? void 0 : sharedStringRegistry.getPatches(saveHistory);
+    }, [
+        createHistory,
+        locale,
+        enqueueCalculation,
+        enqueueStructureChange,
+        onChangeSheetData,
+        sharedStringRegistry,
+        onCommand,
+    ]);
+};

package/dist/cjs/hooks/use-on-freeze.d.ts

@@ -0,0 +1,13 @@
+import { type CellData, type Sheet } from "@rowsncolumns/spreadsheet";
+import type { OnCommand } from "../commands";
+import type { UseSpreadsheetProps } from "./use-spreadsheet-state";
+import type { SpreadsheetPatch } from "./use-undo-redo";
+export type UseOnFreezeProps<T extends CellData, S extends Sheet> = {
+    createHistory(): (patches: SpreadsheetPatch) => void;
+    onChangeSheets: UseSpreadsheetProps<T, S>["onChangeSheets"];
+    onChangeEmbeds?: UseSpreadsheetProps<T, S>["onChangeEmbeds"];
+    onChangeCharts?: UseSpreadsheetProps<T, S>["onChangeCharts"];
+    onCommand?: OnCommand;
+};
+export declare const useOnFreeze: <T extends CellData, S extends Sheet>({ createHistory, onChangeSheets, onChangeEmbeds, onChangeCharts, onCommand, }: UseOnFreezeProps<T, S>) => readonly [(sheetId: number, rowIndex: number) => void, (sheetId: number, columnIndex: number) => void];
+//# sourceMappingURL=use-on-freeze.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"use-on-freeze.d.ts","sourceRoot":"","sources":["../../../hooks/use-on-freeze.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,QAAQ,EAAE,KAAK,KAAK,EAAE,MAAM,2BAA2B,CAAC;AAGtE,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AAG7C,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,yBAAyB,CAAC;AACnE,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,iBAAiB,CAAC;AAExD,MAAM,MAAM,gBAAgB,CAAC,CAAC,SAAS,QAAQ,EAAE,CAAC,SAAS,KAAK,IAAI;IAClE,aAAa,IAAI,CAAC,OAAO,EAAE,gBAAgB,KAAK,IAAI,CAAC;IACrD,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,cAAc,CAAC,EAAE,mBAAmB,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,gBAAgB,CAAC,CAAC;IAC7D,SAAS,CAAC,EAAE,SAAS,CAAC;CACvB,CAAC;AAEF,eAAO,MAAM,WAAW,GAAI,CAAC,SAAS,QAAQ,EAAE,CAAC,SAAS,KAAK,EAAE,+EAM9D,gBAAgB,CAAC,CAAC,EAAE,CAAC,CAAC,yBAGX,MAAM,YAAY,MAAM,qBA8BxB,MAAM,eAAe,MAAM,UA8BxC,CAAC"}