@revolist/revogrid 4.22.0 → 4.23.0

package/dist/revo-grid/{throttle-BEjFQa2l.js → throttle-CaUDyxyU.js}

@@ -1,8 +1,8 @@
 /*!
  * Built by Revolist OU ❤️
  */
-import { q as scaleValue } from './dimension.helpers-DzxqJQqN.js';
-import { d as debounce, a as isObject } from './debounce-BfO9dz9v.js';
+import { g as getScrollDimension } from './viewport.helpers-CoCAvmZs.js';
+import { d as debounce, i as isObject } from './debounce-PCRWZliA.js';
 
 const initialParams = {
     contentSize: 0,
@@ -16,10 +16,11 @@ const NO_COORDINATE = -1;
  * return full size
  */
 function getContentSize(contentSize, clientSize, virtualSize = 0) {
-    if (virtualSize > contentSize) {
-        return 0;
-    }
-    return contentSize + (virtualSize ? clientSize - virtualSize : 0);
+    return getScrollDimension({
+        contentSize,
+        clientSize,
+        virtualSize,
+    }).physicalContentSize;
 }
 class LocalScrollService {
     constructor(cfg) {
@@ -33,14 +34,20 @@ class LocalScrollService {
             rgRow: NO_COORDINATE,
             rgCol: NO_COORDINATE,
         };
+        this.previousLogicalScroll = {
+            rgRow: 0,
+            rgCol: 0,
+        };
         this.params = {
             rgRow: Object.assign({}, initialParams),
             rgCol: Object.assign({}, initialParams),
         };
     }
     setParams(params, dimension) {
-        const virtualContentSize = getContentSize(params.contentSize, params.clientSize, params.virtualSize);
-        this.params[dimension] = Object.assign(Object.assign({}, params), { maxSize: virtualContentSize - params.clientSize, virtualContentSize });
+        const scrollDimension = getScrollDimension(params);
+        const virtualContentSize = scrollDimension.physicalContentSize;
+        this.params[dimension] = Object.assign(Object.assign({}, params), { maxSize: virtualContentSize - params.clientSize, virtualContentSize,
+            scrollDimension });
     }
     // apply scroll values after scroll done
     async setScroll(e) {
@@ -60,16 +67,27 @@ class LocalScrollService {
             await frameAnimation;
             const params = this.getParams(e.dimension);
             e.coordinate = Math.ceil(e.coordinate);
-            this.previousScroll[e.dimension] = this.wrapCoordinate(e.coordinate, params);
+            this.previousLogicalScroll[e.dimension] = this.wrapLogicalCoordinate(e.coordinate, params);
+            const physicalCoordinate = this.toPhysicalCoordinate(e.coordinate, params);
+            this.previousScroll[e.dimension] = this.wrapPhysicalCoordinate(physicalCoordinate, params);
             this.preventArtificialScroll[e.dimension] = null;
-            this.cfg.applyScroll(Object.assign(Object.assign({}, e), { coordinate: params.virtualSize
-                    ? this.convert(e.coordinate, params, false)
-                    : e.coordinate }));
+            this.cfg.applyScroll(Object.assign(Object.assign({}, e), { coordinate: physicalCoordinate }));
         }
         catch (id) {
             window.cancelAnimationFrame(id);
         }
     }
+    async setScrollByDelta(e, currentPhysicalCoordinate) {
+        var _a;
+        const params = this.getParams(e.dimension);
+        const baseCoordinate = this.previousScroll[e.dimension] === NO_COORDINATE
+            ? this.toLogicalCoordinate(currentPhysicalCoordinate, params)
+            : this.previousLogicalScroll[e.dimension];
+        const coordinate = this.wrapLogicalCoordinate(baseCoordinate + ((_a = e.delta) !== null && _a !== void 0 ? _a : 0), params);
+        const nextEvent = Object.assign(Object.assign({}, e), { coordinate });
+        await this.setScroll(nextEvent);
+        return nextEvent;
+    }
     /**
      * On scroll event started
      */
@@ -82,21 +100,21 @@ class LocalScrollService {
             return;
         }
         const param = this.getParams(dimension);
+        const logicalCoordinate = this.toLogicalScrollCoordinate(coordinate, dimension, param, delta);
         // let component know about scroll event started
         this.cfg.runScroll({
             dimension: dimension,
-            coordinate: param.virtualSize
-                ? this.convert(coordinate, param)
-                : coordinate,
+            coordinate: logicalCoordinate,
             delta,
             outside,
         });
+        this.previousLogicalScroll[dimension] = logicalCoordinate;
     }
     getParams(dimension) {
         return this.params[dimension];
     }
     // check if scroll outside of region to avoid looping
-    wrapCoordinate(c, param) {
+    wrapPhysicalCoordinate(c, param) {
         if (c < 0) {
             return NO_COORDINATE;
         }
@@ -105,22 +123,39 @@ class LocalScrollService {
         }
         return c;
     }
+    wrapLogicalCoordinate(c, param) {
+        var _a, _b;
+        if (c < 0) {
+            return 0;
+        }
+        return Math.min(c, (_b = (_a = param.scrollDimension) === null || _a === void 0 ? void 0 : _a.logicalScrollSize) !== null && _b !== void 0 ? _b : c);
+    }
     // prevent already started scroll, performance optimization
     cancelScroll(dimension) {
         var _a, _b;
         (_b = (_a = this.preventArtificialScroll)[dimension]) === null || _b === void 0 ? void 0 : _b.call(_a);
         this.preventArtificialScroll[dimension] = null;
     }
-    /* convert virtual to real and back, scale range */
-    convert(pos, param, toReal = true) {
-        var _a;
-        const minRange = param.clientSize;
-        const from = [0, ((_a = param.virtualContentSize) !== null && _a !== void 0 ? _a : minRange) - minRange];
-        const to = [0, param.contentSize - param.virtualSize];
-        if (toReal) {
-            return scaleValue(pos, from, to);
+    toLogicalScrollCoordinate(coordinate, dimension, param, delta) {
+        const scrollDimension = param.scrollDimension;
+        if (!scrollDimension) {
+            return coordinate;
+        }
+        if (typeof delta === 'number' && scrollDimension.isCompressed) {
+            const base = this.previousScroll[dimension] === NO_COORDINATE
+                ? scrollDimension.toLogicalCoordinate(coordinate - delta)
+                : this.previousLogicalScroll[dimension];
+            return scrollDimension.toLogicalCoordinate(scrollDimension.toPhysicalCoordinate(base + delta));
         }
-        return scaleValue(pos, to, from);
+        return scrollDimension.toLogicalCoordinate(coordinate);
+    }
+    toPhysicalCoordinate(coordinate, param) {
+        var _a, _b;
+        return (_b = (_a = param.scrollDimension) === null || _a === void 0 ? void 0 : _a.toPhysicalCoordinate(coordinate)) !== null && _b !== void 0 ? _b : coordinate;
+    }
+    toLogicalCoordinate(coordinate, param) {
+        var _a, _b;
+        return (_b = (_a = param.scrollDimension) === null || _a === void 0 ? void 0 : _a.toLogicalCoordinate(coordinate)) !== null && _b !== void 0 ? _b : coordinate;
     }
 }
 

package/dist/revo-grid/viewport.helpers-CoCAvmZs.js

@@ -0,0 +1,133 @@
+/*!
+ * Built by Revolist OU ❤️
+ */
+const FALLBACK_MAX_SCROLL_SIZE = 16000000;
+const SCROLL_SIZE_GUARD = 1000000;
+let detectedMaxScrollSize;
+function getMaxScrollSize(doc = typeof document === 'undefined' ? undefined : document) {
+    if (typeof detectedMaxScrollSize === 'number') {
+        return detectedMaxScrollSize;
+    }
+    const body = doc === null || doc === void 0 ? void 0 : doc.body;
+    if (body) {
+        const ownerDocument = body.ownerDocument;
+        const element = ownerDocument.createElement('div');
+        element.style.cssText = [
+            'height:1px',
+            'left:-10000px',
+            'overflow:scroll',
+            'position:absolute',
+            'top:-10000px',
+            'visibility:hidden',
+            'width:1px',
+        ].join(';');
+        const content = ownerDocument.createElement('div');
+        content.style.height = `${FALLBACK_MAX_SCROLL_SIZE * 4}px`;
+        element.appendChild(content);
+        body.appendChild(element);
+        detectedMaxScrollSize = Math.max(0, Math.min(element.scrollHeight, FALLBACK_MAX_SCROLL_SIZE * 4) - SCROLL_SIZE_GUARD);
+        element.remove();
+        if (detectedMaxScrollSize > SCROLL_SIZE_GUARD) {
+            return detectedMaxScrollSize;
+        }
+        detectedMaxScrollSize = FALLBACK_MAX_SCROLL_SIZE;
+        return detectedMaxScrollSize;
+    }
+    return FALLBACK_MAX_SCROLL_SIZE;
+}
+function getScrollDimension({ contentSize, clientSize, virtualSize = 0, maxScrollSize = getMaxScrollSize(), }) {
+    const safeContentSize = Math.max(0, maxScrollSize - SCROLL_SIZE_GUARD);
+    const size = Math.max(0, contentSize);
+    const client = Math.max(0, clientSize);
+    const viewport = Math.max(0, virtualSize || client);
+    const logicalScrollSize = Math.max(0, size - viewport);
+    const maxPhysicalScrollSize = Math.max(0, safeContentSize - client);
+    const physicalScrollSize = Math.min(logicalScrollSize, maxPhysicalScrollSize);
+    const physicalContentSize = client + physicalScrollSize;
+    const isCompressed = logicalScrollSize > physicalScrollSize && physicalScrollSize > 0;
+    const clampLogical = (coordinate) => Math.min(Math.max(0, coordinate || 0), logicalScrollSize);
+    const clampPhysical = (coordinate) => Math.min(Math.max(0, coordinate || 0), physicalScrollSize);
+    const toLogicalCoordinate = (coordinate) => {
+        if (!logicalScrollSize || !physicalScrollSize) {
+            return 0;
+        }
+        if (!isCompressed) {
+            return clampLogical(coordinate);
+        }
+        return clampLogical((clampPhysical(coordinate) / physicalScrollSize) * logicalScrollSize);
+    };
+    const toPhysicalCoordinate = (coordinate) => {
+        if (!logicalScrollSize || !physicalScrollSize) {
+            return 0;
+        }
+        if (!isCompressed) {
+            return clampPhysical(coordinate);
+        }
+        return clampPhysical((clampLogical(coordinate) / logicalScrollSize) * physicalScrollSize);
+    };
+    return {
+        contentSize: size,
+        clientSize: client,
+        viewportSize: viewport,
+        physicalContentSize,
+        logicalScrollSize,
+        physicalScrollSize,
+        isCompressed,
+        toLogicalCoordinate,
+        toPhysicalCoordinate,
+        getRenderOffset(coordinate) {
+            const logical = clampLogical(coordinate);
+            return logical - toPhysicalCoordinate(logical);
+        },
+    };
+}
+
+/**
+ * Collects data for pinned columns in the required @ViewportProps format.
+ */
+/**
+ * Represents the slot names for the viewport slots.
+ */
+const HEADER_SLOT = 'header'; // Slot name for the header slot
+const FOOTER_SLOT = 'footer'; // Slot name for the footer slot
+const CONTENT_SLOT = 'content'; // Slot name for the content slot
+const DATA_SLOT = 'data'; // Slot name for the data slot
+/**
+ * Returns the last visible cell in the viewport for a given row type.
+ * Coordinates are not zero-based and are relative to the viewport.
+ * If needed to be zero-based they can be adjusted by subtracting 1.
+ */
+function getLastCell(data, rowType) {
+    // Get the last visible column count from the viewport column data.
+    const lastVisibleColumnCount = data.viewports[data.colType].store.get('realCount');
+    // Get the last visible row count for the given row type from the viewport column data.
+    const lastVisibleRowCount = data.viewports[rowType].store.get('realCount');
+    // Return the last visible cell with the last visible column count and row count.
+    return {
+        x: lastVisibleColumnCount,
+        y: lastVisibleRowCount,
+    };
+}
+function viewportDataPartition(data, type, slot, fixed) {
+    return {
+        colData: data.colStore,
+        viewportCol: data.viewports[data.colType].store,
+        viewportRow: data.viewports[type].store,
+        /**
+         * lastCell is the last real coordinate + 1, saved to selection store
+         */
+        lastCell: getLastCell(data, type),
+        slot,
+        type,
+        canDrag: !fixed,
+        position: data.position,
+        dataStore: data.rowStores[type].store,
+        dimensionCol: data.dimensions[data.colType].store,
+        dimensionRow: data.dimensions[type].store,
+        style: fixed
+            ? { height: `${data.dimensions[type].store.get('realSize')}px` }
+            : undefined,
+    };
+}
+
+export { CONTENT_SLOT as C, DATA_SLOT as D, FOOTER_SLOT as F, HEADER_SLOT as H, getScrollDimension as g, viewportDataPartition as v };

package/dist/{esm/viewport.store-saAZJHRo.js → revo-grid/viewport.store-COAfzAyu.js}

@@ -1,7 +1,7 @@
 /*!
  * Built by Revolist OU ❤️
  */
-import { j as getItemByPosition, W as createStore, w as setStore } from './dimension.helpers-DzxqJQqN.js';
+import { j as getItemByPosition, K as createStore, l as setStore } from './dimension.helpers-CGKwSvw6.js';
 
 const LETTER_BLOCK_SIZE = 10;
 const calculateRowHeaderSize = (itemsLength, rowHeaderColumn, minWidth = 50) => {
@@ -9,6 +9,15 @@ const calculateRowHeaderSize = (itemsLength, rowHeaderColumn, minWidth = 50) =>
         Math.max((itemsLength.toString().length + 1) * LETTER_BLOCK_SIZE, minWidth));
 };
 
+function getViewportMaxCoordinate(dimension, viewportSize, frameOffset = 1) {
+    if (!viewportSize || dimension.realSize <= viewportSize) {
+        return 0;
+    }
+    return Math.max(0, dimension.realSize - viewportSize - dimension.originItemSize * frameOffset);
+}
+function clampViewportCoordinate(coordinate, dimension, viewportSize, frameOffset = 1) {
+    return Math.min(Math.max(0, coordinate), getViewportMaxCoordinate(dimension, viewportSize, frameOffset));
+}
 /**
  * Update items based on new scroll position
  * If viewport wasn't changed fully simple recombination of positions
@@ -274,6 +283,8 @@ function initialState() {
         realCount: 0,
         // size of viewport in px
         clientSize: 0,
+        // logical-to-physical render offset used when scroll space is compressed
+        renderOffset: 0,
     };
 }
 /**
@@ -309,21 +320,8 @@ class ViewportStore {
         const outsize = singleOffsetInPx * 2;
         // math virtual size is based on visible area + 2 items outside of visible area
         const virtualSize = viewportSize + outsize;
-        // expected no scroll if real size less than virtual size, position is 0
-        let maxCoordinate = 0;
-        // if there is nodes outside of viewport, max coordinate has to be adjusted
-        if (dimension.realSize > viewportSize) {
-            // max coordinate is real size minus virtual/rendered space
-            maxCoordinate = dimension.realSize - viewportSize - singleOffsetInPx;
-        }
-        let pos = position;
-        // limit position to max and min coordinates
-        if (pos < 0) {
-            pos = 0;
-        }
-        else if (pos > maxCoordinate) {
-            pos = maxCoordinate;
-        }
+        const maxCoordinate = getViewportMaxCoordinate(dimension, viewportSize, frameOffset);
+        let pos = clampViewportCoordinate(position, dimension, viewportSize, frameOffset);
         // store last coordinate for further restore on redraw
         this.lastCoordinate = pos;
         // actual position is less than first item start based on offset
@@ -401,4 +399,4 @@ class ViewportStore {
     }
 }
 
-export { ViewportStore as V, addMissingItems as a, getItems as b, isActiveRangeOutsideLastItem as c, getFirstItem as d, getLastItem as e, calculateRowHeaderSize as f, getUpdatedItemsByPosition as g, isActiveRange as i, recombineByOffset as r, setItemSizes as s, updateMissingAndRange as u };
+export { ViewportStore as V, getUpdatedItemsByPosition as a, addMissingItems as b, clampViewportCoordinate as c, getItems as d, isActiveRangeOutsideLastItem as e, getFirstItem as f, getViewportMaxCoordinate as g, getLastItem as h, isActiveRange as i, calculateRowHeaderSize as j, recombineByOffset as r, setItemSizes as s, updateMissingAndRange as u };

package/dist/types/components/header/header-group-renderer.d.ts

@@ -9,6 +9,7 @@ export type HeaderGroupRendererProps = {
     providers: ProvidersColumns;
     additionalData: any;
     canResize?: boolean;
+    renderOffset?: number;
     onResize?(e: ResizeEvent): void;
 } & Partial<Pick<ResizeProps, 'active'>>;
 declare const HeaderGroupRenderer: (p: HeaderGroupRendererProps) => ReturnType<typeof h>;

package/dist/types/components/header/header-renderer.d.ts

@@ -8,6 +8,7 @@ export type HeaderRenderProps = {
     range?: RangeArea | null;
     canResize?: boolean;
     canFilter?: boolean;
+    renderOffset?: number;
     onResize?(e: ResizeEvent): void;
     onClick?(data: InitialHeaderClick): void;
     onDblClick?(data: InitialHeaderClick): void;

package/dist/types/components/header/revogr-header.d.ts

@@ -86,5 +86,11 @@ export declare class RevogrHeaderComponent {
     render(): any[];
     private renderHeaderColumns;
     private renderGroupingColumns;
+    private renderGroupRow;
+    private renderGroupColumn;
+    private getVisibleGroupRange;
+    private getHeaderCellKey;
+    private getDuplicateHeaderProps;
+    private getGroupHeaderCellKey;
     get providers(): ProvidersColumns<DimensionCols | 'rowHeaders'>;
 }

package/dist/types/components/overlay/keyboard.service.d.ts

@@ -15,6 +15,11 @@ type Config = {
 export declare class KeyboardService {
     private sv;
     constructor(sv: Config);
+    /**
+     * Appends printable key input that arrives after edit mode was requested
+     * but before the editor input has mounted or received focus.
+     */
+    private appendPendingEditValue;
     keyDown(e: KeyboardEvent, canRange: boolean, isEditMode: boolean, { range, focus }: Nullable<Pick<EventData, 'range' | 'focus'>>): Promise<void>;
     private selectAll;
     keyChangeSelection(e: KeyboardEvent, canRange: boolean): Promise<boolean>;

package/dist/types/plugins/groupingRow/grouping.row.plugin.d.ts

@@ -20,6 +20,14 @@ export declare class GroupingRowPlugin extends BasePlugin {
     private beforeTrimmedApply;
     private beforeFilterTrimmed;
     private isSortingRunning;
+    /**
+     * Returns grouping options for regrouping that must preserve current UI state.
+     *
+     * `expandedAll` and config `prevExpanded` are initial/config instructions.
+     * Reusing them after sorting would reopen groups the user collapsed before
+     * sorting instead of using the current grouped source state.
+     */
+    private getCurrentExpandedOptions;
     /**
      * Starts global source update with group clearing and applying new one
      * Initiated when need to reapply grouping

package/dist/types/plugins/moveColumn/column.drag.plugin.d.ts

@@ -1,11 +1,16 @@
 import { BasePlugin } from '../base.plugin';
 import { ColumnOrderHandler } from './order-column.handler';
-import type { ColumnPropProp, DimensionSettingsState, PositionItem, DimensionCols, MultiDimensionType, PluginProviders, DimensionColPin } from "../../types/index";
+import type { ColumnPropProp, ColumnRegular, DimensionSettingsState, PositionItem, DimensionCols, MultiDimensionType, PluginProviders, DimensionColPin } from "../../types/index";
+export declare const COLUMN_DRAG_MOVE_EVENT = "columndragmousemove";
+export declare const COLUMN_DRAG_END_EVENT = "columndragend";
+export declare const BEFORE_COLUMN_DRAG_END_EVENT = "beforecolumndragend";
+export declare const COLUMN_DRAG_START_EVENT = "columndragstart";
 export type DragStartEventDetails = {
     event: MouseEvent;
     data: ColumnPropProp;
 };
-type StaticData = {
+export type ColumnDragStartEventData = ColumnPropProp;
+export type StaticData = {
     startPos: number;
     startItem: PositionItem;
     pin?: DimensionColPin;
@@ -20,11 +25,32 @@ type LocalSubscription = {
     callback(...params: any[]): void;
 };
 export type ColumnDragEventData = {
+    /**
+     * Reordered columns for the affected column viewport.
+     */
+    columns: ColumnRegular[];
     elRect: DOMRect;
     gridRect: DOMRect;
+    /**
+     * Physical column indexes in their current visual order.
+     */
+    order: number[];
     scrollOffset: number;
     type: DimensionCols;
 };
+export type BeforeColumnDragEndEventData = StaticData & {
+    startPosition: PositionItem;
+    newPosition: PositionItem;
+    newItem?: ColumnRegular;
+};
+declare global {
+    interface HTMLRevoGridElementEventMap {
+        [COLUMN_DRAG_START_EVENT]: ColumnDragStartEventData;
+        [COLUMN_DRAG_MOVE_EVENT]: MouseEvent;
+        [BEFORE_COLUMN_DRAG_END_EVENT]: BeforeColumnDragEndEventData;
+        [COLUMN_DRAG_END_EVENT]: ColumnDragEventData;
+    }
+}
 export declare class ColumnMovePlugin extends BasePlugin {
     protected moveFunc: import("lodash").DebouncedFunc<(e: MouseEvent) => void>;
     protected staticDragData: StaticData | null;
@@ -43,7 +69,7 @@ export declare class ColumnMovePlugin extends BasePlugin {
      * Clearing subscription
      */
     clearSubscriptions(): void;
-    protected getData({ gridEl, dataEl, pin, }: StaticData): ColumnDragEventData;
+    protected getData({ gridEl, dataEl, pin }: StaticData, order: number[], source?: ColumnRegular[]): ColumnDragEventData;
     protected getDimension(type: MultiDimensionType): DimensionSettingsState;
 }
 export declare function getLeftRelative(absoluteX: number, gridPos: number, offset: number): number;

package/dist/types/plugins/sorting/sorting.func.d.ts

@@ -1,6 +1,29 @@
 import type { CellCompareFunc, ColumnProp, ColumnRegular, DataType, Order } from "../../types/index";
-import type { SortingOrderFunction } from './sorting.types';
-export declare function sortIndexByItems(indexes: number[], source: DataType[], sortingFunc?: SortingOrderFunction): number[];
+import type { SortingColumnMap, SortingColumnOrder, SortingColumnRender, SortingOrder, SortingOrderFunction } from './sorting.types';
+/**
+ * Checks whether a sorting map contains at least one active order.
+ *
+ * Empty maps and properties with `undefined` order are treated as inactive.
+ */
+export declare function hasActiveSorting(sorting?: SortingOrder): boolean;
+/**
+ * Returns one-based additive sorting rank for a column.
+ *
+ * A single active sort does not need a visible rank, so it returns undefined.
+ */
+export declare function getSortingIndex(sorting: SortingOrder | undefined, prop: ColumnProp, sortingOrder?: SortingColumnOrder): SortingColumnRender['sortIndex'];
+/**
+ * Sorts row indexes against a source collection.
+ *
+ * @param indexes - Current proxy row indexes to sort.
+ * @param source - Full source collection addressed by the indexes.
+ * @param sortingFunc - Comparator functions by column property.
+ * @param sorting - Active sorting order by column property.
+ * @param sortingColumns - Column metadata by property for default-comparer optimization.
+ * @param sortingOrder - Active sorting priority in click/config insertion order.
+ * @returns Sorted proxy indexes. With no sorting function keys, returns source-order indexes.
+ */
+export declare function sortIndexByItems(indexes: number[], source: DataType[], sortingFunc?: SortingOrderFunction, sorting?: SortingOrder, sortingColumns?: SortingColumnMap, sortingOrder?: SortingColumnOrder): number[];
 export declare function defaultCellCompare(this: {
     column?: ColumnRegular;
 }, prop: ColumnProp, a: DataType, b: DataType): 0 | 1 | -1;

package/dist/types/plugins/sorting/sorting.plugin.d.ts

@@ -1,6 +1,6 @@
 import { BasePlugin } from '../base.plugin';
 import type { ColumnRegular, DimensionRows, PluginProviders } from "../../types/index";
-import type { SortingConfig, SortingOrder, SortingOrderFunction } from './sorting.types';
+import type { SortingColumnMap, SortingColumnOrder, SortingConfig, SortingOrder, SortingOrderFunction } from './sorting.types';
 export * from './sorting.types';
 export * from './sorting.func';
 export * from './sorting.sign';
@@ -15,34 +15,109 @@ export * from './sorting.sign';
  */
 export declare class SortingPlugin extends BasePlugin {
     revogrid: HTMLRevoGridElement;
+    /**
+     * Current sorting order per column property.
+     */
     sorting?: SortingOrder;
+    /**
+     * Comparator functions indexed by column property.
+     *
+     * Multiple columns can be sorted at the same time.
+     */
     sortingFunc?: SortingOrderFunction;
     /**
-     * Delayed sorting promise
+     * Column metadata for the current sorting state.
+     *
+     * Used internally to optimize default sorting without changing comparator
+     * functions or their public API contract.
+     */
+    private sortingColumns?;
+    /**
+     * Active sorting priority in click/config insertion order.
+     *
+     * Required for numeric column props because object key iteration does not
+     * preserve insertion order for integer-like keys.
+     */
+    private sortingOrder?;
+    /**
+     * Delayed sorting promise registered in the grid render job queue.
      */
     sortingPromise: (() => void) | null;
     /**
-     * We need to sort only so often
+     * Debounced sorting entry point.
+     *
+     * Sorting can be requested by column changes, source changes, and header
+     * clicks in quick succession, so the actual sort is delayed and coalesced.
      */
-    postponeSort: import("lodash").DebouncedFunc<(order?: SortingOrder, comparison?: SortingOrderFunction, ignoreViewportUpdate?: boolean) => void>;
+    postponeSort: import("lodash").DebouncedFunc<(order?: SortingOrder, comparison?: SortingOrderFunction, sortingColumns?: SortingColumnMap, sortingOrder?: SortingColumnOrder, ignoreViewportUpdate?: boolean) => void>;
     constructor(revogrid: HTMLRevoGridElement, providers: PluginProviders, config?: SortingConfig);
     /**
-     * Entry point for sorting, waits for all delays, registers jobs
+     * Creates mutable sorting maps from current state when additive sorting is requested.
+     */
+    private createSortingState;
+    /**
+     * Stores normalized sorting state, clearing inactive empty maps.
+     */
+    private setSortingState;
+    /**
+     * Adds or replaces a column in a sorting state.
+     */
+    private setColumnSorting;
+    /**
+     * Removes a column from a sorting state.
+     */
+    private clearColumnSorting;
+    /**
+     * Normalizes external sorting configuration into internal order,
+     * comparator, and column metadata maps.
+     */
+    private applySortingConfig;
+    /**
+     * Schedules sorting before the next render.
+     *
+     * @param order - Active sorting order by column property.
+     * @param sortingFunc - Comparator functions by column property.
+     * @param sortingColumns - Column metadata by property.
+     * @param sortingOrder - Active sorting priority in click/config insertion order.
+     * @param ignoreViewportUpdate - Skips dimension position recalculation when true.
      */
     startSorting(order?: SortingOrder, sortingFunc?: SortingOrderFunction, ignoreViewportUpdate?: boolean): void;
+    startSorting(order?: SortingOrder, sortingFunc?: SortingOrderFunction, sortingColumns?: SortingColumnMap, sortingOrder?: SortingColumnOrder, ignoreViewportUpdate?: boolean): void;
     /**
-     * Apply sorting to data on header click
-     * If additive - add to existing sorting, multiple columns can be sorted
+     * Applies sorting requested by a sortable header click.
+     *
+     * @param column - Column that initiated sorting.
+     * @param additive - If true, add/remove this column from the current multi-sort state.
      */
     headerclick(column: ColumnRegular, additive: boolean): void;
+    /**
+     * Applies sorting state produced by a header click.
+     */
+    private applyHeaderSorting;
+    /**
+     * Runs a scheduled sort and resolves the render-blocking sorting promise.
+     *
+     * @param order - Active sorting order by column property.
+     * @param comparison - Comparator functions by column property.
+     * @param sortingColumns - Column metadata by property.
+     * @param sortingOrder - Active sorting priority in click/config insertion order.
+     * @param ignoreViewportUpdate - Skips dimension position recalculation when true.
+     */
     runSorting(order?: SortingOrder, comparison?: SortingOrderFunction, ignoreViewportUpdate?: boolean): void;
+    runSorting(order?: SortingOrder, comparison?: SortingOrderFunction, sortingColumns?: SortingColumnMap, sortingOrder?: SortingColumnOrder, ignoreViewportUpdate?: boolean): void;
     /**
-     * Sort items by sorting function
+     * Sorts row proxy indexes by sorting functions.
+     *
      * @requires proxyItems applied to row store
      * @requires source applied to row store
      *
      * @param sorting - per column sorting
-     * @param data - this.stores['rgRow'].store.get('source')
+     * @param sortingFunc - Comparator functions by column property.
+     * @param sortingColumns - Column metadata by property.
+     * @param sortingOrder - Active sorting priority in click/config insertion order.
+     * @param types - Row stores to sort.
+     * @param ignoreViewportUpdate - Skips dimension position recalculation when true.
      */
     sort(sorting?: SortingOrder, sortingFunc?: SortingOrderFunction, types?: DimensionRows[], ignoreViewportUpdate?: boolean): void;
+    sort(sorting?: SortingOrder, sortingFunc?: SortingOrderFunction, sortingColumns?: SortingColumnMap, sortingOrder?: SortingColumnOrder, types?: DimensionRows[], ignoreViewportUpdate?: boolean): void;
 }

package/dist/types/plugins/sorting/sorting.sign.d.ts

@@ -1,6 +1,10 @@
 import { ColumnRegular } from "../../types/index";
+import type { SortingColumnRender } from './sorting.types';
 type Props = {
-    column: ColumnRegular;
+    column: ColumnRegular & SortingColumnRender;
 };
+/**
+ * Renders sorting direction and optional additive sorting rank.
+ */
 export declare const SortingSign: ({ column }: Props) => any;
 export {};