@revolist/revogrid 4.9.41 → 4.9.42

package/dist/types/index.d.ts

@@ -4,4 +4,4 @@ export * from './plugins';
 export * from './components';
 export * from './utils';
 export { TextEditor } from './components/editors/text-editor';
-export { h } from './stencil-public-runtime';
+export { h, type FunctionalComponent } from './stencil-public-runtime';

package/dist/types/plugins/add-rows-on-paste.plugin.d.ts

@@ -0,0 +1,14 @@
+import type { PluginProviders } from '../types/plugin.types';
+import { BasePlugin } from './base.plugin';
+/**
+ * Automatically adds new rows when pasted data is larger than current rows
+ * @event newRows - is triggered when new rows are added. Data of new rows can be filled with default values. If the event is prevented, no rows will be added. Event data: { newRows: RowData[] }
+ */
+export declare class AutoAddRowsPlugin extends BasePlugin {
+    constructor(revogrid: HTMLRevoGridElement, providers: PluginProviders);
+    handleBeforePasteApply(event: CustomEvent<{
+        raw: string;
+        parsed: string[][];
+        event: ClipboardEvent;
+    }>): void;
+}

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

@@ -1,6 +1,6 @@
 import { h } from '../stencil-public-runtime';
-import { PluginProviders, PluginBaseComponent } from '..';
-type WatchConfig = {
+import type { PluginProviders, PluginBaseComponent, RevoGridCustomEvent } from '..';
+export type WatchConfig = {
     immediate: boolean;
 };
 /**
@@ -19,7 +19,7 @@ export declare class BasePlugin implements PluginBaseComponent {
      * @param eventName - event name to subscribe to in revo-grid component (e.g. 'beforeheaderclick')
      * @param callback - callback function for event
      */
-    addEventListener<T = any>(eventName: string, callback: (e: CustomEvent<T>) => void): void;
+    addEventListener<K extends keyof HTMLRevoGridElementEventMap>(eventName: K, callback: (this: BasePlugin, e: RevoGridCustomEvent<HTMLRevoGridElementEventMap[K]>) => void): void;
     /**
      * Subscribe to property change in revo-grid component
      * You can return false in callback to prevent default value set
@@ -49,4 +49,3 @@ export declare class BasePlugin implements PluginBaseComponent {
     destroy(): void;
 }
 export type GridPlugin = (typeof BasePlugin);
-export {};

package/dist/types/plugins/column.auto-size.plugin.d.ts

@@ -30,7 +30,7 @@ declare enum ColumnAutoSizeMode {
     autoSizeOnTextOverlap = "autoSizeOnTextOverlap",
     autoSizeAll = "autoSizeAll"
 }
-export default class AutoSizeColumnPlugin extends BasePlugin {
+export declare class AutoSizeColumnPlugin extends BasePlugin {
     providers: PluginProviders;
     config?: AutoSizeColumnConfig | undefined;
     autoSizeColumns: Partial<AutoSizeColumns> | null;

package/dist/types/plugins/column.stretch.plugin.d.ts

@@ -1,6 +1,6 @@
 import { BasePlugin } from './base.plugin';
 import { DimensionCols, PluginBaseComponent, PluginProviders, ColumnRegular } from "../types/index";
-export default class StretchColumn extends BasePlugin {
+export declare class StretchColumn extends BasePlugin {
     providers: PluginProviders;
     private stretchedColumn;
     private readonly scrollSize;

package/dist/types/plugins/export/csv.d.ts

@@ -1,6 +1,6 @@
 import { CSVFormat, DataInput, Formatter } from './types';
 export type CSVFormatter = (options: Partial<CSVFormat>, data: DataInput) => string;
-export default class ExportCsv implements Formatter {
+export declare class ExportCsv implements Formatter {
     readonly options: Readonly<CSVFormat>;
     constructor(options?: Partial<CSVFormat>);
     doExport({ data, headers, props }: DataInput): string;

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

@@ -1,10 +1,12 @@
 import { BasePlugin } from '../base.plugin';
-import { CSVFormat, Formatter } from './types';
+import type { CSVFormat, Formatter } from './types';
+export * from './csv';
+export * from './types';
 declare enum ExportTypes {
     csv = "csv"
 }
 export type ExportFormat = Partial<CSVFormat>;
-export default class ExportFilePlugin extends BasePlugin {
+export declare class ExportFilePlugin extends BasePlugin {
     /** Exports string */
     exportString(options?: ExportFormat, t?: ExportTypes): Promise<string | null>;
     /** Exports Blob */
@@ -21,4 +23,3 @@ export default class ExportFilePlugin extends BasePlugin {
     private getSource;
     private formatter;
 }
-export {};

package/dist/types/plugins/filter/filter.panel.d.ts

@@ -1,7 +1,7 @@
-import { EventEmitter, VNode } from '../../stencil-public-runtime';
+import { EventEmitter, type VNode } from '../../stencil-public-runtime';
 import '../../utils/closest.polifill';
 import { FilterCaptions, LogicFunction, MultiFilterItem, ShowData } from './filter.types';
-import { ColumnProp } from "../../types/index";
+import type { ColumnProp } from "../../types/index";
 import { FilterType } from './filter.indexed';
 /**
  * Filter panel for editing filters

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

@@ -1,6 +1,7 @@
+import { type VNode } from '../../stencil-public-runtime';
 import type { ColumnProp, ColumnRegular, DataType, PluginProviders } from "../../types/index";
 import { BasePlugin } from '../base.plugin';
-import type { ColumnFilterConfig, FilterCollection, LogicFunction, MultiFilterItem } from './filter.types';
+import type { ColumnFilterConfig, FilterCollectionItem, LogicFunction, MultiFilterItem, ShowData } from './filter.types';
 export * from './filter.types';
 export * from './filter.indexed';
 export * from './filter.button';
@@ -10,27 +11,43 @@ export declare const FILTE_PANEL = "revogr-filter-panel";
 /**
  * @typedef ColumnFilterConfig
  * @type {object}
- * @property {FilterCollection|undefined} collection - preserved filter data
+ *
+ * @property {MultiFilterItem|undefined} multiFilterItems - data for multi filtering with relation
+ *
+ * @property {Record<ColumnProp, FilterCollectionItem>|undefined} collection - preserved filter data, relation for filters will be applied as 'and'
+ *
  * @property {string[]|undefined} include - filters to be included, if defined everything else out of scope will be ignored
+ *
  * @property {Record<string, CustomFilter>|undefined} customFilters - hash map of {FilterType:CustomFilter}.
+ *
  * @property {FilterLocalization|undefined} localization - translation for filter popup captions.
- * @property {MultiFilterItem|undefined} multiFilterItems - data for multi filtering.
+ *
  * @property {boolean|undefined} disableDynamicFiltering - disables dynamic filtering. A way to apply filters on Save only.
- * A way to define your own filter types per column
  */
 /**
  * @internal
  */
 export declare class FilterPlugin extends BasePlugin {
     revogrid: HTMLRevoGridElement;
+    config?: ColumnFilterConfig | undefined;
     pop?: HTMLRevogrFilterPanelElement;
-    filterCollection: FilterCollection;
+    filterCollection: Record<ColumnProp, FilterCollectionItem>;
     multiFilterItems: MultiFilterItem;
+    /**
+     * Filter types
+     * @example
+     * {
+     *    string: ['contains', 'beginswith'],
+     *    number: ['eqN', 'neqN', 'gt']
+     *  }
+     */
     filterByType: Record<string, string[]>;
     filterNameIndexByType: Record<string, string>;
     filterFunctionsIndexedByType: Record<string, LogicFunction>;
     filterProp: string;
-    constructor(revogrid: HTMLRevoGridElement, providers: PluginProviders, config?: ColumnFilterConfig);
+    extraHyperContent?: (data: ShowData) => VNode | VNode[];
+    constructor(revogrid: HTMLRevoGridElement, providers: PluginProviders, config?: ColumnFilterConfig | undefined);
+    beforeshow(_: ShowData): void;
     extraContent(): any;
     initConfig(config: ColumnFilterConfig): void;
     headerclick(e: CustomEvent<ColumnRegular>): Promise<void>;
@@ -44,11 +61,12 @@ export declare class FilterPlugin extends BasePlugin {
     /**
      * Triggers grid filtering
      */
-    doFiltering(collection: FilterCollection, source: DataType[], columns: ColumnRegular[], filterItems: MultiFilterItem): Promise<void>;
+    doFiltering(collection: Record<ColumnProp, FilterCollectionItem>, source: DataType[], columns: ColumnRegular[], filterItems: MultiFilterItem): Promise<void>;
     clearFiltering(): Promise<void>;
     runFiltering(multiFilterItems: MultiFilterItem): Promise<void>;
     /**
      * Get trimmed rows based on filter
      */
     getRowFilter(rows: DataType[], filterItems: MultiFilterItem, columnByProp: Record<string, ColumnRegular>): Record<number, boolean>;
+    private shouldTrimRow;
 }

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

@@ -1,5 +1,5 @@
-import { ColumnProp } from "../../types/index";
-import { FilterType } from './filter.indexed';
+import type { ColumnProp, ColumnRegular } from "../../types/index";
+import type { FilterType } from './filter.indexed';
 export type DateEnum = 'today' | 'yesterday' | 'tomorrow' | 'thisweek' | 'lastweek' | 'nextweek' | 'thismonth' | 'lastmonth' | 'nextmonth' | 'thisyear' | 'lastyear' | 'nextyear';
 export type ExtraField = 'input' | 'select' | 'multi' | 'datepicker';
 export type LogicFunctionParam = any;
@@ -8,9 +8,18 @@ export type LogicFunction<T1 = LogicFunctionParam, T2 = LogicFunctionExtraParam>
     (value: T1, extra?: T2): boolean;
     extra?: ExtraField;
 };
-type CustomFilter<T1 = LogicFunctionParam, T2 = LogicFunctionExtraParam> = {
+export type CustomFilter<T1 = LogicFunctionParam, T2 = LogicFunctionExtraParam> = {
+    /**
+     * Property defined in column { filter: string/number/abstract/enum...etc }
+     */
     columnFilterType: string;
+    /**
+     * Filter name
+     */
     name: string;
+    /**
+     * Function to apply the filter
+     */
     func: LogicFunction<T1, T2>;
 };
 export type FilterCaptions = {
@@ -35,7 +44,7 @@ export type ColumnFilterConfig = {
     /**
      * The collection of filters to be applied to the column.
      */
-    collection?: FilterCollection;
+    collection?: Record<ColumnProp, FilterCollectionItem>;
     /**
      * The names of the filters to be included in the filter dropdown.
      */
@@ -62,12 +71,10 @@ export type ColumnFilterConfig = {
      */
     disableDynamicFiltering?: boolean;
 };
-type FilterCollectionItem = {
-    filter: LogicFunction;
+export type FilterCollectionItem = {
     type: FilterType;
     value?: any;
 };
-export type FilterCollection = Record<ColumnProp, FilterCollectionItem>;
 export type FilterItem = {
     prop?: ColumnProp;
     type?: FilterType;
@@ -75,9 +82,22 @@ export type FilterItem = {
 };
 export type FilterData = {
     id: number;
+    /**
+     * Filter type
+     */
     type: FilterType;
+    /**
+     * Filter value
+     */
     value?: any;
-    relation: 'and' | 'or';
+    /**
+     * Filter invisible in filter panel
+     */
+    hidden?: boolean;
+    /**
+     * Filter relation
+     */
+    relation?: 'and' | 'or';
 };
 export type MultiFilterItem = {
     [prop: string]: FilterData[];
@@ -90,5 +110,7 @@ export type ShowData = {
      */
     autoCorrect?: boolean;
     filterTypes?: Record<string, string[]>;
-} & FilterItem;
-export {};
+    filterItems?: MultiFilterItem;
+    hideDefaultFilters?: boolean;
+    extraContent?: (data: ShowData) => any;
+} & FilterItem & Omit<ColumnRegular, 'filter'>;

package/dist/types/plugins/groupingColumn/columnGroupsRenderer.d.ts

@@ -1,4 +1,4 @@
-import { VNode } from '../../stencil-public-runtime';
+import { h } from '../../stencil-public-runtime';
 import { Group } from "../../store/index";
 import { DimensionSettingsState, Providers, DimensionCols } from "../../types/index";
 import { ResizeProps } from '../../components/header/resizable.directive';
@@ -14,5 +14,5 @@ type Props<T> = {
     additionalData: any;
     onResize(changedX: number, startIndex: number, endIndex: number): void;
 } & Partial<Pick<ResizeProps, 'active'>>;
-declare const ColumnGroupsRenderer: ({ additionalData, providers, depth, groups, visibleProps, dimensionCol, canResize, active, onResize }: Props<DimensionCols | "rowHeaders">) => VNode[];
+declare const ColumnGroupsRenderer: ({ additionalData, providers, depth, groups, visibleProps, dimensionCol, canResize, active, onResize }: Props<DimensionCols | "rowHeaders">) => ReturnType<typeof h>[];
 export default ColumnGroupsRenderer;

package/dist/types/plugins/groupingColumn/headerGroupRenderer.d.ts

@@ -1,8 +1,7 @@
-import { VNode } from '../../stencil-public-runtime';
+import { h } from '../../stencil-public-runtime';
 import { Group } from "../../store/index";
-import { Providers } from "../../types/index";
+import type { Providers, DimensionCols } from "../../types/index";
 import { ResizeEvent, ResizeProps } from '../../components/header/resizable.directive';
-import { DimensionCols } from '../../components';
 type Props = {
     start: number;
     end: number;
@@ -12,5 +11,5 @@ type Props = {
     canResize?: boolean;
     onResize?(e: ResizeEvent): void;
 } & Partial<Pick<ResizeProps, 'active'>>;
-declare const GroupHeaderRenderer: (p: Props) => VNode[];
+declare const GroupHeaderRenderer: (p: Props) => ReturnType<typeof h>;
 export default GroupHeaderRenderer;

package/dist/types/plugins/groupingRow/grouping.const.d.ts

@@ -1,10 +1,12 @@
+import { DimensionRows } from "../../types/index";
 export declare const GROUP_DEPTH = "__rvgr-depth";
 export declare const PSEUDO_GROUP_ITEM = "__rvgr-name";
 export declare const PSEUDO_GROUP_ITEM_ID = "__rvgr-id";
 export declare const PSEUDO_GROUP_ITEM_VALUE = "__rvgr-value";
 export declare const PSEUDO_GROUP_COLUMN = "__rvgr-column";
 export declare const GROUP_EXPANDED = "__rvgr-expanded";
+export declare const GROUP_COLUMN_PROP = "__rvgr-prop";
 export declare const GROUP_ORIGINAL_INDEX = "__rvgr-original-index";
 export declare const GROUP_EXPAND_BTN = "group-expand";
 export declare const GROUP_EXPAND_EVENT = "groupexpandclick";
-export declare const GROUPING_ROW_TYPE = "rgRow";
+export declare const GROUPING_ROW_TYPE: DimensionRows;

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

@@ -1,24 +1,26 @@
-import { DSourceState } from "../../store/index";
+import { type DSourceState } from "../../store/index";
 import { BasePlugin } from '../base.plugin';
-import { GroupingOptions } from './grouping.row.types';
-import { DataType, DimensionRows, PluginProviders } from "../../types/index";
-import { Observable } from '../../utils/store.utils';
-export default class GroupingRowPlugin extends BasePlugin {
+import type { GroupingOptions, OnExpandEvent } from './grouping.row.types';
+import type { DataType, DimensionRows, PluginProviders } from "../../types/index";
+import type { Observable } from '../../utils';
+declare global {
+    interface HTMLRevoGridElementEventMap {
+        groupexpandclick: OnExpandEvent;
+    }
+}
+export declare class GroupingRowPlugin extends BasePlugin {
     revogrid: HTMLRevoGridElement;
     providers: PluginProviders;
     private options;
-    get hasProps(): number | undefined;
-    get store(): Observable<DSourceState<DataType, DimensionRows>>;
-    get rowItems(): number[];
-    get trimmed(): Record<any, any>;
+    getStore(type?: DimensionRows): Observable<DSourceState<DataType, DimensionRows>>;
     constructor(revogrid: HTMLRevoGridElement, providers: PluginProviders);
     private onFocus;
     private onExpand;
-    private getSource;
     private setColumnGrouping;
     private setColumns;
     private onDrag;
     private beforeTrimmedApply;
+    private isSortingRunning;
     private subscribe;
     /**
      * Starts global source update with group clearing and applying new one
@@ -31,6 +33,9 @@ export default class GroupingRowPlugin extends BasePlugin {
      * If source came from other plugin
      */
     private onDataSet;
+    /**
+     * Externam call to apply grouping. Called by revogrid when prop changed.
+     */
     setGrouping(options: GroupingOptions): void;
     clearGrouping(): void;
     private updateTrimmed;

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

@@ -1,17 +1,36 @@
-import { VNode } from '../../stencil-public-runtime';
-import { HyperFunc, ColumnProp, DimensionRows, DataType } from "../../types/index";
+import type { VNode } from '../../stencil-public-runtime';
+import type { HyperFunc, ColumnProp, DimensionRows, DataType } from "../../types/index";
 export type GroupLabelTemplateFunc = (createElement: HyperFunc<VNode>, props: {
     name: string;
     itemIndex: number;
     expanded: boolean;
     depth: number;
+    model?: DataType;
 }) => any;
 export type GroupingOptions = {
+    /**
+     * Column props to which grouping will be applied
+     */
     props?: ColumnProp[];
-    /** is expanded by default */
+    /**
+     * Currently expanded items.
+     * Corresponds to prop values as: source = [{ me: 'a' }, { me: 'b' }, { me: 'c' }], to set expanded: { a: true }
+     */
+    prevExpanded?: Record<string, boolean>;
+    /**
+     * Is expanded by default
+     */
     expandedAll?: boolean;
+    /**
+     * Should grouping be preserved on source update.
+     * default: true
+     */
+    preserveGroupingOnUpdate?: boolean;
+    /**
+     * Custom group label template
+     */
     groupLabelTemplate?: GroupLabelTemplateFunc;
-};
+} & ExpandedOptions;
 export type BeforeSourceSetEvent = {
     type: DimensionRows;
     source: DataType[];
@@ -25,3 +44,18 @@ export type SourceGather = {
     prevExpanded: Record<string, boolean>;
     oldNewIndexes?: Record<number, number>;
 };
+export type ExpandedOptions = {
+    prevExpanded?: Record<string, boolean>;
+    /**
+     * Is expanded by default
+     */
+    expandedAll?: boolean;
+    /**
+     * Custom group label value parser
+     */
+    getGroupValue?(item: DataType, prop: string | number): any;
+    /**
+     * Custom group label template
+     */
+    groupLabelTemplate?: GroupLabelTemplateFunc;
+};

package/dist/types/plugins/groupingRow/grouping.service.d.ts

@@ -1,19 +1,15 @@
-import { DataType, ColumnProp, ColumnRegular } from "../../types/index";
-import { GROUP_DEPTH, GROUP_EXPANDED, PSEUDO_GROUP_ITEM, PSEUDO_GROUP_ITEM_VALUE } from './grouping.const';
-import { GroupLabelTemplateFunc } from './grouping.row.types';
-export type ExpandedOptions = {
-    prevExpanded?: Record<string, boolean>;
-    expandedAll?: boolean;
-    getGroupValue?(item: DataType, prop: string | number): any;
-    groupLabelTemplate?: GroupLabelTemplateFunc;
-};
+import type { DataType, ColumnProp, ColumnRegular } from "../../types/index";
+import { GROUP_DEPTH, GROUP_EXPANDED, PSEUDO_GROUP_ITEM, PSEUDO_GROUP_ITEM_VALUE, GROUP_COLUMN_PROP } from './grouping.const';
+import type { ExpandedOptions, SourceGather } from './grouping.row.types';
+export declare function getSource(source: DataType[], items: number[], withoutGrouping?: boolean): Required<SourceGather>;
+export declare function getExpanded(model?: DataType): any;
 /**
  * Gather data for grouping
  * @param array - flat data array
- * @param groupIds - ids of groups
+ * @param columnProps - ids of groups
  * @param expanded - potentially expanded items if present
  */
-export declare function gatherGrouping(array: DataType[], groupIds: ColumnProp[], { prevExpanded, expandedAll, getGroupValue, }: ExpandedOptions): {
+export declare function gatherGrouping(array: DataType[], columnProps: ColumnProp[], { prevExpanded, expandedAll, getGroupValue, }: ExpandedOptions): {
     sourceWithGroups: DataType[];
     depth: number;
     trimmed: Record<number, boolean>;
@@ -26,9 +22,10 @@ type GroupingItem = {
     [GROUP_EXPANDED]: boolean;
     [PSEUDO_GROUP_ITEM_VALUE]: string;
     [GROUP_DEPTH]: number;
+    [GROUP_COLUMN_PROP]: ColumnProp;
 };
 export declare function isGrouping(rgRow?: DataType): rgRow is GroupingItem;
-export declare function isGroupingColumn(column?: ColumnRegular): boolean | undefined;
+export declare function isGroupingColumn(column?: ColumnRegular): boolean;
 export declare function measureEqualDepth<T>(groupA: T[], groupB: T[]): number;
 export declare function getParsedGroup(id: string): any[] | null;
 export declare function isSameGroup(currentGroup: any[], currentModel: DataType, nextModel: DataType): boolean;

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

@@ -7,6 +7,8 @@ export * from './filter/filter.plugin';
 export * from './groupingColumn/columnGroupsRenderer';
 export * from './groupingColumn/headerGroupRenderer';
 export * from './groupingRow/grouping.row.plugin';
+export * from './groupingRow/grouping.service';
 export * from './moveColumn/column.drag.plugin';
 export * from './sorting/sorting.plugin';
 export * from './sorting/sorting.sign';
+export * from './add-rows-on-paste.plugin';

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

@@ -1,5 +1,5 @@
 import { BasePlugin } from '../base.plugin';
-import { ColumnPropProp, DimensionCols, PluginProviders } from "../../types/index";
+import type { ColumnPropProp, DimensionCols, PluginProviders } from "../../types/index";
 export type DragStartEventDetails = {
     event: MouseEvent;
     data: ColumnPropProp;
@@ -15,7 +15,7 @@ export type ColumnDragEventData = {
     scrollOffset: number;
     type: DimensionCols;
 };
-export default class ColumnPlugin extends BasePlugin {
+export declare class ColumnMovePlugin extends BasePlugin {
     revogrid: HTMLRevoGridElement;
     providers: PluginProviders;
     private moveFunc;

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

@@ -0,0 +1,3 @@
+import type { DataType } from "../../types/index";
+import type { SortingOrderFunction } from './sorting.types';
+export declare function sortIndexByItems(indexes: number[], source: DataType[], sortingFunc?: SortingOrderFunction): number[];

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

@@ -1,26 +1,27 @@
 import { BasePlugin } from '../base.plugin';
-import { ColumnProp, Order, CellCompareFunc, ColumnRegular, DataType, DimensionRows, PluginProviders } from "../../types/index";
-export type SortingOrder = Record<ColumnProp, Order>;
-type SortingOrderFunction = Record<ColumnProp, CellCompareFunc | undefined>;
+import type { ColumnProp, Order, CellCompareFunc, ColumnRegular, DataType, DimensionRows, PluginProviders } from "../../types/index";
+import type { SortingConfig, SortingOrder, SortingOrderFunction } from './sorting.types';
+export * from './sorting.types';
 /**
  * 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.
  * 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.
  */
-export default class SortingPlugin extends BasePlugin {
+export declare class SortingPlugin extends BasePlugin {
     revogrid: HTMLRevoGridElement;
     sorting?: SortingOrder;
     sortingFunc?: SortingOrderFunction;
     sortingPromise: (() => void) | null;
-    postponeSort: import("lodash").DebouncedFunc<(order?: SortingOrder, comparison?: SortingOrderFunction) => void>;
-    runSorting(order?: SortingOrder, comparison?: SortingOrderFunction): void;
-    constructor(revogrid: HTMLRevoGridElement, providers: PluginProviders);
-    startSorting(order?: SortingOrder, sortingFunc?: SortingOrderFunction): void;
-    getComparer(column: ColumnRegular | undefined, order: Order): CellCompareFunc | undefined;
+    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);
+    startSorting(order?: SortingOrder, sortingFunc?: SortingOrderFunction, ignoreViewportUpdate?: boolean): void;
+    getComparer(column: Partial<ColumnRegular> | undefined, order: Order): CellCompareFunc | undefined;
     /**
      * Apply sorting to data on header click
      * If additive - add to existing sorting, multiple columns can be sorted
@@ -34,10 +35,10 @@ export default class SortingPlugin extends BasePlugin {
      * @param sorting - per column sorting
      * @param data - this.stores['rgRow'].store.get('source')
      */
-    sort(sorting?: SortingOrder, sortingFunc?: SortingOrderFunction, types?: DimensionRows[]): void;
-    defaultCellCompare(prop: ColumnProp, a: DataType, b: DataType): 0 | 1 | -1;
+    sort(sorting?: SortingOrder, sortingFunc?: SortingOrderFunction, types?: DimensionRows[], ignoreViewportUpdate?: boolean): void;
+    defaultCellCompare(this: {
+        column?: ColumnRegular;
+    }, prop: ColumnProp, a: DataType, b: DataType): 0 | 1 | -1;
     descCellCompare(cmp: CellCompareFunc): (prop: ColumnProp, a: DataType, b: DataType) => number;
-    sortIndexByItems(indexes: number[], source: DataType[], sortingFunc?: SortingOrderFunction): number[];
     getNextOrder(currentOrder: Order): Order;
 }
-export {};

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

@@ -0,0 +1,13 @@
+import type { CellCompareFunc, ColumnProp, Order } from "../../types/index";
+export type SortingOrder = Record<ColumnProp, Order>;
+export type SortingOrderFunction = Record<ColumnProp, CellCompareFunc | undefined>;
+export type ColumnSetEvent = {
+    order: SortingOrder;
+};
+export type SortingConfig = {
+    columns?: {
+        prop: ColumnProp;
+        order: Order;
+        cellCompare?: CellCompareFunc;
+    }[];
+};

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

@@ -1,5 +1,5 @@
 import { DataStore } from "../store/index";
-import type { ColumnProp, ColumnRegular, DimensionCols, DimensionColPin } from "../types/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>;
@@ -11,13 +11,16 @@ export default class ColumnDataProvider {
     get order(): SortingOrder;
     get stores(): ColumnDataSources;
     constructor();
-    column(c: number, pin?: DimensionColPin): ColumnRegular | undefined;
+    column(c: number, type?: DimensionCols): ColumnRegular | undefined;
     getColumn(virtualIndex: number, type: DimensionCols): ColumnRegular | undefined;
     getRawColumns(): Record<DimensionCols, ColumnRegular[]>;
     getColumns(type?: DimensionCols | 'all'): ColumnRegular[];
     getColumnIndexByProp(prop: ColumnProp, type: DimensionCols): number;
     getColumnByProp(prop: ColumnProp): ColumnRegular[] | undefined;
     refreshByType(type: DimensionCols): void;
+    /**
+     * Main method to set columns
+     */
     setColumns(data: ColumnCollection): ColumnCollection;
     /**
      * Used in plugins

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

@@ -7,6 +7,8 @@ export type RowDataSources = {
 };
 /**
  * Data source provider
+ *
+ * @dependsOn DimensionProvider
  */
 export declare class DataProvider {
     private dimensionProvider;
@@ -23,7 +25,7 @@ export declare class DataProvider {
         from: number;
         to: number;
     }): void;
-    setCellData({ type, rowIndex, prop, val }: BeforeSaveDataDetails, mutate?: boolean): void;
+    setCellData({ type, rowIndex, prop, val }: Pick<BeforeSaveDataDetails, 'type' | 'rowIndex' | 'prop' | 'val'>, mutate?: boolean): void;
     setRangeData(data: DataLookup, type: DimensionRows): void;
     refresh(type?: DimensionRows | 'all'): void;
     refreshItems(type?: DimensionRows): void;

package/dist/types/services/dimension.provider.d.ts

@@ -1,12 +1,14 @@
 import ViewportProvider from './viewport.provider';
 import { DimensionStoreCollection, Trimmed } from "../store/index";
-import { DimensionCols, DimensionType, MultiDimensionType, ColumnRegular, DimensionSettingsState, ViewPortScrollEvent, ViewSettingSizeProp } from "../types/index";
+import type { DimensionCols, DimensionType, MultiDimensionType, ColumnRegular, DimensionSettingsState, ViewPortScrollEvent, ViewSettingSizeProp } from "../types/index";
 export type DimensionConfig = {
     realSizeChanged(k: MultiDimensionType): void;
 };
 /**
  * Dimension provider
  * Stores dimension information and custom sizes
+ *
+ * @dependsOn ViewportProvider
  */
 export default class DimensionProvider {
     private viewports;
@@ -33,7 +35,7 @@ export default class DimensionProvider {
      */
     setTrimmed(trimmed: Trimmed, type: MultiDimensionType): void;
     /**
-     * Sets dimension data and view port coordinate
+     * Sets dimension data and viewport coordinate
      * @param itemCount
      * @param type - dimension type
      * @param noVirtual - disable virtual data
@@ -44,12 +46,15 @@ export default class DimensionProvider {
      * @param columns - new columns data
      * @param disableVirtualX - disable virtual data for X axis
      */
-    applyNewColumns(columns: Record<DimensionCols, ColumnRegular[]>, disableVirtualX: boolean): void;
+    applyNewColumns(columns: Record<DimensionCols, ColumnRegular[]>, disableVirtualX: boolean, keepOld?: boolean): void;
+    /**
+     * Gets the full size of the grid by summing up the sizes of all dimensions
+     * Goes through all dimensions columnTypes (x) and rowTypes (y) and sums up their sizes
+     */
     getFullSize(): {
         x: number;
         y: number;
     };
-    updateViewport(type: MultiDimensionType, force?: boolean): void;
     setViewPortCoordinate({ coordinate, type, force, }: {
         coordinate: number;
         type: MultiDimensionType;