@revolist/revogrid 4.22.1 → 4.23.0

package/dist/collection/plugins/sorting/sorting.func.js

@@ -1,13 +1,177 @@
 /*!
  * Built by Revolist OU ❤️
  */
+import { GROUP_COLUMN_PROP } from "../groupingRow/grouping.const";
 import { isGrouping } from "../groupingRow/grouping.service";
 import { getCellRaw } from "../../utils/column.utils";
-export function sortIndexByItems(indexes, source, sortingFunc = {}) {
+/**
+ * Checks whether a sorting map contains at least one active order.
+ *
+ * Empty maps and properties with `undefined` order are treated as inactive.
+ */
+export function hasActiveSorting(sorting) {
+    for (const prop of Object.keys(sorting || {})) {
+        if (sorting === null || sorting === void 0 ? void 0 : sorting[prop]) {
+            return true;
+        }
+    }
+    return false;
+}
+/**
+ * Compares column properties after object-key coercion.
+ */
+function isSameColumnProp(a, b) {
+    return String(a) === String(b);
+}
+/**
+ * Returns active sorting properties in explicit priority order.
+ */
+function getActiveSortingProps(sorting, sortingOrder) {
+    const activeProps = [];
+    const add = (prop) => {
+        if ((sorting === null || sorting === void 0 ? void 0 : sorting[prop]) && !activeProps.some(active => isSameColumnProp(active, prop))) {
+            activeProps.push(prop);
+        }
+    };
+    sortingOrder === null || sortingOrder === void 0 ? void 0 : sortingOrder.forEach(add);
+    Object.keys(sorting || {}).forEach(add);
+    return activeProps;
+}
+/**
+ * Returns one-based additive sorting rank for a column.
+ *
+ * A single active sort does not need a visible rank, so it returns undefined.
+ */
+export function getSortingIndex(sorting, prop, sortingOrder) {
+    const activeProps = getActiveSortingProps(sorting, sortingOrder);
+    if (activeProps.length <= 1) {
+        return undefined;
+    }
+    const index = activeProps.findIndex(active => isSameColumnProp(active, prop));
+    return index >= 0 ? index + 1 : undefined;
+}
+/**
+ * Collects only active comparator functions from a sorting function map.
+ *
+ * This keeps undefined comparator entries from triggering sorting work.
+ */
+function activeSortingEntries(sortingFunc = {}, sortingOrder) {
+    const entries = [];
+    const add = (prop) => {
+        const cmp = sortingFunc[prop];
+        if (typeof cmp === 'function' && !entries.some(([active]) => isSameColumnProp(active, prop))) {
+            entries.push([prop, cmp]);
+        }
+    };
+    sortingOrder === null || sortingOrder === void 0 ? void 0 : sortingOrder.forEach(add);
+    Object.keys(sortingFunc).forEach(add);
+    return entries;
+}
+/**
+ * Reads and normalizes a value for the built-in default comparer.
+ */
+function getDefaultCompareValue(item, prop, column) {
+    const aRaw = column ? getCellRaw(item, column) : item === null || item === void 0 ? void 0 : item[prop];
+    return typeof aRaw === 'number' ? aRaw : aRaw === null || aRaw === void 0 ? void 0 : aRaw.toString().toLowerCase();
+}
+function isEmptyCompareValue(value) {
+    return value === '' || value === null || value === undefined;
+}
+/**
+ * Compares two already-normalized default comparer values.
+ */
+function compareValues(av, bv) {
+    if (av === bv) {
+        return 0;
+    }
+    const aEmpty = isEmptyCompareValue(av);
+    const bEmpty = isEmptyCompareValue(bv);
+    if (aEmpty || bEmpty) {
+        if (aEmpty && bEmpty) {
+            return 0;
+        }
+        return aEmpty ? -1 : 1;
+    }
+    if (av > bv) {
+        return 1;
+    }
+    return -1;
+}
+/**
+ * Sorts indexes by precomputed values for default column comparers.
+ *
+ * This avoids repeatedly parsing the same cell value during large default
+ * sorts while preserving normal multi-column ordering.
+ */
+function sortIndexByDefaultComparers(indexes, source, entries, sorting, sortingColumns) {
+    const prepared = entries.map(([prop]) => {
+        const values = [];
+        const column = sortingColumns[prop];
+        for (const index of indexes) {
+            values[index] = getDefaultCompareValue(source[index], prop, column);
+        }
+        return {
+            order: sorting[prop],
+            values,
+        };
+    });
+    return indexes.sort((a, b) => {
+        for (const { order, values } of prepared) {
+            const sorted = compareValues(values[a], values[b]);
+            if (sorted) {
+                return order === 'desc' ? -sorted : sorted;
+            }
+        }
+        return 0;
+    });
+}
+/**
+ * Detects whether the optimized default-comparer path can be used.
+ *
+ * Grouped rows and custom `cellCompare` functions stay on the legacy
+ * comparator path to preserve their exact behavior.
+ */
+function canUseDefaultCompareFastPath(entries, indexes, source, sorting, sortingColumns) {
+    return !indexes.some(index => isGrouping(source[index])) && !!sorting && !!sortingColumns && entries.every(([prop]) => {
+        const order = sorting[prop];
+        const column = sortingColumns[prop];
+        return !!order && !(column === null || column === void 0 ? void 0 : column.cellCompare);
+    });
+}
+/**
+ * Group placeholder rows are generated for their grouping column. If sorting is
+ * requested for another column, the grouped source must be unwrapped first.
+ */
+function hasGroupingRowsForOtherSorting(entries, indexes, source) {
+    return indexes.some(index => {
+        const item = source[index];
+        return isGrouping(item) && !entries.some(([prop]) => isSameColumnProp(item[GROUP_COLUMN_PROP], prop));
+    });
+}
+/**
+ * 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 function sortIndexByItems(indexes, source, sortingFunc = {}, sorting, sortingColumns, sortingOrder) {
+    const hasSortingKeys = Object.keys(sortingFunc).length > 0;
+    const sortingEntries = activeSortingEntries(sortingFunc, sortingOrder);
     // if no sorting - return unsorted indexes
-    if (Object.entries(sortingFunc).length === 0) {
+    if (sortingEntries.length === 0) {
         // Unsorted indexes
-        return [...Array(indexes.length).keys()];
+        return hasSortingKeys ? indexes : [...new Array(indexes.length).keys()];
+    }
+    if (hasGroupingRowsForOtherSorting(sortingEntries, indexes, source)) {
+        return indexes;
+    }
+    if (canUseDefaultCompareFastPath(sortingEntries, indexes, source, sorting, sortingColumns)) {
+        return sortIndexByDefaultComparers(indexes, source, sortingEntries, sorting, sortingColumns);
     }
     //
     /**
@@ -17,15 +181,15 @@ export function sortIndexByItems(indexes, source, sortingFunc = {}) {
     return indexes.sort((a, b) => {
         const itemA = source[a];
         const itemB = source[b];
-        for (const [prop, cmp] of Object.entries(sortingFunc)) {
+        for (const [prop, cmp] of sortingEntries) {
             if (isGrouping(itemA)) {
-                if (itemA['__rvgr-prop'] !== prop) {
-                    return 0;
+                if (!isSameColumnProp(itemA[GROUP_COLUMN_PROP], prop)) {
+                    return a - b;
                 }
             }
             if (isGrouping(itemB)) {
-                if (itemB['__rvgr-prop'] !== prop) {
-                    return 0;
+                if (!isSameColumnProp(itemB[GROUP_COLUMN_PROP], prop)) {
+                    return a - b;
                 }
             }
             /**
@@ -45,13 +209,7 @@ export function defaultCellCompare(prop, a, b) {
     const bRaw = this.column ? getCellRaw(b, this.column) : b === null || b === void 0 ? void 0 : b[prop];
     const av = typeof aRaw === 'number' ? aRaw : aRaw === null || aRaw === void 0 ? void 0 : aRaw.toString().toLowerCase();
     const bv = typeof bRaw === 'number' ? bRaw : bRaw === null || bRaw === void 0 ? void 0 : bRaw.toString().toLowerCase();
-    if (av === bv) {
-        return 0;
-    }
-    if (av > bv) {
-        return 1;
-    }
-    return -1;
+    return compareValues(av, bv);
 }
 export function descCellCompare(cmp) {
     return (prop, a, b) => {

package/dist/collection/plugins/sorting/sorting.plugin.js

@@ -1,15 +1,30 @@
 /*!
  * Built by Revolist OU ❤️
  */
-import size from "lodash/size";
 import debounce from "lodash/debounce";
 import { BasePlugin } from "../base.plugin";
 import { getColumnByProp } from "../../utils/column.utils";
 import { columnTypes, rowTypes } from "../../store/index";
-import { getComparer, getNextOrder, sortIndexByItems } from "./sorting.func";
+import { isGrouping } from "../groupingRow/grouping.service";
+import { getComparer, getNextOrder, getSortingIndex, hasActiveSorting, sortIndexByItems, } from "./sorting.func";
 export * from './sorting.types';
 export * from './sorting.func';
 export * from './sorting.sign';
+function getSortableRowIndexes(indexes, source) {
+    return indexes.filter(index => !isGrouping(source[index]));
+}
+function mergeSortedRowsWithGroups(indexes, source, sortedRows) {
+    if (sortedRows.length === indexes.length) {
+        return sortedRows;
+    }
+    let rowIndex = 0;
+    return indexes.map(index => {
+        if (isGrouping(source[index])) {
+            return index;
+        }
+        return sortedRows[rowIndex++];
+    });
+}
 /**
  * Lifecycle
  * 1. @event `beforesorting` - Triggered when sorting just starts. Nothing has happened yet. This can be triggered from a column or from the source. If the type is from rows, the column will be undefined.
@@ -24,54 +39,37 @@ export class SortingPlugin extends BasePlugin {
         super(revogrid, providers);
         this.revogrid = revogrid;
         /**
-         * Delayed sorting promise
+         * Delayed sorting promise registered in the grid render job queue.
          */
         this.sortingPromise = 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.
          */
-        this.postponeSort = debounce((order, comparison, ignoreViewportUpdate) => this.runSorting(order, comparison, ignoreViewportUpdate), 50);
-        const setConfig = (cfg) => {
-            var _a;
-            if (cfg) {
-                const sortingFunc = {};
-                const order = {};
-                (_a = cfg.columns) === null || _a === void 0 ? void 0 : _a.forEach(col => {
-                    sortingFunc[col.prop] = getComparer(col, col.order);
-                    order[col.prop] = col.order;
-                });
-                if (cfg.additive) {
-                    this.sorting = Object.assign(Object.assign({}, this.sorting), order);
-                    this.sortingFunc = Object.assign(Object.assign({}, this.sortingFunc), sortingFunc);
-                }
-                else {
-                    // // set sorting
-                    this.sorting = order;
-                    this.sortingFunc = sortingFunc;
-                }
-            }
-        };
-        setConfig(config);
+        this.postponeSort = debounce((order, comparison, sortingColumns, sortingOrder, ignoreViewportUpdate) => this.runSorting(order, comparison, sortingColumns, sortingOrder, ignoreViewportUpdate), 50);
+        this.applySortingConfig(config);
         this.addEventListener('sortingconfigchanged', ({ detail }) => {
             config = detail;
-            setConfig(detail);
-            this.startSorting(this.sorting, this.sortingFunc);
+            this.applySortingConfig(detail);
+            this.startSorting(this.sorting, this.sortingFunc, this.sortingColumns, this.sortingOrder);
         });
         this.addEventListener('beforeheaderrender', ({ detail, }) => {
             var _a;
             const { data: column } = detail;
             if (column.sortable) {
-                detail.data = Object.assign(Object.assign({}, column), { order: (_a = this.sorting) === null || _a === void 0 ? void 0 : _a[column.prop] });
+                detail.data = Object.assign(Object.assign({}, column), { order: (_a = this.sorting) === null || _a === void 0 ? void 0 : _a[column.prop], sortIndex: getSortingIndex(this.sorting, column.prop, this.sortingOrder) });
             }
         });
         this.addEventListener('beforeanysource', ({ detail: { type }, }) => {
             // if sorting was provided - sort data
-            if (!!this.sorting && this.sortingFunc) {
+            if (hasActiveSorting(this.sorting) && this.sortingFunc) {
                 const event = this.emit('beforesourcesortingapply', { type, sorting: this.sorting });
                 if (event.defaultPrevented) {
                     return;
                 }
-                this.startSorting(this.sorting, this.sortingFunc);
+                this.startSorting(this.sorting, this.sortingFunc, this.sortingColumns, this.sortingOrder);
             }
         });
         this.addEventListener('aftercolumnsset', ({ detail: { order }, }) => {
@@ -81,13 +79,24 @@ export class SortingPlugin extends BasePlugin {
             }
             const columns = this.providers.column.getColumns();
             const sortingFunc = {};
+            const sortingColumns = {};
+            const sortingOrder = [];
+            const sorting = {};
             for (let prop in order) {
-                const cmp = getComparer(getColumnByProp(columns, prop), order[prop]);
-                sortingFunc[prop] = cmp;
+                if (order[prop]) {
+                    const column = getColumnByProp(columns, prop);
+                    const cmp = getComparer(column, order[prop]);
+                    sorting[prop] = order[prop];
+                    sortingFunc[prop] = cmp;
+                    sortingColumns[prop] = column;
+                    sortingOrder.push(prop);
+                }
             }
             // set sorting
-            this.sorting = order;
-            this.sortingFunc = order && sortingFunc;
+            this.sorting = hasActiveSorting(sorting) ? sorting : undefined;
+            this.sortingFunc = this.sorting ? sortingFunc : undefined;
+            this.sortingColumns = this.sorting ? sortingColumns : undefined;
+            this.sortingOrder = this.sorting ? sortingOrder : undefined;
         });
         this.addEventListener('beforeheaderclick', (e) => {
             var _a, _b, _c, _d;
@@ -101,23 +110,89 @@ export class SortingPlugin extends BasePlugin {
         });
     }
     /**
-     * Entry point for sorting, waits for all delays, registers jobs
+     * Creates mutable sorting maps from current state when additive sorting is requested.
+     */
+    createSortingState(additive) {
+        var _a;
+        return {
+            sorting: additive ? Object.assign({}, this.sorting) : {},
+            sortingFunc: additive ? Object.assign({}, this.sortingFunc) : {},
+            sortingColumns: additive ? Object.assign({}, this.sortingColumns) : {},
+            sortingOrder: additive ? [...((_a = this.sortingOrder) !== null && _a !== void 0 ? _a : [])] : [],
+        };
+    }
+    /**
+     * Stores normalized sorting state, clearing inactive empty maps.
+     */
+    setSortingState({ sorting, sortingFunc, sortingColumns, sortingOrder, }) {
+        this.sorting = hasActiveSorting(sorting) ? sorting : undefined;
+        this.sortingFunc = this.sorting ? sortingFunc : undefined;
+        this.sortingColumns = this.sorting ? sortingColumns : undefined;
+        this.sortingOrder = this.sorting ? sortingOrder : undefined;
+    }
+    /**
+     * Adds or replaces a column in a sorting state.
      */
-    startSorting(order, sortingFunc, ignoreViewportUpdate) {
+    setColumnSorting(state, prop, order, cmp, column) {
+        state.sorting[prop] = order;
+        state.sortingFunc[prop] = cmp;
+        state.sortingColumns[prop] = column;
+        if (!state.sortingOrder.some(sortingProp => String(sortingProp) === String(prop))) {
+            state.sortingOrder.push(prop);
+        }
+    }
+    /**
+     * Removes a column from a sorting state.
+     */
+    clearColumnSorting(state, prop) {
+        delete state.sorting[prop];
+        delete state.sortingFunc[prop];
+        delete state.sortingColumns[prop];
+        const index = state.sortingOrder.findIndex(sortingProp => String(sortingProp) === String(prop));
+        if (index >= 0) {
+            state.sortingOrder.splice(index, 1);
+        }
+    }
+    /**
+     * Normalizes external sorting configuration into internal order,
+     * comparator, and column metadata maps.
+     */
+    applySortingConfig(cfg) {
+        var _a;
+        if (!cfg) {
+            return;
+        }
+        const state = this.createSortingState(cfg.additive);
+        (_a = cfg.columns) === null || _a === void 0 ? void 0 : _a.forEach(col => {
+            if (col.order) {
+                this.setColumnSorting(state, col.prop, col.order, getComparer(col, col.order), col);
+                return;
+            }
+            this.clearColumnSorting(state, col.prop);
+        });
+        this.setSortingState(state);
+    }
+    startSorting(order, sortingFunc, sortingColumns, sortingOrder, ignoreViewportUpdate) {
         if (!this.sortingPromise) {
             // add job before render
             this.revogrid.jobsBeforeRender.push(new Promise(resolve => {
                 this.sortingPromise = resolve;
             }));
         }
-        this.postponeSort(order, sortingFunc, ignoreViewportUpdate);
+        if (typeof sortingColumns === 'boolean') {
+            this.postponeSort(order, sortingFunc, undefined, undefined, sortingColumns);
+            return;
+        }
+        this.postponeSort(order, sortingFunc, sortingColumns, sortingOrder, ignoreViewportUpdate);
     }
     /**
-     * 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, additive) {
-        var _a, _b, _c;
+        var _a;
         const columnProp = column.prop;
         let order = getNextOrder((_a = this.sorting) === null || _a === void 0 ? void 0 : _a[columnProp]);
         const beforeEvent = this.emit('beforesorting', { column, order, additive });
@@ -135,52 +210,59 @@ export class SortingPlugin extends BasePlugin {
             return;
         }
         const cmp = getComparer(beforeApplyEvent.detail.column, beforeApplyEvent.detail.order);
-        if (beforeApplyEvent.detail.additive && this.sorting) {
-            const sorting = {};
-            const sortingFunc = {};
-            if (columnProp in sorting && size(sorting) > 1 && order === undefined) {
-                delete sorting[columnProp];
-                delete sortingFunc[columnProp];
-            }
-            else {
-                sorting[columnProp] = order;
-                sortingFunc[columnProp] = cmp;
-            }
-            this.sorting = Object.assign(Object.assign({}, this.sorting), sorting);
-            // extend sorting function with new sorting for multiple columns sorting
-            this.sortingFunc = Object.assign(Object.assign({}, this.sortingFunc), sortingFunc);
+        this.applyHeaderSorting(beforeApplyEvent.detail.column, beforeApplyEvent.detail.additive, order, cmp);
+        this.startSorting(this.sorting, this.sortingFunc, this.sortingColumns, this.sortingOrder);
+    }
+    /**
+     * Applies sorting state produced by a header click.
+     */
+    applyHeaderSorting(column, additive, order, cmp) {
+        if (!additive) {
+            this.setSortingState(order ? {
+                sorting: { [column.prop]: order },
+                sortingFunc: { [column.prop]: cmp },
+                sortingColumns: { [column.prop]: column },
+                sortingOrder: [column.prop],
+            } : this.createSortingState());
+            return;
+        }
+        const state = this.createSortingState(true);
+        if (order) {
+            this.setColumnSorting(state, column.prop, order, cmp, column);
         }
         else {
-            if (order) {
-                // reset sorting
-                this.sorting = { [columnProp]: order };
-                this.sortingFunc = { [columnProp]: cmp };
-            }
-            else {
-                (_b = this.sorting) === null || _b === void 0 ? true : delete _b[columnProp];
-                (_c = this.sortingFunc) === null || _c === void 0 ? true : delete _c[columnProp];
-            }
+            this.clearColumnSorting(state, column.prop);
         }
-        this.startSorting(this.sorting, this.sortingFunc);
+        this.setSortingState(state);
     }
-    runSorting(order, comparison, ignoreViewportUpdate) {
-        var _a;
-        this.sort(order, comparison, undefined, ignoreViewportUpdate);
-        (_a = this.sortingPromise) === null || _a === void 0 ? void 0 : _a.call(this);
+    runSorting(order, comparison, sortingColumns, sortingOrder, ignoreViewportUpdate) {
+        var _a, _b;
+        if (typeof sortingColumns === 'boolean') {
+            this.sort(order, comparison, undefined, undefined, undefined, sortingColumns);
+            (_a = this.sortingPromise) === null || _a === void 0 ? void 0 : _a.call(this);
+            this.sortingPromise = null;
+            return;
+        }
+        this.sort(order, comparison, sortingColumns, sortingOrder, undefined, ignoreViewportUpdate);
+        (_b = this.sortingPromise) === null || _b === void 0 ? void 0 : _b.call(this);
         this.sortingPromise = null;
     }
-    /**
-     * Sort items by sorting function
-     * @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')
-     */
-    sort(sorting, sortingFunc, types = rowTypes, ignoreViewportUpdate = false) {
+    sort(sorting, sortingFunc, sortingColumns, sortingOrder, types = rowTypes, ignoreViewportUpdate = false) {
+        let activeSortingColumns;
+        let activeSortingOrder;
+        let activeTypes = types;
+        let activeIgnoreViewportUpdate = ignoreViewportUpdate;
+        if (Array.isArray(sortingColumns)) {
+            activeTypes = sortingColumns;
+            activeIgnoreViewportUpdate = typeof sortingOrder === 'boolean' ? sortingOrder : false;
+        }
+        else {
+            activeSortingColumns = sortingColumns;
+            activeSortingOrder = Array.isArray(sortingOrder) ? sortingOrder : undefined;
+        }
         // if no sorting - reset
         if (!Object.keys(sorting || {}).length) {
-            for (let type of types) {
+            for (let type of activeTypes) {
                 const storeService = this.providers.data.stores[type];
                 // row data
                 const source = storeService.store.get('source');
@@ -189,26 +271,27 @@ export class SortingPlugin extends BasePlugin {
                 // row indexes
                 const newItemsOrder = Array.from({ length: source.length }, (_, i) => i); // recover indexes range(0, source.length)
                 this.providers.dimension.updateSizesPositionByNewDataIndexes(type, newItemsOrder, proxyItems);
-                storeService.setData({ proxyItems: newItemsOrder, source: [...source], });
+                storeService.setData({ proxyItems: newItemsOrder });
             }
         }
         else {
-            for (let type of types) {
+            for (let type of activeTypes) {
                 const storeService = this.providers.data.stores[type];
                 // row data
                 const source = storeService.store.get('source');
                 // row indexes
                 const proxyItems = storeService.store.get('proxyItems');
-                const newItemsOrder = sortIndexByItems([...proxyItems], source, sortingFunc);
+                const sortItems = getSortableRowIndexes(proxyItems, source);
+                const sortedItems = sortIndexByItems([...sortItems], source, sortingFunc, sorting, activeSortingColumns, activeSortingOrder);
+                const newItemsOrder = mergeSortedRowsWithGroups(proxyItems, source, sortedItems);
                 // take row indexes before trim applied and proxy items
                 const prevItems = storeService.store.get('items');
                 storeService.setData({
                     proxyItems: newItemsOrder,
-                    source: [...source],
                 });
                 // take currently visible row indexes
                 const newItems = storeService.store.get('items');
-                if (!ignoreViewportUpdate) {
+                if (!activeIgnoreViewportUpdate) {
                     this.providers.dimension
                         .updateSizesPositionByNewDataIndexes(type, newItems, prevItems);
                 }

package/dist/collection/plugins/sorting/sorting.sign.js

@@ -2,7 +2,13 @@
  * Built by Revolist OU ❤️
  */
 import { h } from "@stencil/core";
+/**
+ * Renders sorting direction and optional additive sorting rank.
+ */
 export const SortingSign = ({ column }) => {
     var _a;
-    return h("i", { class: (_a = column === null || column === void 0 ? void 0 : column.order) !== null && _a !== void 0 ? _a : 'sort-off' });
+    const indicatorAttrs = { class: 'sort-indicator' };
+    const iconAttrs = { class: (_a = column === null || column === void 0 ? void 0 : column.order) !== null && _a !== void 0 ? _a : 'sort-off' };
+    const orderIndexAttrs = { class: 'sort-order-index' };
+    return (h("span", Object.assign({}, indicatorAttrs), h("i", Object.assign({}, iconAttrs)), (column === null || column === void 0 ? void 0 : column.sortIndex) ? (h("sup", Object.assign({}, orderIndexAttrs), column.sortIndex)) : null));
 };