@rowsncolumns/spreadsheet-state 28.0.66

package/dist/cjs/hooks/use-on-show-column.js

@@ -0,0 +1,96 @@
+import { __read, __values } from "tslib";
+import { Direction } from "@rowsncolumns/grid";
+import { DEFAULT_ROW_COUNT, useSpreadsheet } from "@rowsncolumns/spreadsheet";
+import { produceWithPatches } from "immer";
+import { useCallback } from "react";
+import { useShowError } from "../atoms/error-state.atom";
+import { SHEET_PROTECTION_ERROR_TITLE, useCanEditSheet, useCanPerformSheetAction, } from "./use-can-edit-cellrange";
+export var useOnShowColumn = function (_a) {
+    var createHistory = _a.createHistory, onChangeActiveCell = _a.onChangeActiveCell, onChangeSelections = _a.onChangeSelections, onChangeSheets = _a.onChangeSheets, _b = _a.rowCount, rowCount = _b === void 0 ? DEFAULT_ROW_COUNT : _b, onCommand = _a.onCommand;
+    var getNextFocusableCell = useSpreadsheet().getNextFocusableCell;
+    var canEditSheet = useCanEditSheet();
+    var canPerformSheetAction = useCanPerformSheetAction();
+    var showError = useShowError();
+    return useCallback(function (sheetId, columnIndexes) {
+        var _a;
+        if (!canEditSheet(sheetId)) {
+            console.debug("This range is protected, users cannot edit this cell range.");
+            return;
+        }
+        if (!canPerformSheetAction(sheetId, "formatColumns")) {
+            showError({
+                title: SHEET_PROTECTION_ERROR_TITLE,
+                message: "You can't hide or show columns on a protected sheet.",
+            });
+            return;
+        }
+        var saveHistory = createHistory();
+        var firstColumnIndex = columnIndexes[0];
+        var newActiveCell = (_a = getNextFocusableCell === null || getNextFocusableCell === void 0 ? void 0 : getNextFocusableCell(sheetId, { rowIndex: 0, columnIndex: firstColumnIndex }, Direction.Down, false)) !== null && _a !== void 0 ? _a : { rowIndex: 1, columnIndex: firstColumnIndex };
+        var newSelections = [
+            {
+                range: {
+                    startRowIndex: 1,
+                    startColumnIndex: firstColumnIndex,
+                    endColumnIndex: firstColumnIndex + columnIndexes.length - 1,
+                    endRowIndex: rowCount,
+                },
+            },
+        ];
+        // Add to sheets
+        onChangeSheets(function (prevSheets) {
+            var _a = __read(produceWithPatches(prevSheets, function (draft) {
+                var e_1, _a;
+                var sheet = draft.find(function (sheet) { return sheet.sheetId === sheetId; });
+                if (sheet) {
+                    if (!sheet.columnMetadata) {
+                        sheet.columnMetadata = [];
+                    }
+                    try {
+                        for (var columnIndexes_1 = __values(columnIndexes), columnIndexes_1_1 = columnIndexes_1.next(); !columnIndexes_1_1.done; columnIndexes_1_1 = columnIndexes_1.next()) {
+                            var columnIndex = columnIndexes_1_1.value;
+                            if (!sheet.columnMetadata[columnIndex]) {
+                                sheet.columnMetadata[columnIndex] =
+                                    {};
+                            }
+                            sheet.columnMetadata[columnIndex].hiddenByUser = false;
+                        }
+                    }
+                    catch (e_1_1) { e_1 = { error: e_1_1 }; }
+                    finally {
+                        try {
+                            if (columnIndexes_1_1 && !columnIndexes_1_1.done && (_a = columnIndexes_1.return)) _a.call(columnIndexes_1);
+                        }
+                        finally { if (e_1) throw e_1.error; }
+                    }
+                }
+            }), 3), nextState = _a[0], patches = _a[1], inversePatches = _a[2];
+            // Save to history
+            saveHistory({
+                sheets: { patches: patches, inversePatches: inversePatches },
+                sheetId: { undo: sheetId, redo: sheetId },
+            });
+            return nextState;
+        });
+        // Change active cell
+        onChangeActiveCell(sheetId, newActiveCell);
+        // Change selections
+        onChangeSelections(sheetId, newSelections);
+        onCommand === null || onCommand === void 0 ? void 0 : onCommand({
+            command: "show-column",
+            sheetId: sheetId,
+            columnIndexes: columnIndexes,
+        });
+    }, [
+        rowCount,
+        createHistory,
+        onChangeActiveCell,
+        onChangeSelections,
+        onChangeSheets,
+        getNextFocusableCell,
+        canEditSheet,
+        canPerformSheetAction,
+        showError,
+        onCommand,
+    ]);
+};

package/dist/cjs/hooks/use-on-show-row.d.ts

@@ -0,0 +1,22 @@
+import type { CellInterface, SelectionArea } from "@rowsncolumns/common-types";
+import type { CellData, SelectionAttributes, Sheet } from "@rowsncolumns/spreadsheet";
+import type { OnCommand } from "../commands";
+import type { UseSpreadsheetProps } from "./use-spreadsheet-state";
+import type { SpreadsheetPatch } from "./use-undo-redo";
+type UseOnShowRowProps<T extends CellData, S extends Sheet> = {
+    onChangeSheets: UseSpreadsheetProps<T, S>["onChangeSheets"];
+    onChangeActiveCell(sheetId: number, cell: CellInterface): void;
+    onChangeSelections(sheetId: number, selections: SelectionArea<SelectionAttributes>[]): void;
+    createHistory(): (patches: SpreadsheetPatch) => void;
+    columnCount: number | undefined;
+    onCommand?: OnCommand;
+    /**
+     * Called after row visibility changed. Values are untouched so the
+     * calc graph sees nothing dirty, but visibility-aware formulas
+     * (SUBTOTAL) must recalculate.
+     */
+    onRowVisibilityChange?: () => void;
+};
+export declare const useOnShowRow: <T extends CellData, S extends Sheet>({ createHistory, onChangeActiveCell, onChangeSelections, onChangeSheets, columnCount, onCommand, onRowVisibilityChange, }: UseOnShowRowProps<T, S>) => (sheetId: number, rowIndexes: number[]) => void;
+export {};
+//# sourceMappingURL=use-on-show-row.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"use-on-show-row.d.ts","sourceRoot":"","sources":["../../../hooks/use-on-show-row.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,aAAa,EAAE,MAAM,4BAA4B,CAAC;AAE/E,OAAO,KAAK,EACV,QAAQ,EAER,mBAAmB,EACnB,KAAK,EACN,MAAM,2BAA2B,CAAC;AASnC,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AAO7C,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,yBAAyB,CAAC;AACnE,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,iBAAiB,CAAC;AAExD,KAAK,iBAAiB,CAAC,CAAC,SAAS,QAAQ,EAAE,CAAC,SAAS,KAAK,IAAI;IAC5D,cAAc,EAAE,mBAAmB,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,gBAAgB,CAAC,CAAC;IAC5D,kBAAkB,CAAC,OAAO,EAAE,MAAM,EAAE,IAAI,EAAE,aAAa,GAAG,IAAI,CAAC;IAC/D,kBAAkB,CAChB,OAAO,EAAE,MAAM,EACf,UAAU,EAAE,aAAa,CAAC,mBAAmB,CAAC,EAAE,GAC/C,IAAI,CAAC;IACR,aAAa,IAAI,CAAC,OAAO,EAAE,gBAAgB,KAAK,IAAI,CAAC;IACrD,WAAW,EAAE,MAAM,GAAG,SAAS,CAAC;IAChC,SAAS,CAAC,EAAE,SAAS,CAAC;IACtB;;;;OAIG;IACH,qBAAqB,CAAC,EAAE,MAAM,IAAI,CAAC;CACpC,CAAC;AAEF,eAAO,MAAM,YAAY,GAAI,CAAC,SAAS,QAAQ,EAAE,CAAC,SAAS,KAAK,EAAE,2HAQ/D,iBAAiB,CAAC,CAAC,EAAE,CAAC,CAAC,eAMZ,MAAM,cAAc,MAAM,EAAE,SA4FzC,CAAC"}

package/dist/cjs/hooks/use-on-show-row.js

@@ -0,0 +1,99 @@
+import { __read, __values } from "tslib";
+import { Direction } from "@rowsncolumns/grid";
+import { DEFAULT_COLUMN_COUNT, useSpreadsheet, } from "@rowsncolumns/spreadsheet";
+import { produceWithPatches } from "immer";
+import { useCallback } from "react";
+import { useShowError } from "../atoms/error-state.atom";
+import { SHEET_PROTECTION_ERROR_TITLE, useCanEditSheet, useCanPerformSheetAction, } from "./use-can-edit-cellrange";
+export var useOnShowRow = function (_a) {
+    var createHistory = _a.createHistory, onChangeActiveCell = _a.onChangeActiveCell, onChangeSelections = _a.onChangeSelections, onChangeSheets = _a.onChangeSheets, _b = _a.columnCount, columnCount = _b === void 0 ? DEFAULT_COLUMN_COUNT : _b, onCommand = _a.onCommand, onRowVisibilityChange = _a.onRowVisibilityChange;
+    var getNextFocusableCell = useSpreadsheet().getNextFocusableCell;
+    var canEditSheet = useCanEditSheet();
+    var canPerformSheetAction = useCanPerformSheetAction();
+    var showError = useShowError();
+    return useCallback(function (sheetId, rowIndexes) {
+        var _a;
+        if (!canEditSheet(sheetId)) {
+            console.debug("This range is protected, users cannot edit this cell range.");
+            return;
+        }
+        if (!canPerformSheetAction(sheetId, "formatRows")) {
+            showError({
+                title: SHEET_PROTECTION_ERROR_TITLE,
+                message: "You can't hide or show rows on a protected sheet.",
+            });
+            return;
+        }
+        var saveHistory = createHistory();
+        var firstRowIndex = rowIndexes[0];
+        var newActiveCell = (_a = getNextFocusableCell === null || getNextFocusableCell === void 0 ? void 0 : getNextFocusableCell(sheetId, { rowIndex: firstRowIndex, columnIndex: 0 }, Direction.Right, false)) !== null && _a !== void 0 ? _a : { rowIndex: firstRowIndex, columnIndex: 1 };
+        var newSelections = [
+            {
+                range: {
+                    startRowIndex: firstRowIndex,
+                    startColumnIndex: 1,
+                    endColumnIndex: columnCount,
+                    endRowIndex: firstRowIndex + rowIndexes.length - 1,
+                },
+            },
+        ];
+        // Add to sheets
+        onChangeSheets(function (prevSheets) {
+            var _a = __read(produceWithPatches(prevSheets, function (draft) {
+                var e_1, _a;
+                var sheet = draft.find(function (sheet) { return sheet.sheetId === sheetId; });
+                if (sheet) {
+                    if (!sheet.rowMetadata) {
+                        sheet.rowMetadata = [];
+                    }
+                    try {
+                        for (var rowIndexes_1 = __values(rowIndexes), rowIndexes_1_1 = rowIndexes_1.next(); !rowIndexes_1_1.done; rowIndexes_1_1 = rowIndexes_1.next()) {
+                            var rowIndex = rowIndexes_1_1.value;
+                            if (!sheet.rowMetadata[rowIndex]) {
+                                sheet.rowMetadata[rowIndex] =
+                                    {};
+                            }
+                            sheet.rowMetadata[rowIndex].hiddenByUser = false;
+                        }
+                    }
+                    catch (e_1_1) { e_1 = { error: e_1_1 }; }
+                    finally {
+                        try {
+                            if (rowIndexes_1_1 && !rowIndexes_1_1.done && (_a = rowIndexes_1.return)) _a.call(rowIndexes_1);
+                        }
+                        finally { if (e_1) throw e_1.error; }
+                    }
+                }
+            }), 3), nextState = _a[0], patches = _a[1], inversePatches = _a[2];
+            // Save to history
+            saveHistory({
+                sheets: { patches: patches, inversePatches: inversePatches },
+                sheetId: { undo: sheetId, redo: sheetId },
+            });
+            return nextState;
+        });
+        // Change active cell
+        onChangeActiveCell(sheetId, newActiveCell);
+        // Change selections
+        onChangeSelections(sheetId, newSelections);
+        // Unhiding rows affects SUBTOTAL(101-111) results
+        onRowVisibilityChange === null || onRowVisibilityChange === void 0 ? void 0 : onRowVisibilityChange();
+        onCommand === null || onCommand === void 0 ? void 0 : onCommand({
+            command: "show-row",
+            sheetId: sheetId,
+            rowIndexes: rowIndexes,
+        });
+    }, [
+        columnCount,
+        createHistory,
+        onChangeActiveCell,
+        onChangeSelections,
+        onChangeSheets,
+        getNextFocusableCell,
+        canEditSheet,
+        canPerformSheetAction,
+        showError,
+        onCommand,
+        onRowVisibilityChange,
+    ]);
+};

package/dist/cjs/hooks/use-on-sort-column.d.ts

@@ -0,0 +1,53 @@
+import { type CellData, type SortOrder, type SpreadsheetTheme } from "@rowsncolumns/spreadsheet";
+import type { OnCommand } from "../commands";
+import type { useCalculation } from "./use-calculation";
+import type { useSheetProperties } from "./use-sheet-properties";
+import type { UseSpreadsheetProps } from "./use-spreadsheet-state";
+import type { SharedStringRegistry } from "./use-ss-registry";
+import type { SpreadsheetPatch } from "./use-undo-redo";
+import { type DimensionSortSpec } from "./utils/sort-rows";
+export type SortColumnOptions = Pick<DimensionSortSpec, "sortBy" | "sortColor" | "sortIcon" | "customList">;
+/**
+ * An additional ("then by") sort level for multi-level column sort. Each
+ * level pins its own absolute `columnIndex`, direction, and color/icon/
+ * custom-list options. Levels are applied as tiebreakers in order after
+ * the primary column passed to the callback.
+ */
+export type SortColumnLevel = {
+    columnIndex: number;
+    sortOrder: SortOrder;
+} & SortColumnOptions;
+export type UseOnSortColumnProps<T extends CellData> = {
+    rowCount: number;
+    columnCount: number;
+    locale?: string;
+    sharedStringRegistry?: SharedStringRegistry;
+    createHistory(): (patches: SpreadsheetPatch) => void;
+    enqueueCalculation: ReturnType<typeof useCalculation>["enqueueCalculation"];
+    enqueueStructureChange?: ReturnType<typeof useCalculation>["enqueueStructureChange"];
+    enqueueGraphOperation: ReturnType<typeof useCalculation>["enqueueGraphOperation"];
+    onChangeSheetData: UseSpreadsheetProps<T>["onChangeSheetData"];
+    isHiddenRow(sheetId: number, rowIndex: number): boolean;
+    getDependents: ReturnType<typeof useCalculation>["getDependents"];
+    getFrozenRowCount(sheetId: number): number;
+    getSheetName(sheetId: number): string;
+    /**
+     * Optional — needed when callers pass `sortBy: "cellColor" | "fontColor" | "icon"`.
+     * Without it those sort modes are silently treated as `sortBy: "value"`.
+     */
+    getEffectiveFormat?: ReturnType<typeof useSheetProperties>["getEffectiveFormat"];
+    /**
+     * Required for color sort modes — used to resolve theme-indexed colors
+     * to the same hex the renderer paints before comparison.
+     */
+    theme: SpreadsheetTheme;
+    enableSortTimingLogs?: boolean;
+    onCommand?: OnCommand;
+};
+/**
+ * Sorts a column
+ * @param param0
+ * @returns
+ */
+export declare const useOnSortColumn: <T extends CellData>({ rowCount, columnCount, locale, sharedStringRegistry, createHistory, enqueueCalculation, enqueueStructureChange, enqueueGraphOperation, onChangeSheetData, isHiddenRow, getDependents, getFrozenRowCount, getSheetName, getEffectiveFormat, theme, enableSortTimingLogs, onCommand, }: UseOnSortColumnProps<T>) => (sheetId: number, sortedColumnIndex: number, sortOrder: SortOrder, options?: SortColumnOptions, additionalLevels?: SortColumnLevel[]) => void;
+//# sourceMappingURL=use-on-sort-column.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"use-on-sort-column.d.ts","sourceRoot":"","sources":["../../../hooks/use-on-sort-column.ts"],"names":[],"mappings":"AAKA,OAAO,EACL,KAAK,QAAQ,EAIb,KAAK,SAAS,EACd,KAAK,gBAAgB,EACtB,MAAM,2BAA2B,CAAC;AAOnC,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AAG7C,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,mBAAmB,CAAC;AAOxD,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,wBAAwB,CAAC;AACjE,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,EACL,KAAK,iBAAiB,EAEvB,MAAM,mBAAmB,CAAC;AAE3B,MAAM,MAAM,iBAAiB,GAAG,IAAI,CAClC,iBAAiB,EACjB,QAAQ,GAAG,WAAW,GAAG,UAAU,GAAG,YAAY,CACnD,CAAC;AAEF;;;;;GAKG;AACH,MAAM,MAAM,eAAe,GAAG;IAC5B,WAAW,EAAE,MAAM,CAAC;IACpB,SAAS,EAAE,SAAS,CAAC;CACtB,GAAG,iBAAiB,CAAC;AA+BtB,MAAM,MAAM,oBAAoB,CAAC,CAAC,SAAS,QAAQ,IAAI;IACrD,QAAQ,EAAE,MAAM,CAAC;IACjB,WAAW,EAAE,MAAM,CAAC;IACpB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,oBAAoB,CAAC,EAAE,oBAAoB,CAAC;IAC5C,aAAa,IAAI,CAAC,OAAO,EAAE,gBAAgB,KAAK,IAAI,CAAC;IACrD,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,qBAAqB,EAAE,UAAU,CAC/B,OAAO,cAAc,CACtB,CAAC,uBAAuB,CAAC,CAAC;IAC3B,iBAAiB,EAAE,mBAAmB,CAAC,CAAC,CAAC,CAAC,mBAAmB,CAAC,CAAC;IAC/D,WAAW,CAAC,OAAO,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC;IACxD,aAAa,EAAE,UAAU,CAAC,OAAO,cAAc,CAAC,CAAC,eAAe,CAAC,CAAC;IAClE,iBAAiB,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,CAAC;IAC3C,YAAY,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,CAAC;IACtC;;;OAGG;IACH,kBAAkB,CAAC,EAAE,UAAU,CAC7B,OAAO,kBAAkB,CAC1B,CAAC,oBAAoB,CAAC,CAAC;IACxB;;;OAGG;IACH,KAAK,EAAE,gBAAgB,CAAC;IACxB,oBAAoB,CAAC,EAAE,OAAO,CAAC;IAC/B,SAAS,CAAC,EAAE,SAAS,CAAC;CACvB,CAAC;AAEF;;;;GAIG;AACH,eAAO,MAAM,eAAe,GAAI,CAAC,SAAS,QAAQ,EAAE,wRAkBjD,oBAAoB,CAAC,CAAC,CAAC,eAMX,MAAM,qBACI,MAAM,aACd,SAAS,YACV,iBAAiB,qBAMR,eAAe,EAAE,SA+TzC,CAAC"}

package/dist/cjs/hooks/use-on-sort-column.js

@@ -0,0 +1,300 @@
+import { __read, __spreadArray, __values } from "tslib";
+import { isStaticNode, } from "@rowsncolumns/dag";
+import { getCellUserEnteredValue, getExtendedValueFormula, getStringifiedColor, } from "@rowsncolumns/spreadsheet";
+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 { useShowError } from "../atoms/error-state.atom";
+import { SHEET_PROTECTION_ERROR_TITLE, useCanEditSheet, useCanPerformSheetAction, } from "./use-can-edit-cellrange";
+import { sortRowEntriesByFrozenState, } from "./utils/sort-rows";
+var buildSortValue = function (options, fallbackValue, getEffectiveFormat, theme, sheetId, rowIndex, columnIndex) {
+    var _a, _b;
+    var sortBy = (_a = options === null || options === void 0 ? void 0 : options.sortBy) !== null && _a !== void 0 ? _a : "value";
+    if (sortBy === "value")
+        return fallbackValue;
+    var fmt = getEffectiveFormat === null || getEffectiveFormat === void 0 ? void 0 : getEffectiveFormat(sheetId, rowIndex, columnIndex);
+    // Resolve theme-indexed colors to the same hex the renderer paints so
+    // the comparator in sort-rows.ts can use plain string equality.
+    if (sortBy === "cellColor")
+        return getStringifiedColor(fmt === null || fmt === void 0 ? void 0 : fmt.backgroundColor, theme);
+    if (sortBy === "fontColor")
+        return getStringifiedColor((_b = fmt === null || fmt === void 0 ? void 0 : fmt.textFormat) === null || _b === void 0 ? void 0 : _b.color, theme);
+    if (sortBy === "icon") {
+        var icon = fmt === null || fmt === void 0 ? void 0 : fmt.conditionalIcon;
+        return icon
+            ? { iconSet: icon.iconSet, iconId: icon.iconId }
+            : undefined;
+    }
+    return fallbackValue;
+};
+/**
+ * Sorts a column
+ * @param param0
+ * @returns
+ */
+export var useOnSortColumn = function (_a) {
+    var rowCount = _a.rowCount, columnCount = _a.columnCount, locale = _a.locale, sharedStringRegistry = _a.sharedStringRegistry, createHistory = _a.createHistory, enqueueCalculation = _a.enqueueCalculation, enqueueStructureChange = _a.enqueueStructureChange, enqueueGraphOperation = _a.enqueueGraphOperation, onChangeSheetData = _a.onChangeSheetData, isHiddenRow = _a.isHiddenRow, getDependents = _a.getDependents, getFrozenRowCount = _a.getFrozenRowCount, getSheetName = _a.getSheetName, getEffectiveFormat = _a.getEffectiveFormat, theme = _a.theme, enableSortTimingLogs = _a.enableSortTimingLogs, onCommand = _a.onCommand;
+    var canEditSheet = useCanEditSheet();
+    var canPerformSheetAction = useCanPerformSheetAction();
+    var showError = useShowError();
+    return useCallback(function (sheetId, sortedColumnIndex, sortOrder, options, 
+    /**
+     * Optional "then by" levels for multi-level sort. When provided,
+     * each level's column contributes a tiebreaker after the primary
+     * column. Omitting this keeps the single-column behavior identical.
+     */
+    additionalLevels) {
+        if (!canEditSheet(sheetId)) {
+            console.debug("This range is protected, users cannot edit this cell range.");
+            return;
+        }
+        if (!canPerformSheetAction(sheetId, "sort")) {
+            showError({
+                title: SHEET_PROTECTION_ERROR_TITLE,
+                message: "You can't sort a protected sheet.",
+            });
+            return;
+        }
+        var now = typeof performance !== "undefined" &&
+            typeof performance.now === "function"
+            ? performance.now.bind(performance)
+            : Date.now;
+        var activeSheetName = getSheetName(sheetId);
+        // We need to track this for history. Precedent cells
+        var recalcCells = new Map();
+        // History
+        var saveHistory = createHistory();
+        var frozenRowCount = getFrozenRowCount(sheetId);
+        enqueueStructureChange === null || enqueueStructureChange === void 0 ? void 0 : enqueueStructureChange({
+            kind: "invalidate-range",
+            sheetId: sheetId,
+            startRowIndex: 1,
+            endRowIndex: rowCount,
+            startColumnIndex: 1,
+            endColumnIndex: columnCount,
+        });
+        // Update sheet data
+        onChangeSheetData === null || onChangeSheetData === void 0 ? void 0 : onChangeSheetData(function (prevSheetData) {
+            var overallStart = now();
+            var buildMs = 0;
+            var sortMs = 0;
+            var applyMs = 0;
+            var _a = __read(produceWithPatches(prevSheetData, function (draft) {
+                var e_1, _a;
+                var _b, _c, _d, _e, _f;
+                var sheet = createSheetDraft(draft, sheetId);
+                var startRowIndex = 1;
+                var startColumnIndex = 1;
+                var rowCount = sheet.length;
+                var rowEntries = [];
+                var rowSnapshots = new Map();
+                var buildStart = now();
+                var maxColumnCount = 0;
+                var _loop_1 = function (rowIndex) {
+                    var e_2, _g;
+                    // Ignore hidden rows
+                    if (isHiddenRow(sheetId, rowIndex)) {
+                        return "continue";
+                    }
+                    var rowValue = sheet[rowIndex];
+                    var columnCount_1 = (_c = (_b = rowValue === null || rowValue === void 0 ? void 0 : rowValue.values) === null || _b === void 0 ? void 0 : _b.length) !== null && _c !== void 0 ? _c : 0;
+                    maxColumnCount = Math.max(maxColumnCount, columnCount_1);
+                    rowSnapshots.set(rowIndex, ((_d = rowValue === null || rowValue === void 0 ? void 0 : rowValue.values) !== null && _d !== void 0 ? _d : []).slice());
+                    // Build one sort value per level: the primary column first,
+                    // then each "then by" column in order.
+                    var buildLevelValue = function (columnIndex, levelOptions) {
+                        var _a, _b;
+                        var sortCellData = (_a = rowValue === null || rowValue === void 0 ? void 0 : rowValue.values) === null || _a === void 0 ? void 0 : _a[columnIndex];
+                        var sortCell = new SheetCell(sheetId, { rowIndex: rowIndex, columnIndex: columnIndex }, sortCellData, { locale: locale, sharedStringRegistry: sharedStringRegistry });
+                        var fallbackValue = (_b = sortCell.getEffectiveValue()) !== null && _b !== void 0 ? _b : sortCell.formattedValue;
+                        return buildSortValue(levelOptions, fallbackValue, getEffectiveFormat, theme, sheetId, rowIndex, columnIndex);
+                    };
+                    var sortValues = [
+                        buildLevelValue(sortedColumnIndex, options),
+                    ];
+                    try {
+                        for (var _h = (e_2 = void 0, __values(additionalLevels !== null && additionalLevels !== void 0 ? additionalLevels : [])), _j = _h.next(); !_j.done; _j = _h.next()) {
+                            var level = _j.value;
+                            sortValues.push(buildLevelValue(level.columnIndex, level));
+                        }
+                    }
+                    catch (e_2_1) { e_2 = { error: e_2_1 }; }
+                    finally {
+                        try {
+                            if (_j && !_j.done && (_g = _h.return)) _g.call(_h);
+                        }
+                        finally { if (e_2) throw e_2.error; }
+                    }
+                    rowEntries.push({ rowIndex: rowIndex, sortValues: sortValues });
+                };
+                for (var rowIndex = startRowIndex; rowIndex <= rowCount; rowIndex++) {
+                    _loop_1(rowIndex);
+                }
+                buildMs = now() - buildStart;
+                // Sort data
+                var sortStart = now();
+                // Primary spec, then one spec per "then by" level. The order
+                // matches the sortValues built above so the comparator pairs
+                // each value with its spec.
+                var specs = __spreadArray([
+                    {
+                        sortOrder: sortOrder,
+                        sortBy: (_e = options === null || options === void 0 ? void 0 : options.sortBy) !== null && _e !== void 0 ? _e : "value",
+                        // Pre-resolve the target color the same way the cell sort
+                        // values are resolved, so sort-rows.ts can compare strings.
+                        sortColor: getStringifiedColor(options === null || options === void 0 ? void 0 : options.sortColor, theme),
+                        sortIcon: options === null || options === void 0 ? void 0 : options.sortIcon,
+                        customList: options === null || options === void 0 ? void 0 : options.customList,
+                    }
+                ], __read((additionalLevels !== null && additionalLevels !== void 0 ? additionalLevels : []).map(function (level) {
+                    var _a;
+                    return ({
+                        sortOrder: level.sortOrder,
+                        sortBy: (_a = level.sortBy) !== null && _a !== void 0 ? _a : "value",
+                        sortColor: getStringifiedColor(level.sortColor, theme),
+                        sortIcon: level.sortIcon,
+                        customList: level.customList,
+                    });
+                })), false);
+                var sortedEntries = sortRowEntriesByFrozenState(rowEntries, frozenRowCount, specs);
+                sortMs = now() - sortStart;
+                // Counter for how many rows we have skipped
+                var skippedRow = 0;
+                var applyStart = now();
+                for (var rowIndex = startRowIndex; rowIndex <= sortedEntries.length; rowIndex++) {
+                    // Ignore hidden rows
+                    if (isHiddenRow(sheetId, rowIndex)) {
+                        skippedRow++;
+                        continue;
+                    }
+                    var sourceRow = sortedEntries[rowIndex - skippedRow - startRowIndex];
+                    if (!sourceRow) {
+                        continue;
+                    }
+                    if (sourceRow.rowIndex === rowIndex) {
+                        continue;
+                    }
+                    var sourceRowValues = (_f = rowSnapshots.get(sourceRow.rowIndex)) !== null && _f !== void 0 ? _f : [];
+                    var nextRowValues = [];
+                    for (var columnIndex = startColumnIndex; columnIndex <= maxColumnCount; columnIndex++) {
+                        // const currentSheet = createSheetDraft(draft, sheetId, rowIndex);
+                        var sourceCellData = sourceRowValues[columnIndex];
+                        var originalPosition = {
+                            sheetId: sheetId,
+                            rowIndex: sourceRow.rowIndex,
+                            columnIndex: columnIndex,
+                        };
+                        var previousPosition = void 0;
+                        if (!sourceCellData) {
+                            nextRowValues[columnIndex] = sourceCellData;
+                            continue;
+                        }
+                        var hasFormula = !!getExtendedValueFormula(getCellUserEnteredValue(sourceCellData));
+                        if (!hasFormula) {
+                            nextRowValues[columnIndex] = sourceCellData;
+                            continue;
+                        }
+                        var sheetCell = new SheetCell(sheetId, { rowIndex: sourceRow.rowIndex, columnIndex: columnIndex }, sourceCellData, { locale: locale, sharedStringRegistry: sharedStringRegistry });
+                        var dependents = getDependents(originalPosition);
+                        sheetCell.moveFormula(sheetCell.coords, {
+                            rowIndex: rowIndex,
+                            columnIndex: columnIndex,
+                        }, activeSheetName, {
+                            preserveAbsolutes: true, // keep absolute refs fixed during sort
+                        });
+                        previousPosition = originalPosition;
+                        // Update graph / dirty cell
+                        if (hasFormula) {
+                            enqueueGraphOperation({
+                                type: "add",
+                                position: {
+                                    sheetId: sheetId,
+                                    rowIndex: rowIndex,
+                                    columnIndex: columnIndex,
+                                },
+                                previousPosition: previousPosition,
+                            });
+                            // Add to recalc cells
+                            recalcCells.set(createSheetCellIdentifier(sheetId, rowIndex, columnIndex), {
+                                rowIndex: rowIndex,
+                                columnIndex: columnIndex,
+                                sheetId: sheetId,
+                            });
+                        }
+                        nextRowValues[columnIndex] =
+                            sheetCell === null || sheetCell === void 0 ? void 0 : sheetCell.getCellData();
+                        try {
+                            for (var dependents_1 = (e_1 = void 0, __values(dependents)), dependents_1_1 = dependents_1.next(); !dependents_1_1.done; dependents_1_1 = dependents_1.next()) {
+                                var dependent = dependents_1_1.value;
+                                if (isStaticNode(dependent)) {
+                                    continue;
+                                }
+                                enqueueCalculation({
+                                    type: "dirty",
+                                    position: dependent.position,
+                                });
+                                recalcCells.set(createSheetCellIdentifier(dependent.position.sheetId, dependent.position.rowIndex, dependent.position.columnIndex), dependent.position);
+                            }
+                        }
+                        catch (e_1_1) { e_1 = { error: e_1_1 }; }
+                        finally {
+                            try {
+                                if (dependents_1_1 && !dependents_1_1.done && (_a = dependents_1.return)) _a.call(dependents_1);
+                            }
+                            finally { if (e_1) throw e_1.error; }
+                        }
+                    }
+                    var currentSheet = createSheetDraft(draft, sheetId, rowIndex);
+                    currentSheet[rowIndex].values = nextRowValues;
+                }
+                applyMs = now() - applyStart;
+            }), 3), nextState = _a[0], patches = _a[1], inversePatches = _a[2];
+            var overallMs = now() - overallStart;
+            if (enableSortTimingLogs) {
+                console.debug("sort-column timings", {
+                    sheetId: sheetId,
+                    sortedColumnIndex: sortedColumnIndex,
+                    sortOrder: sortOrder,
+                    buildMs: buildMs,
+                    sortMs: sortMs,
+                    applyMs: applyMs,
+                    overallMs: overallMs,
+                });
+            }
+            // Save history
+            saveHistory({
+                sheetData: { patches: patches, inversePatches: inversePatches },
+                recalcCells: { undo: recalcCells, redo: recalcCells },
+            });
+            return nextState;
+        });
+        onCommand === null || onCommand === void 0 ? void 0 : onCommand({
+            command: "sort-column",
+            sheetId: sheetId,
+            sortedColumnIndex: sortedColumnIndex,
+            sortOrder: sortOrder,
+        });
+    }, [
+        rowCount,
+        columnCount,
+        locale,
+        sharedStringRegistry,
+        createHistory,
+        enqueueCalculation,
+        enqueueStructureChange,
+        enqueueGraphOperation,
+        onChangeSheetData,
+        isHiddenRow,
+        getDependents,
+        getFrozenRowCount,
+        canEditSheet,
+        canPerformSheetAction,
+        showError,
+        getSheetName,
+        getEffectiveFormat,
+        enableSortTimingLogs,
+        onCommand,
+    ]);
+};

package/dist/cjs/hooks/use-on-sort-range.d.ts

@@ -0,0 +1,42 @@
+import type { SelectionArea } from "@rowsncolumns/common-types";
+import { type CellData, type SelectionAttributes, type SortOrder, type SpreadsheetTheme } from "@rowsncolumns/spreadsheet";
+import type { OnCommand } from "../commands";
+import type { useCalculation } from "./use-calculation";
+import type { useSheetProperties } from "./use-sheet-properties";
+import type { UseSpreadsheetProps } from "./use-spreadsheet-state";
+import type { SharedStringRegistry } from "./use-ss-registry";
+import type { SpreadsheetPatch } from "./use-undo-redo";
+import { type DimensionSortSpec } from "./utils/sort-rows";
+export type UseOnSortRangeProps<T extends CellData> = {
+    locale?: string;
+    sharedStringRegistry?: SharedStringRegistry;
+    createHistory(): (patches: SpreadsheetPatch) => void;
+    enqueueStructureChange?: ReturnType<typeof useCalculation>["enqueueStructureChange"];
+    enqueueGraphOperation: ReturnType<typeof useCalculation>["enqueueGraphOperation"];
+    enqueueCalculation: ReturnType<typeof useCalculation>["enqueueCalculation"];
+    onChangeSheetData: UseSpreadsheetProps<T>["onChangeSheetData"];
+    isHiddenRow(sheetId: number, rowIndex: number): boolean;
+    getDependents: ReturnType<typeof useCalculation>["getDependents"];
+    getFrozenRowCount(sheetId: number): number;
+    getSheetName(sheetId: number): string;
+    /**
+     * Optional — needed when callers pass per-column specs using
+     * `sortBy: "cellColor" | "fontColor" | "icon"`. Without it those sort
+     * modes are silently treated as `sortBy: "value"`.
+     */
+    getEffectiveFormat?: ReturnType<typeof useSheetProperties>["getEffectiveFormat"];
+    /**
+     * Required for color sort modes — used to resolve theme-indexed colors
+     * to the same hex the renderer paints before comparison.
+     */
+    theme: SpreadsheetTheme;
+    onCommand?: OnCommand;
+};
+/**
+ * Sorts a column range.
+ * This does not expand the selection
+ * @param param0
+ * @returns
+ */
+export declare const useOnSortRange: <T extends CellData>({ locale, sharedStringRegistry, createHistory, enqueueStructureChange, enqueueGraphOperation, enqueueCalculation, onChangeSheetData, getDependents, isHiddenRow, getFrozenRowCount, getSheetName, getEffectiveFormat, theme, onCommand, }: UseOnSortRangeProps<T>) => (sheetId: number, selections: SelectionArea<SelectionAttributes>[], sortOrder: SortOrder, specs?: DimensionSortSpec[]) => void;
+//# sourceMappingURL=use-on-sort-range.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"use-on-sort-range.d.ts","sourceRoot":"","sources":["../../../hooks/use-on-sort-range.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,4BAA4B,CAAC;AAGhE,OAAO,EACL,KAAK,QAAQ,EAIb,KAAK,mBAAmB,EACxB,KAAK,SAAS,EACd,KAAK,gBAAgB,EACtB,MAAM,2BAA2B,CAAC;AAOnC,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AAS7C,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,mBAAmB,CAAC;AACxD,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,wBAAwB,CAAC;AACjE,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,EACL,KAAK,iBAAiB,EAEvB,MAAM,mBAAmB,CAAC;AAE3B,MAAM,MAAM,mBAAmB,CAAC,CAAC,SAAS,QAAQ,IAAI;IACpD,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,oBAAoB,CAAC,EAAE,oBAAoB,CAAC;IAC5C,aAAa,IAAI,CAAC,OAAO,EAAE,gBAAgB,KAAK,IAAI,CAAC;IACrD,sBAAsB,CAAC,EAAE,UAAU,CACjC,OAAO,cAAc,CACtB,CAAC,wBAAwB,CAAC,CAAC;IAC5B,qBAAqB,EAAE,UAAU,CAC/B,OAAO,cAAc,CACtB,CAAC,uBAAuB,CAAC,CAAC;IAC3B,kBAAkB,EAAE,UAAU,CAAC,OAAO,cAAc,CAAC,CAAC,oBAAoB,CAAC,CAAC;IAC5E,iBAAiB,EAAE,mBAAmB,CAAC,CAAC,CAAC,CAAC,mBAAmB,CAAC,CAAC;IAC/D,WAAW,CAAC,OAAO,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC;IACxD,aAAa,EAAE,UAAU,CAAC,OAAO,cAAc,CAAC,CAAC,eAAe,CAAC,CAAC;IAClE,iBAAiB,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,CAAC;IAC3C,YAAY,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,CAAC;IACtC;;;;OAIG;IACH,kBAAkB,CAAC,EAAE,UAAU,CAC7B,OAAO,kBAAkB,CAC1B,CAAC,oBAAoB,CAAC,CAAC;IACxB;;;OAGG;IACH,KAAK,EAAE,gBAAgB,CAAC;IACxB,SAAS,CAAC,EAAE,SAAS,CAAC;CACvB,CAAC;AAEF;;;;;GAKG;AACH,eAAO,MAAM,cAAc,GAAI,CAAC,SAAS,QAAQ,EAAE,2OAehD,mBAAmB,CAAC,CAAC,CAAC,eAMV,MAAM,cACH,aAAa,CAAC,mBAAmB,CAAC,EAAE,aACrC,SAAS,UAQZ,iBAAiB,EAAE,SA8ShC,CAAC"}