@revolist/revogrid 4.0.2-next → 4.0.2

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

@@ -1,9 +1,10 @@
-export declare const GROUP_DEPTH: string;
-export declare const PSEUDO_GROUP_ITEM: string;
-export declare const PSEUDO_GROUP_ITEM_ID: string;
-export declare const PSEUDO_GROUP_ITEM_VALUE: string;
-export declare const PSEUDO_GROUP_COLUMN: string;
-export declare const GROUP_EXPANDED: string;
+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_ORIGINAL_INDEX = "__rvgr-original-index";
 export declare const GROUP_EXPAND_BTN = "group-expand";
-export declare const GROUP_EXPAND_EVENT = "groupExpandClick";
+export declare const GROUP_EXPAND_EVENT = "groupexpandclick";
 export declare const GROUPING_ROW_TYPE = "rgRow";

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

@@ -1,6 +1,6 @@
-import { RevoGrid } from '../../interfaces';
-export declare function doCollapse(pIndex: number, source: RevoGrid.DataType[]): {
-  trimmed: Record<number, boolean>;
+import { DataType } from '../..';
+export declare function doCollapse(pIndex: number, source: DataType[]): {
+    trimmed: Record<number, boolean>;
 };
 /**
  *
@@ -9,7 +9,7 @@ export declare function doCollapse(pIndex: number, source: RevoGrid.DataType[]):
  * @param source - data source
  * @param rowItemsIndexes - rgRow indexes
  */
-export declare function doExpand(vIndex: number, source: RevoGrid.DataType[], rowItemsIndexes: number[]): {
-  trimmed: Record<number, boolean>;
-  items?: number[];
+export declare function doExpand(vIndex: number, source: DataType[], rowItemsIndexes: number[]): {
+    trimmed: Record<number, boolean>;
+    items?: number[];
 };

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

@@ -1,40 +1,35 @@
-import { RevoGrid } from '../../interfaces';
-import ColumnDataProvider from '../../services/column.data.provider';
-import { DataProvider } from '../../services/data.provider';
-import BasePlugin from '../basePlugin';
+import { BasePlugin } from '../base.plugin';
 import { GroupingOptions } from './grouping.row.types';
+import { PluginProviders } from '../../';
 export default class GroupingRowPlugin extends BasePlugin {
-  protected revogrid: HTMLRevoGridElement;
-  private providers;
-  private options;
-  get hasProps(): number;
-  get store(): import("../../interfaces").Observable<import("../../store/dataSource/data.store").DataSourceState<RevoGrid.DataType, RevoGrid.DimensionRows>>;
-  get rowItems(): number[];
-  get trimmed(): import("../trimmed/trimmed.plugin").Trimmed;
-  constructor(revogrid: HTMLRevoGridElement, providers: {
-    dataProvider: DataProvider;
-    columnProvider: ColumnDataProvider;
-  });
-  private onFocus;
-  private onExpand;
-  private getSource;
-  private setColumnGrouping;
-  private setColumns;
-  private onDrag;
-  private beforeTrimmedApply;
-  private subscribe;
-  /**
-   * Starts global source update with group clearing and applying new one
-   * Initiated when need to reapply grouping
-   */
-  private doSourceUpdate;
-  /**
-   * Apply grouping on data set
-   * Clear grouping from source
-   * If source came from other plugin
-   */
-  private onDataSet;
-  setGrouping(options: GroupingOptions): void;
-  clearGrouping(): void;
-  private updateTrimmed;
+    protected revogrid: HTMLRevoGridElement;
+    protected providers: PluginProviders;
+    private options;
+    get hasProps(): number;
+    get store(): import("../..").Observable<import("../..").DSourceState<import("../..").DataType, import("../..").DimensionRows>>;
+    get rowItems(): number[];
+    get trimmed(): Record<any, any>;
+    constructor(revogrid: HTMLRevoGridElement, providers: PluginProviders);
+    private onFocus;
+    private onExpand;
+    private getSource;
+    private setColumnGrouping;
+    private setColumns;
+    private onDrag;
+    private beforeTrimmedApply;
+    private subscribe;
+    /**
+     * Starts global source update with group clearing and applying new one
+     * Initiated when need to reapply grouping
+     */
+    private doSourceUpdate;
+    /**
+     * Apply grouping on data set
+     * Clear grouping from source
+     * If source came from other plugin
+     */
+    private onDataSet;
+    setGrouping(options: GroupingOptions): void;
+    clearGrouping(): void;
+    private updateTrimmed;
 }

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

@@ -1,9 +1,11 @@
-import { RowProps } from '../../components/data/rowRenderer';
-import { RevoGrid } from '../../interfaces';
+import { RowProps } from '../../components/data/row-renderer';
+import { GroupLabelTemplateFunc } from './grouping.row.types';
+import { DataType, PositionItem } from '../../types/interfaces';
 interface GroupRowPros extends RowProps {
-  model: RevoGrid.DataType;
-  hasExpand: boolean;
+    model: DataType;
+    hasExpand: boolean;
+    groupingCustomRenderer?: GroupLabelTemplateFunc;
 }
-declare type Props = GroupRowPros & RevoGrid.PositionItem;
+type Props = GroupRowPros & PositionItem;
 declare const GroupingRowRenderer: (props: Props) => any;
 export default GroupingRowRenderer;

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

@@ -1,19 +1,27 @@
-import { RevoGrid } from '../../interfaces';
-export declare type GroupingOptions = {
-  props?: RevoGrid.ColumnProp[];
-  /** is expanded by default */
-  expandedAll?: boolean;
+import { VNode } from '../../stencil-public-runtime';
+import { HyperFunc, ColumnProp, DimensionRows, DataType } from '../..';
+export type GroupLabelTemplateFunc = (createElement: HyperFunc<VNode>, props: {
+    name: string;
+    itemIndex: number;
+    expanded: boolean;
+    depth: number;
+}) => any;
+export type GroupingOptions = {
+    props?: ColumnProp[];
+    /** is expanded by default */
+    expandedAll?: boolean;
+    groupLabelTemplate?: GroupLabelTemplateFunc;
 };
-export declare type BeforeSourceSetEvent = {
-  type: RevoGrid.DimensionRows;
-  source: RevoGrid.DataType[];
+export type BeforeSourceSetEvent = {
+    type: DimensionRows;
+    source: DataType[];
 };
-export declare type OnExpandEvent = {
-  model: RevoGrid.DataType;
-  virtualIndex: number;
+export type OnExpandEvent = {
+    model: DataType;
+    virtualIndex: number;
 };
-export declare type SourceGather = {
-  source: RevoGrid.DataType[];
-  prevExpanded: Record<string, boolean>;
-  oldNewIndexes?: Record<number, number>;
+export type SourceGather = {
+    source: DataType[];
+    prevExpanded: Record<string, boolean>;
+    oldNewIndexes?: Record<number, number>;
 };

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

@@ -1,25 +1,27 @@
-import { RevoGrid } from '../../interfaces';
-export declare type ExpandedOptions = {
-  prevExpanded?: Record<string, boolean>;
-  expandedAll?: boolean;
+import { DataType, ColumnProp, ColumnRegular } from '../..';
+import { GroupLabelTemplateFunc } from './grouping.row.types';
+export type ExpandedOptions = {
+    prevExpanded?: Record<string, boolean>;
+    expandedAll?: boolean;
+    getGroupValue?(item: DataType, prop: string | number): any;
+    groupLabelTemplate?: GroupLabelTemplateFunc;
 };
 /**
  * Gather data for grouping
  * @param array - flat data array
- * @param mapFunc - mapping function for stringify
+ * @param groupIds - ids of groups
  * @param expanded - potentially expanded items if present
  */
-export declare function gatherGrouping<T>(array: T[], mapFunc: (v: T) => any, { prevExpanded, expandedAll }: ExpandedOptions): {
-  sourceWithGroups: RevoGrid.DataType[];
-  depth: number;
-  trimmed: Record<number, boolean>;
-  oldNewIndexMap: Record<number, number>;
-  childrenByGroup: Record<string, any>;
+export declare function gatherGrouping(array: DataType[], groupIds: ColumnProp[], { prevExpanded, expandedAll, getGroupValue }: ExpandedOptions): {
+    sourceWithGroups: DataType[];
+    depth: number;
+    trimmed: Record<number, boolean>;
+    oldNewIndexMap: Record<number, number>;
+    childrenByGroup: Record<string, number[]>;
 };
-export declare function getGroupingName(rgRow?: RevoGrid.DataType): any;
-export declare function isGrouping(rgRow?: RevoGrid.DataType): boolean;
-export declare function isGroupingColumn(column?: RevoGrid.ColumnRegular): boolean;
-export declare function isArray<T>(data: any | T[]): data is T[];
+export declare function getGroupingName(rgRow?: DataType): any;
+export declare function isGrouping(rgRow?: DataType): boolean;
+export declare function isGroupingColumn(column?: ColumnRegular): boolean;
 export declare function measureEqualDepth<T>(groupA: T[], groupB: T[]): number;
 export declare function getParsedGroup(id: string): any[];
-export declare function isSameGroup(currentGroup: any[], currentModel: RevoGrid.DataType, nextModel: RevoGrid.DataType): boolean;
+export declare function isSameGroup(currentGroup: any[], currentModel: DataType, nextModel: DataType): boolean;

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

@@ -1,4 +1,4 @@
-import { Trimmed, TrimmedEntity } from '../trimmed/trimmed.plugin';
+import { Trimmed, TrimmedEntity } from '../../store/dataSource/trimmed.plugin';
 export declare const TRIMMED_GROUPING = "grouping";
 /**
  * Prepare trimming updated indexes for grouping

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

@@ -0,0 +1,56 @@
+import ColumnDataProvider from '../../services/column.data.provider';
+import { DataProvider } from '../../services/data.provider';
+import DimensionProvider from '../../services/dimension.provider';
+import SelectionStoreConnector from '../../services/selection.store.connector';
+import ViewportProvider from '../../services/viewport.provider';
+import { BasePlugin } from '../base.plugin';
+import { ColumnPropProp } from '../..';
+import { DimensionCols } from '../..';
+import { PluginProviders } from '../../';
+export type DragStartEventDetails = {
+    event: MouseEvent;
+    data: ColumnPropProp;
+};
+export type Providers = {
+    data: DataProvider;
+    dimension: DimensionProvider;
+    selection: SelectionStoreConnector;
+    column: ColumnDataProvider;
+    viewport: ViewportProvider;
+};
+type LocalSubscriptions = Record<string, LocalSubscription>;
+type LocalSubscription = {
+    target: Element | Document;
+    callback(...params: any[]): void;
+};
+export type EventData = {
+    elRect: DOMRect;
+    gridRect: DOMRect;
+    scrollOffset: number;
+    type: DimensionCols;
+};
+export default class ColumnPlugin extends BasePlugin {
+    protected revogrid: HTMLRevoGridElement;
+    protected providers: PluginProviders;
+    private moveFunc;
+    private staticDragData;
+    private dragData;
+    private readonly orderUi;
+    protected readonly localSubscriptions: LocalSubscriptions;
+    constructor(revogrid: HTMLRevoGridElement, providers: PluginProviders);
+    dragStart({ event, data }: DragStartEventDetails): void;
+    doMove(e: MouseEvent): void;
+    move(e: MouseEvent): void;
+    onMouseOut(_: MouseEvent): void;
+    onMouseUp(e: MouseEvent): void;
+    private clearLocalSubscriptions;
+    clearOrder(): void;
+    /**
+     * Clearing subscription
+     */
+    protected clearSubscriptions(): void;
+    private getData;
+    private getDimension;
+}
+export declare function getLeftRelative(absoluteX: number, gridPos: number, offset: number): number;
+export {};

package/dist/types/plugins/moveColumn/order-column.handler.d.ts

@@ -0,0 +1,16 @@
+export declare class ColumnOrderHandler {
+    private element?;
+    private autoscrollEl?;
+    private offset;
+    renderAutoscroll(_: MouseEvent, parent: HTMLElement | null): void;
+    autoscroll(pos: number, dataContainerSize: number, direction?: string): void;
+    start(e: MouseEvent, { dataEl, gridRect, scrollEl, gridEl }: {
+        dataEl: HTMLElement;
+        gridRect: DOMRect;
+        scrollEl: Element;
+        gridEl: Element;
+    }, dir?: 'top' | 'left'): void;
+    stop(gridEl: Element): void;
+    showHandler(pos: number, size: number, direction?: string): void;
+    render(): HTMLDivElement;
+}

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

@@ -1,32 +1,45 @@
-import { RevoGrid } from '../../interfaces';
-import BasePlugin from '../basePlugin';
-export declare type SortingOrder = Record<RevoGrid.ColumnProp, RevoGrid.Order>;
+import { BasePlugin } from '../base.plugin';
+import { ColumnProp, Order, CellCompareFunc, ColumnRegular, DataType } from '../..';
+import { DimensionRows } from '../..';
+import { PluginProviders } from '../../';
+export type SortingOrder = Record<ColumnProp, Order>;
+type SortingOrderFunction = Record<ColumnProp, CellCompareFunc | undefined>;
 /**
- * lifecycle
- * 1) @event beforesorting - sorting just started, nothing happened yet
- * 2) @metod updateColumnSorting - column sorting icon applied to grid and column get updated, data still untiuched
- * 3) @event beforesortingapply - before we applied sorting data to data source, you can prevent data apply from here
- * 4) @event afterSortingApply - sorting applied, just finished event
+ * 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.
+ * 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.
  *
- * If you prevent event it'll not reach farther steps
+ * Note: If you prevent an event, it will not proceed to the subsequent steps.
  */
 export default class SortingPlugin extends BasePlugin {
-  protected revogrid: HTMLRevoGridElement;
-  private sorting;
-  private sortingFunc;
-  get hasSorting(): boolean;
-  constructor(revogrid: HTMLRevoGridElement);
-  private headerclick;
-  private setData;
-  /**
-   * Sorting apply, available for rgRow type only
-   * @param sorting - per column sorting
-   * @param data - this.stores['rgRow'].store.get('source')
-   */
-  private sort;
-  private defaultCellCompare;
-  private descCellCompare;
-  private sortIndexByItems;
-  private sortItems;
-  private getNextOrder;
+    protected revogrid: HTMLRevoGridElement;
+    private sorting;
+    private sortingFunc;
+    private sortingPromise;
+    private postponeSort;
+    private runSorting;
+    constructor(revogrid: HTMLRevoGridElement, providers: PluginProviders);
+    private startSorting;
+    private getComparer;
+    /**
+     * 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): Promise<void>;
+    /**
+     * 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: SortingOrder, sortingFunc: SortingOrderFunction, types?: DimensionRows[]): Promise<void>;
+    defaultCellCompare(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.sign.d.ts

@@ -1,8 +1,8 @@
-import { RevoGrid } from '../../interfaces';
+import { ColumnRegular } from '../../types/interfaces';
 export declare const FILTER_BUTTON_CLASS = "rv-filter";
 export declare const FILTER_BUTTON_ACTIVE = "active";
-declare type Props = {
-  column: RevoGrid.ColumnRegular;
+type Props = {
+    column: ColumnRegular;
 };
 export declare const SortingSign: ({ column }: Props) => any;
 export {};

package/dist/types/services/cell.helpers.d.ts

@@ -1,2 +1,2 @@
-import { Selection } from '../interfaces';
-export declare function getCell(cell: HTMLElement): Selection.Cell;
+import { Cell } from '..';
+export declare function getCell(cell: HTMLElement): Cell;

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

@@ -1,40 +1,38 @@
 import DataStore from '../store/dataSource/data.store';
-import { ColumnItems } from './dimension.provider';
-import { RevoGrid } from '../interfaces';
-import ColumnRegular = RevoGrid.ColumnRegular;
-import DimensionCols = RevoGrid.DimensionCols;
-import ColumnProp = RevoGrid.ColumnProp;
-import { ColumnGrouping } from '../plugins/groupingColumn/grouping.col.plugin';
-export declare type ColumnCollection = {
-  columns: ColumnItems;
-  columnGrouping: ColumnGrouping;
-  maxLevel: number;
-  sort: Record<ColumnProp, ColumnRegular>;
+import { ColumnGroupingCollection } from '../plugins/groupingColumn/grouping.col.plugin';
+import { ColumnData, ColumnProp, ColumnRegular, ColumnTypes, ViewSettingSizeProp } from '..';
+import { DimensionCols, DimensionColPin } from '..';
+export type ColumnCollection = {
+    columns: Record<DimensionCols, ColumnRegular[]>;
+    columnByProp: Record<ColumnProp, ColumnRegular[]>;
+    columnGrouping: ColumnGroupingCollection;
+    maxLevel: number;
+    sort: Record<ColumnProp, ColumnRegular>;
 };
-export declare type ColumnDataSources = Record<DimensionCols, DataStore<ColumnRegular, DimensionCols>>;
-declare type Sorting = Record<ColumnProp, ColumnRegular>;
-declare type SortingOrder = Record<ColumnProp, 'asc' | 'desc'>;
+export type ColumnDataSources = Record<DimensionCols, DataStore<ColumnRegular, DimensionCols>>;
+type Sorting = Record<ColumnProp, ColumnRegular>;
+type SortingOrder = Record<ColumnProp, 'asc' | 'desc'>;
 export default class ColumnDataProvider {
-  private readonly dataSources;
-  sorting: Sorting | null;
-  get order(): SortingOrder;
-  get stores(): ColumnDataSources;
-  constructor();
-  column(c: number, pin?: RevoGrid.DimensionColPin): ColumnRegular | undefined;
-  getColumn(virtualIndex: number, type: DimensionCols): ColumnRegular | undefined;
-  getRawColumns(): ColumnItems;
-  getColumns(type?: DimensionCols | 'all'): RevoGrid.ColumnRegular[];
-  getColumnIndexByProp(prop: ColumnProp, type: DimensionCols): number;
-  getColumnByProp(prop: ColumnProp, type: DimensionCols): ColumnRegular | undefined;
-  refreshByType(type: DimensionCols): void;
-  setColumns(data: ColumnCollection): ColumnCollection;
-  updateColumns(cols: ColumnRegular[]): void;
-  updateColumn(column: ColumnRegular, index: number): void;
-  updateColumnSorting(column: ColumnRegular, index: number, sorting: 'asc' | 'desc', additive: boolean): ColumnRegular;
-  clearSorting(): void;
-  static getSizes(cols: ColumnRegular[]): RevoGrid.ViewSettingSizeProp;
-  static getColumnByProp(columns: RevoGrid.ColumnData, prop: ColumnProp): ColumnRegular | undefined;
-  static getColumns(columns: RevoGrid.ColumnData, level?: number, types?: RevoGrid.ColumnTypes): ColumnCollection;
-  static getColumnType(rgCol: ColumnRegular): DimensionCols;
+    readonly dataSources: ColumnDataSources;
+    sorting: Sorting | null;
+    get order(): SortingOrder;
+    get stores(): ColumnDataSources;
+    constructor();
+    column(c: number, pin?: DimensionColPin): 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, type: DimensionCols): ColumnRegular | undefined;
+    refreshByType(type: DimensionCols): void;
+    setColumns(data: ColumnCollection): ColumnCollection;
+    updateColumns(cols: ColumnRegular[]): void;
+    updateColumn(column: ColumnRegular, index: number): void;
+    updateColumnSorting(column: ColumnRegular, index: number, sorting: 'asc' | 'desc', additive: boolean): ColumnRegular;
+    clearSorting(): void;
+    static getSizes(cols: ColumnRegular[]): ViewSettingSizeProp;
+    static getColumnByProp(columns: ColumnData, prop: ColumnProp): ColumnRegular | undefined;
+    static getColumns(columns: ColumnData, level?: number, types?: ColumnTypes): ColumnCollection;
+    static getColumnType(rgCol: ColumnRegular): DimensionCols;
 }
 export {};

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

@@ -1,26 +1,32 @@
 import DataStore, { Groups } from '../store/dataSource/data.store';
 import DimensionProvider from './dimension.provider';
-import { RevoGrid, Edition } from '../interfaces';
-import { Trimmed } from '../plugins/trimmed/trimmed.plugin';
-import DimensionRows = RevoGrid.DimensionRows;
-import DataType = RevoGrid.DataType;
-export declare type RowDataSources = {
-  [T in DimensionRows]: DataStore<DataType, DimensionRows>;
+import { Trimmed } from '../store/dataSource/trimmed.plugin';
+import { GroupLabelTemplateFunc } from '../plugins/groupingRow/grouping.row.types';
+import { DataLookup, DimensionRows } from '..';
+import { DataType } from '..';
+import { BeforeSaveDataDetails } from '..';
+export type RowDataSources = {
+    [T in DimensionRows]: DataStore<DataType, DimensionRows>;
 };
+/**
+ * Data source provider
+ */
 export declare class DataProvider {
-  private dimensionProvider;
-  readonly stores: RowDataSources;
-  constructor(dimensionProvider: DimensionProvider);
-  setData(data: DataType[], type?: DimensionRows, grouping?: {
-    depth: number;
-    groups?: Groups;
-  }, silent?: boolean): DataType[];
-  getModel(virtualIndex: number, type?: DimensionRows): any;
-  setCellData({ type, rowIndex, prop, val }: Edition.BeforeSaveDataDetails): void;
-  refresh(type?: DimensionRows | 'all'): void;
-  refreshItems(type?: DimensionRows): void;
-  setGrouping({ depth }: {
-    depth: number;
-  }, type?: DimensionRows): void;
-  setTrimmed(trimmed: Partial<Trimmed>, type?: DimensionRows): void;
+    private dimensionProvider;
+    readonly stores: RowDataSources;
+    constructor(dimensionProvider: DimensionProvider);
+    setData(data: DataType[], type?: DimensionRows, disableVirtualRows?: boolean, grouping?: {
+        depth: number;
+        groups?: Groups;
+        customRenderer?: GroupLabelTemplateFunc;
+    }, silent?: boolean): DataType[];
+    getModel(virtualIndex: number, type?: DimensionRows): any;
+    setCellData({ type, rowIndex, prop, val }: BeforeSaveDataDetails, mutate?: boolean): void;
+    setRangeData(data: DataLookup, type: DimensionRows): void;
+    refresh(type?: DimensionRows | 'all'): void;
+    refreshItems(type?: DimensionRows): void;
+    setGrouping({ depth }: {
+        depth: number;
+    }, type?: DimensionRows): void;
+    setTrimmed(trimmed: Partial<Trimmed>, type?: DimensionRows): void;
 }

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

@@ -1,36 +1,56 @@
-import DimensionStore from '../store/dimension/dimension.store';
+import { DimensionStoreCollection } from '../store/dimension/dimension.store';
 import ViewportProvider from './viewport.provider';
-import { RevoGrid } from '../interfaces';
-export declare type ColumnItems = Record<RevoGrid.DimensionCols, RevoGrid.ColumnRegular[]>;
-export declare type DimensionStores = {
-  [T in RevoGrid.MultiDimensionType]: DimensionStore;
-};
-export declare type DimensionConfig = {
-  realSizeChanged(): void;
+import { Trimmed } from '../store/dataSource/trimmed.plugin';
+import { ColumnRegular, DimensionSettingsState, ViewPortScrollEvent, ViewSettingSizeProp } from '..';
+import { DimensionCols, DimensionType, MultiDimensionType } from '..';
+export type ColumnItems = Record<DimensionCols, ColumnRegular[]>;
+export type DimensionConfig = {
+    realSizeChanged(k: MultiDimensionType): void;
 };
+/**
+ * Dimension provider
+ * Stores dimension information and custom sizes
+ */
 export default class DimensionProvider {
-  private viewports;
-  readonly stores: DimensionStores;
-  constructor(viewports: ViewportProvider, config: DimensionConfig);
-  setDimensionSize(dimensionType: RevoGrid.MultiDimensionType, sizes: RevoGrid.ViewSettingSizeProp): void;
-  setRealSize(realCount: number, type: RevoGrid.MultiDimensionType): void;
-  /**
-   * Sets dimension data and view port coordinate
-   * @param items - data/column items
-   * @param type - dimension type
-   */
-  setData(items: RevoGrid.ColumnRegular[] | RevoGrid.DataType[], type: RevoGrid.MultiDimensionType, noVirtual?: boolean): void;
-  private setNoVirtual;
-  drop(): void;
-  getFullSize(): {
-    x: number;
-    y: number;
-  };
-  setColumns(type: RevoGrid.MultiDimensionType, sizes?: RevoGrid.ViewSettingSizeProp, noVirtual?: boolean): void;
-  setViewPortCoordinate({ coordinate, type }: {
-    coordinate: number;
-    type: RevoGrid.MultiDimensionType;
-  }): void;
-  getViewPortPos(e: RevoGrid.ViewPortScrollEvent): number;
-  setSettings(data: Partial<RevoGrid.DimensionSettingsState>, dimensionType: RevoGrid.DimensionType): void;
+    private viewports;
+    readonly stores: DimensionStoreCollection;
+    constructor(viewports: ViewportProvider, config: DimensionConfig);
+    /**
+     * Clear old sizes from dimension and viewports
+     * @param type - dimension type
+     * @param count - count of items
+     */
+    clearSize(t: MultiDimensionType, count: number): void;
+    /**
+     * Apply new custom sizes to dimension and view port
+     * @param type - dimension type
+     * @param sizes - new custom sizes
+     * @param keepOld - keep old sizes merge new with old
+     */
+    setCustomSizes(type: MultiDimensionType, sizes: ViewSettingSizeProp, keepOld?: boolean): void;
+    setItemCount(realCount: number, type: MultiDimensionType): void;
+    /**
+     * Apply trimmed items
+     * @param trimmed - trimmed items
+     * @param type
+     */
+    setTrimmed(trimmed: Partial<Trimmed>, type: MultiDimensionType): void;
+    /**
+     * Sets dimension data and view port coordinate
+     * @param items - data/column items
+     * @param type - dimension type
+     */
+    setData(itemCount: number, type: MultiDimensionType, noVirtual?: boolean): void;
+    applyNewColumns(columns: Record<DimensionCols, ColumnRegular[]>, disableVirtualX: boolean): void;
+    getFullSize(): {
+        x: number;
+        y: number;
+    };
+    updateViewport(type: MultiDimensionType): void;
+    setViewPortCoordinate({ coordinate, type, }: {
+        coordinate: number;
+        type: MultiDimensionType;
+    }): void;
+    getViewPortPos(e: ViewPortScrollEvent): number;
+    setSettings(data: Partial<DimensionSettingsState>, dimensionType: DimensionType): void;
 }