@revolist/revogrid 4.14.1 → 4.14.2

package/dist/types/components/revoGrid/revo-grid.d.ts

@@ -136,6 +136,7 @@ export declare class RevoGridComponent {
     /**
      * Alternative way to set sorting.
      * `{columns: [{prop: 'name', order: 'asc'}]}`
+     * Use SortingPlugin to get current sorting state
      */
     sorting?: SortingConfig;
     /**
@@ -258,7 +259,7 @@ export declare class RevoGridComponent {
         to: number;
     }>;
     /**
-     * By `sorting.plugin.ts`
+     * By `SortingPlugin`
      * <br>Triggered immediately after header click.
      * <br>First in sorting event sequence. Ff this event stops no other event called.
      * <br>Use `e.preventDefault()` to prevent sorting.
@@ -269,7 +270,7 @@ export declare class RevoGridComponent {
         additive: boolean;
     }>;
     /**
-     * By `sorting.plugin.ts`
+     * By `SortingPlugin`
      * <br>Same as `beforesorting` but triggered after `beforeanysource` (when source is changed).
      * <br>Use `e.preventDefault()` to prevent sorting data change.
      */
@@ -278,7 +279,7 @@ export declare class RevoGridComponent {
         sorting?: SortingOrder;
     }>;
     /**
-     * By `sorting.plugin.ts`
+     * By `SortingPlugin`
      * <br> After `beforesorting`
      * <br>Triggered after column data updated with new sorting order.
      * <br>Use `e.preventDefault()` to prevent sorting data change.
@@ -352,7 +353,7 @@ export declare class RevoGridComponent {
     /**  Column updated */
     aftercolumnsset: EventEmitter<{
         columns: ColumnCollection;
-        order: Record<ColumnProp, 'asc' | 'desc' | undefined>;
+        order: SortingOrder;
     }>;
     /**
      * Emitted before applying a filter to the data source.
@@ -424,6 +425,7 @@ export declare class RevoGridComponent {
     filterconfigchanged: EventEmitter;
     /**
      * Emitted when the sorting configuration is changed
+     * SortingPlugin subsribed to this event
      */
     sortingconfigchanged: EventEmitter<SortingConfig>;
     /**
@@ -522,12 +524,13 @@ export declare class RevoGridComponent {
     getColumnStore(type?: DimensionCols): Promise<Observable<DSourceState<ColumnRegular, DimensionCols>>>;
     /**
      * Update column sorting
-     * @param column - full column details to update
-     * @param index - virtual column index
+     * @param column - column prop and cellCompare
      * @param order - order to apply
      * @param additive - if false will replace current order
+     *
+     * later passed to SortingPlugin
      */
-    updateColumnSorting(column: ColumnRegular, index: number, order: 'asc' | 'desc' | undefined, additive: boolean): Promise<ColumnRegular>;
+    updateColumnSorting(column: Pick<ColumnRegular, 'prop' | 'cellCompare'>, order: 'asc' | 'desc' | undefined, additive: boolean): Promise<void>;
     /**
      * Clears column sorting
      */

package/dist/types/components.d.ts

@@ -268,7 +268,7 @@ export namespace Components {
          */
         "setDataAt": ({ row, col, colType, rowType, val, skipDataUpdate }: { row: number; col: number; val?: any; skipDataUpdate?: boolean; } & AllDimensionType) => Promise<void | undefined>;
         /**
-          * Alternative way to set sorting. `{columns: [{prop: 'name', order: 'asc'}]}`
+          * Alternative way to set sorting. `{columns: [{prop: 'name', order: 'asc'}]}` Use SortingPlugin to get current sorting state
          */
         "sorting"?: SortingConfig;
         /**
@@ -289,12 +289,11 @@ export namespace Components {
         "trimmedRows": Record<number, boolean>;
         /**
           * Update column sorting
-          * @param column - full column details to update
-          * @param index - virtual column index
+          * @param column - column prop and cellCompare
           * @param order - order to apply
-          * @param additive - if false will replace current order
+          * @param additive - if false will replace current order  later passed to SortingPlugin
          */
-        "updateColumnSorting": (column: ColumnRegular, index: number, order: "asc" | "desc" | undefined, additive: boolean) => Promise<ColumnRegular>;
+        "updateColumnSorting": (column: Pick<ColumnRegular, "prop" | "cellCompare">, order: "asc" | "desc" | undefined, additive: boolean) => Promise<void>;
         /**
           * Update columns
          */
@@ -834,7 +833,7 @@ declare global {
         "beforecolumnapplied": ColumnCollection;
         "aftercolumnsset": {
     columns: ColumnCollection;
-    order: Record<ColumnProp, 'asc' | 'desc' | undefined>;
+    order: SortingOrder;
   };
         "beforefilterapply": { collection: Record<ColumnProp, FilterCollectionItem> };
         "beforefiltertrimmed": {
@@ -1384,7 +1383,7 @@ declare namespace LocalJSX {
          */
         "onAftercolumnsset"?: (event: RevoGridCustomEvent<{
     columns: ColumnCollection;
-    order: Record<ColumnProp, 'asc' | 'desc' | undefined>;
+    order: SortingOrder;
   }>) => void;
         /**
           * After data applied or range changed.
@@ -1484,7 +1483,7 @@ declare namespace LocalJSX {
          */
         "onBeforerowdefinition"?: (event: RevoGridCustomEvent<{ vals: any; oldVals: any }>) => void;
         /**
-          * By `sorting.plugin.ts` <br>Triggered immediately after header click. <br>First in sorting event sequence. Ff this event stops no other event called. <br>Use `e.preventDefault()` to prevent sorting.
+          * By `SortingPlugin` <br>Triggered immediately after header click. <br>First in sorting event sequence. Ff this event stops no other event called. <br>Use `e.preventDefault()` to prevent sorting.
          */
         "onBeforesorting"?: (event: RevoGridCustomEvent<{
     column: ColumnRegular;
@@ -1492,7 +1491,7 @@ declare namespace LocalJSX {
     additive: boolean;
   }>) => void;
         /**
-          * By `sorting.plugin.ts` <br> After `beforesorting` <br>Triggered after column data updated with new sorting order. <br>Use `e.preventDefault()` to prevent sorting data change.
+          * By `SortingPlugin` <br> After `beforesorting` <br>Triggered after column data updated with new sorting order. <br>Use `e.preventDefault()` to prevent sorting data change.
          */
         "onBeforesortingapply"?: (event: RevoGridCustomEvent<{
     column: ColumnRegular;
@@ -1507,7 +1506,7 @@ declare namespace LocalJSX {
     source: DataType[];
   }>) => void;
         /**
-          * By `sorting.plugin.ts` <br>Same as `beforesorting` but triggered after `beforeanysource` (when source is changed). <br>Use `e.preventDefault()` to prevent sorting data change.
+          * By `SortingPlugin` <br>Same as `beforesorting` but triggered after `beforeanysource` (when source is changed). <br>Use `e.preventDefault()` to prevent sorting data change.
          */
         "onBeforesourcesortingapply"?: (event: RevoGridCustomEvent<{
     type: DimensionRows;
@@ -1550,7 +1549,7 @@ declare namespace LocalJSX {
          */
         "onRoworderchanged"?: (event: RevoGridCustomEvent<{ from: number; to: number }>) => void;
         /**
-          * Emitted when the sorting configuration is changed
+          * Emitted when the sorting configuration is changed SortingPlugin subsribed to this event
          */
         "onSortingconfigchanged"?: (event: RevoGridCustomEvent<SortingConfig>) => void;
         /**
@@ -1605,7 +1604,7 @@ declare namespace LocalJSX {
          */
         "rowSize"?: number;
         /**
-          * Alternative way to set sorting. `{columns: [{prop: 'name', order: 'asc'}]}`
+          * Alternative way to set sorting. `{columns: [{prop: 'name', order: 'asc'}]}` Use SortingPlugin to get current sorting state
          */
         "sorting"?: SortingConfig;
         /**

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

@@ -7,8 +7,7 @@ export * from './sorting.sign';
 /**
  * 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.
- * 1.1. @event `beforesourcesortingapply` - Triggered before the sorting data is applied to the data source. You can prevent this event, and the data will not be sorted.
- * 2. Method `updateColumnSorting` - Updates the column sorting icon on the grid and the column itself, but the data remains untouched.
+ * 2. @event `beforesourcesortingapply` - Triggered before the sorting data is applied to the data source. You can prevent this event, and the data will not be sorted.
  * 3. @event `beforesortingapply` - Triggered before the sorting data is applied to the data source. You can prevent this event, and the data will not be sorted. This event is only called from a column sorting click.
  * 4. @event `aftersortingapply` - Triggered after sorting has been applied and completed. This event occurs for both row and column sorting.
  *
@@ -18,16 +17,25 @@ export declare class SortingPlugin extends BasePlugin {
     revogrid: HTMLRevoGridElement;
     sorting?: SortingOrder;
     sortingFunc?: SortingOrderFunction;
+    /**
+     * Delayed sorting promise
+     */
     sortingPromise: (() => void) | null;
+    /**
+     * We need to sort only so often
+     */
     postponeSort: import("lodash").DebouncedFunc<(order?: SortingOrder, comparison?: SortingOrderFunction, ignoreViewportUpdate?: boolean) => void>;
-    runSorting(order?: SortingOrder, comparison?: SortingOrderFunction, ignoreViewportUpdate?: boolean): void;
     constructor(revogrid: HTMLRevoGridElement, providers: PluginProviders, config?: SortingConfig);
+    /**
+     * Entry point for sorting, waits for all delayes, registers jobs
+     */
     startSorting(order?: SortingOrder, sortingFunc?: SortingOrderFunction, ignoreViewportUpdate?: boolean): void;
     /**
      * Apply sorting to data on header click
      * If additive - add to existing sorting, multiple columns can be sorted
      */
-    headerclick(column: ColumnRegular, index: number, additive: boolean): void;
+    headerclick(column: ColumnRegular, additive: boolean): void;
+    runSorting(order?: SortingOrder, comparison?: SortingOrderFunction, ignoreViewportUpdate?: boolean): void;
     /**
      * Sort items by sorting function
      * @requires proxyItems applied to row store

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

@@ -10,4 +10,5 @@ export type SortingConfig = {
         order: Order;
         cellCompare?: CellCompareFunc;
     }[];
+    additive?: boolean;
 };

package/dist/types/services/column.data.provider.d.ts

@@ -2,13 +2,9 @@ import { DataStore } from "../store/index";
 import type { ColumnProp, ColumnRegular, DimensionCols } from "../types/index";
 import { ColumnCollection } from '../utils/column.utils';
 export type ColumnDataSources = Record<DimensionCols, DataStore<ColumnRegular, DimensionCols>>;
-type Sorting = Record<ColumnProp, ColumnRegular>;
-type SortingOrder = Record<ColumnProp, 'asc' | 'desc' | undefined>;
 export default class ColumnDataProvider {
     readonly dataSources: ColumnDataSources;
-    sorting: Sorting | null;
     collection: ColumnCollection | null;
-    get order(): SortingOrder;
     get stores(): ColumnDataSources;
     constructor();
     column(c: number, type?: DimensionCols): ColumnRegular | undefined;
@@ -28,7 +24,4 @@ export default class ColumnDataProvider {
      */
     updateColumns(updatedColumns: ColumnRegular[]): void;
     updateColumn(column: ColumnRegular, index: number): void;
-    updateColumnSorting(column: ColumnRegular, index: number, sorting: 'asc' | 'desc' | undefined, additive: boolean): ColumnRegular;
-    clearSorting(): void;
 }
-export {};

package/hydrate/index.js

@@ -10598,89 +10598,11 @@ class RevoEdit {
     }; }
 }
 
-/**
- * A specialized version of `_.forEach` for arrays without support for
- * iteratee shorthands.
- *
- * @private
- * @param {Array} [array] The array to iterate over.
- * @param {Function} iteratee The function invoked per iteration.
- * @returns {Array} Returns `array`.
- */
-function arrayEach(array, iteratee) {
-  var index = -1,
-      length = array == null ? 0 : array.length;
-
-  while (++index < length) {
-    if (iteratee(array[index], index, array) === false) {
-      break;
-    }
-  }
-  return array;
-}
-
-/**
- * Casts `value` to `identity` if it's not a function.
- *
- * @private
- * @param {*} value The value to inspect.
- * @returns {Function} Returns cast function.
- */
-function castFunction(value) {
-  return typeof value == 'function' ? value : identity;
-}
-
-/**
- * Iterates over elements of `collection` and invokes `iteratee` for each element.
- * The iteratee is invoked with three arguments: (value, index|key, collection).
- * Iteratee functions may exit iteration early by explicitly returning `false`.
- *
- * **Note:** As with other "Collections" methods, objects with a "length"
- * property are iterated like arrays. To avoid this behavior use `_.forIn`
- * or `_.forOwn` for object iteration.
- *
- * @static
- * @memberOf _
- * @since 0.1.0
- * @alias each
- * @category Collection
- * @param {Array|Object} collection The collection to iterate over.
- * @param {Function} [iteratee=_.identity] The function invoked per iteration.
- * @returns {Array|Object} Returns `collection`.
- * @see _.forEachRight
- * @example
- *
- * _.forEach([1, 2], function(value) {
- *   console.log(value);
- * });
- * // => Logs `1` then `2`.
- *
- * _.forEach({ 'a': 1, 'b': 2 }, function(value, key) {
- *   console.log(key);
- * });
- * // => Logs 'a' then 'b' (iteration order is not guaranteed).
- */
-function forEach(collection, iteratee) {
-  var func = isArray$1(collection) ? arrayEach : baseEach$1;
-  return func(collection, castFunction(iteratee));
-}
-
 class ColumnDataProvider {
-    get order() {
-        const order = {};
-        const sorting = this.sorting;
-        if (sorting) {
-            Object.keys(sorting).forEach(prop => {
-                order[prop] = sorting[prop].order;
-            });
-        }
-        return order;
-    }
     get stores() {
         return this.dataSources;
     }
     constructor() {
-        this.sorting = null;
         this.collection = null;
         this.dataSources = columnTypes.reduce((sources, k) => {
             sources[k] = new DataStore(k);
@@ -10739,7 +10661,6 @@ class ColumnDataProvider {
                 }, {}),
             });
         });
-        this.sorting = data.sort;
         this.collection = data;
         return data;
     }
@@ -10788,31 +10709,6 @@ class ColumnDataProvider {
         const type = getColumnType(column);
         setSourceByVirtualIndex(this.dataSources[type].store, { [index]: column });
     }
-    updateColumnSorting(column, index, sorting, additive) {
-        if (!additive) {
-            this.clearSorting();
-        }
-        column.order = sorting;
-        if (!this.sorting) {
-            this.sorting = {};
-        }
-        this.sorting[column.prop] = column;
-        this.updateColumn(column, index);
-        return column;
-    }
-    clearSorting() {
-        const types = reduce(this.sorting, (r, c) => {
-            const k = getColumnType(c);
-            r[k] = true;
-            return r;
-        }, {});
-        forEach(types, (_, type) => {
-            const cols = this.dataSources[type].store.get('source');
-            forEach(cols, (c) => (c.order = undefined));
-            this.dataSources[type].setData({ source: [...cols] });
-        });
-        this.sorting = {};
-    }
 }
 
 /**
@@ -11079,6 +10975,73 @@ class ViewportProvider {
     }
 }
 
+/**
+ * A specialized version of `_.forEach` for arrays without support for
+ * iteratee shorthands.
+ *
+ * @private
+ * @param {Array} [array] The array to iterate over.
+ * @param {Function} iteratee The function invoked per iteration.
+ * @returns {Array} Returns `array`.
+ */
+function arrayEach(array, iteratee) {
+  var index = -1,
+      length = array == null ? 0 : array.length;
+
+  while (++index < length) {
+    if (iteratee(array[index], index, array) === false) {
+      break;
+    }
+  }
+  return array;
+}
+
+/**
+ * Casts `value` to `identity` if it's not a function.
+ *
+ * @private
+ * @param {*} value The value to inspect.
+ * @returns {Function} Returns cast function.
+ */
+function castFunction(value) {
+  return typeof value == 'function' ? value : identity;
+}
+
+/**
+ * Iterates over elements of `collection` and invokes `iteratee` for each element.
+ * The iteratee is invoked with three arguments: (value, index|key, collection).
+ * Iteratee functions may exit iteration early by explicitly returning `false`.
+ *
+ * **Note:** As with other "Collections" methods, objects with a "length"
+ * property are iterated like arrays. To avoid this behavior use `_.forIn`
+ * or `_.forOwn` for object iteration.
+ *
+ * @static
+ * @memberOf _
+ * @since 0.1.0
+ * @alias each
+ * @category Collection
+ * @param {Array|Object} collection The collection to iterate over.
+ * @param {Function} [iteratee=_.identity] The function invoked per iteration.
+ * @returns {Array|Object} Returns `collection`.
+ * @see _.forEachRight
+ * @example
+ *
+ * _.forEach([1, 2], function(value) {
+ *   console.log(value);
+ * });
+ * // => Logs `1` then `2`.
+ *
+ * _.forEach({ 'a': 1, 'b': 2 }, function(value, key) {
+ *   console.log(key);
+ * });
+ * // => Logs 'a' then 'b' (iteration order is not guaranteed).
+ */
+function forEach(collection, iteratee) {
+  var func = isArray$1(collection) ? arrayEach : baseEach$1;
+  return func(collection, castFunction(iteratee));
+}
+
 /**
  * Base layer for plugins
  * Provide minimal starting core for plugins to work
@@ -12130,24 +12093,23 @@ const SortingSign = ({ column }) => {
 /**
  * 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.
- * 1.1. @event `beforesourcesortingapply` - Triggered before the sorting data is applied to the data source. You can prevent this event, and the data will not be sorted.
- * 2. Method `updateColumnSorting` - Updates the column sorting icon on the grid and the column itself, but the data remains untouched.
+ * 2. @event `beforesourcesortingapply` - Triggered before the sorting data is applied to the data source. You can prevent this event, and the data will not be sorted.
  * 3. @event `beforesortingapply` - Triggered before the sorting data is applied to the data source. You can prevent this event, and the data will not be sorted. This event is only called from a column sorting click.
  * 4. @event `aftersortingapply` - Triggered after sorting has been applied and completed. This event occurs for both row and column sorting.
  *
  * Note: If you prevent an event, it will not proceed to the subsequent steps.
  */
 class SortingPlugin extends BasePlugin {
-    runSorting(order, comparison, ignoreViewportUpdate) {
-        var _a;
-        this.sort(order, comparison, undefined, ignoreViewportUpdate);
-        (_a = this.sortingPromise) === null || _a === void 0 ? void 0 : _a.call(this);
-        this.sortingPromise = null;
-    }
     constructor(revogrid, providers, config) {
         super(revogrid, providers);
         this.revogrid = revogrid;
+        /**
+         * Delayed sorting promise
+         */
         this.sortingPromise = null;
+        /**
+         * We need to sort only so often
+         */
         this.postponeSort = debounce$1((order, comparison, ignoreViewportUpdate) => this.runSorting(order, comparison, ignoreViewportUpdate), 50);
         const setConfig = (cfg) => {
             var _a;
@@ -12158,9 +12120,15 @@ class SortingPlugin extends BasePlugin {
                     sortingFunc[col.prop] = getComparer(col, col.order);
                     order[col.prop] = col.order;
                 });
-                // // set sorting
-                this.sorting = order;
-                this.sortingFunc = sortingFunc;
+                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);
@@ -12169,6 +12137,13 @@ class SortingPlugin extends BasePlugin {
             setConfig(detail);
             this.startSorting(this.sorting, this.sortingFunc);
         });
+        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] });
+            }
+        });
         this.addEventListener('beforeanysource', ({ detail: { type }, }) => {
             // if sorting was provided - sort data
             if (!!this.sorting && this.sortingFunc) {
@@ -12202,9 +12177,12 @@ class SortingPlugin extends BasePlugin {
             if (!((_b = (_a = e.detail) === null || _a === void 0 ? void 0 : _a.column) === null || _b === void 0 ? void 0 : _b.sortable)) {
                 return;
             }
-            this.headerclick(e.detail.column, e.detail.index, (_d = (_c = e.detail) === null || _c === void 0 ? void 0 : _c.originalEvent) === null || _d === void 0 ? void 0 : _d.shiftKey);
+            this.headerclick(e.detail.column, (_d = (_c = e.detail) === null || _c === void 0 ? void 0 : _c.originalEvent) === null || _d === void 0 ? void 0 : _d.shiftKey);
         });
     }
+    /**
+     * Entry point for sorting, waits for all delayes, registers jobs
+     */
     startSorting(order, sortingFunc, ignoreViewportUpdate) {
         if (!this.sortingPromise) {
             // add job before render
@@ -12218,18 +12196,18 @@ class SortingPlugin extends BasePlugin {
      * Apply sorting to data on header click
      * If additive - add to existing sorting, multiple columns can be sorted
      */
-    headerclick(column, index, additive) {
-        var _a, _b;
-        let order = getNextOrder(column.order);
+    headerclick(column, additive) {
+        var _a, _b, _c;
+        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 });
         if (beforeEvent.defaultPrevented) {
             return;
         }
         order = beforeEvent.detail.order;
-        const newCol = this.providers.column.updateColumnSorting(beforeEvent.detail.column, index, order, additive);
         // apply sort data
         const beforeApplyEvent = this.emit('beforesortingapply', {
-            column: newCol,
+            column: beforeEvent.detail.column,
             order,
             additive,
         });
@@ -12243,28 +12221,34 @@ class SortingPlugin extends BasePlugin {
             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);
-            if (column.prop in sorting && size$1(sorting) > 1 && order === undefined) {
-                delete sorting[column.prop];
-                delete sortingFunc[column.prop];
+            if (columnProp in sorting && size$1(sorting) > 1 && order === undefined) {
+                delete sorting[columnProp];
+                delete sortingFunc[columnProp];
             }
             else {
-                sorting[column.prop] = order;
-                sortingFunc[column.prop] = cmp;
+                sorting[columnProp] = order;
+                sortingFunc[columnProp] = cmp;
             }
         }
         else {
             if (order) {
                 // reset sorting
-                this.sorting = { [column.prop]: order };
-                this.sortingFunc = { [column.prop]: cmp };
+                this.sorting = { [columnProp]: order };
+                this.sortingFunc = { [columnProp]: cmp };
             }
             else {
-                (_a = this.sorting) === null || _a === void 0 ? true : delete _a[column.prop];
-                (_b = this.sortingFunc) === null || _b === void 0 ? true : delete _b[column.prop];
+                (_b = this.sorting) === null || _b === void 0 ? true : delete _b[columnProp];
+                (_c = this.sortingFunc) === null || _c === void 0 ? true : delete _c[columnProp];
             }
         }
         this.startSorting(this.sorting, this.sortingFunc);
     }
+    runSorting(order, comparison, ignoreViewportUpdate) {
+        var _a;
+        this.sort(order, comparison, undefined, ignoreViewportUpdate);
+        (_a = this.sortingPromise) === null || _a === void 0 ? void 0 : _a.call(this);
+        this.sortingPromise = null;
+    }
     /**
      * Sort items by sorting function
      * @requires proxyItems applied to row store
@@ -12310,6 +12294,10 @@ class SortingPlugin extends BasePlugin {
                 }
             }
         }
+        // refresh columns to redraw column headers and show correct icon
+        columnTypes.forEach((type) => {
+            this.providers.column.dataSources[type].refresh();
+        });
         this.emit('aftersortingapply');
     }
 }
@@ -14568,25 +14556,29 @@ class RevoGridComponent {
     }
     /**
      * Update column sorting
-     * @param column - full column details to update
-     * @param index - virtual column index
+     * @param column - column prop and cellCompare
      * @param order - order to apply
      * @param additive - if false will replace current order
+     *
+     * later passed to SortingPlugin
      */
-    async updateColumnSorting(column, index, order, additive) {
-        if (!this.columnProvider) {
-            throw new Error('Not connected');
-        }
-        return this.columnProvider.updateColumnSorting(column, index, order, additive);
+    async updateColumnSorting(column, order, additive) {
+        this.sortingconfigchanged.emit({
+            columns: [{
+                    prop: column.prop,
+                    order,
+                    cellCompare: column.cellCompare,
+                }],
+            additive,
+        });
     }
     /**
      * Clears column sorting
      */
     async clearSorting() {
-        if (!this.columnProvider) {
-            throw new Error('Not connected');
-        }
-        this.columnProvider.clearSorting();
+        this.sortingconfigchanged.emit({
+            columns: [],
+        });
     }
     /**
      * Receive all columns in data source
@@ -14794,7 +14786,10 @@ class RevoGridComponent {
         const columns = this.columnProvider.setColumns(beforeApplyEvent.detail);
         this.aftercolumnsset.emit({
             columns,
-            order: this.columnProvider.order,
+            order: Object.entries(beforeApplyEvent.detail.sort).reduce((acc, [prop, column]) => {
+                acc[prop] = column.order;
+                return acc;
+            }, {}),
         });
     }
     disableVirtualXChanged(newVal = false, prevVal = false) {