dhx-suite 8.4.6 → 9.0.1

package/codebase/types/ts-all/sources/entry.d.ts

@@ -3,7 +3,7 @@ export { cssManager } from "../../ts-common/CssManager";
 export { EventSystem } from "../../ts-common/events";
 export { awaitRedraw, resizeHandler, setTheme } from "../../ts-common/dom";
 export { Uploader } from "../../ts-vault";
-export { DataCollection, TreeCollection, DataProxy, dataDrivers, ajax } from "../../ts-data";
+export { DataCollection, TreeCollection, DataProxy, dataDrivers, ajax, methods } from "../../ts-data";
 export { Layout } from "../../ts-layout";
 export { List } from "../../ts-list";
 export { Calendar } from "../../ts-calendar";

package/codebase/types/ts-common/core.d.ts

@@ -1,6 +1,7 @@
 type fn<T extends any[], K> = (...args: T) => K;
 type anyFunction = fn<any[], any>;
 export declare function uid(): string;
+export declare function extendComponent(target: any, source: any): any;
 export declare function extend(target: any, source: any, deep?: boolean): any;
 interface IOBj {
     [key: string]: any;

package/codebase/types/ts-common/html.d.ts

@@ -66,4 +66,5 @@ export declare function getLabelStyle(config: any): false | {
 };
 export declare function getPageInlineCss(): string;
 export declare function getPageLinksCss(exportStyles?: string[]): string;
+export declare function getElementFromPoint(e: MouseEvent | TouchEvent): Element | null;
 export {};

package/codebase/types/ts-common/input.d.ts

@@ -0,0 +1,24 @@
+export interface INumberMask {
+    prefix?: string;
+    suffix?: string;
+    groupSeparator?: string;
+    decSeparator?: string;
+    allowNegative?: boolean;
+    maxIntLength?: number;
+    maxDecLength?: number;
+    minDecLength?: number;
+}
+export interface INumberMaskConfig extends INumberMask {
+    onlyView?: boolean;
+    lastCall?: boolean;
+}
+export declare function numberMask(value: string | number, options: INumberMaskConfig, input?: HTMLInputElement): string | number;
+export declare function removeNumberMask(value: string, options: INumberMaskConfig): string;
+export interface IPatternMask {
+    pattern: ((value: string | number) => string) | string;
+    charFormat?: {
+        [char: string]: RegExp;
+    };
+}
+export declare function patternMask(value: string | number, options: IPatternMask | string, input?: HTMLInputElement): string;
+export declare function removePatternMask(value: string, options: IPatternMask | string): string;

package/codebase/types/ts-data/index.d.ts

@@ -10,3 +10,4 @@ export * from "./sources/drivers/JsonDriver";
 export * from "./sources/selection";
 export * from "./sources/drivers/drivers";
 export * from "./sources/ajax";
+export * from "./sources/methods";

package/codebase/types/ts-data/sources/DragManager.d.ts

@@ -1,8 +1,19 @@
 import { Id } from "../../ts-common/types";
+export type TDragItem = "row" | "group" | "column";
+interface IDragConfig {
+    event: MouseEvent | TouchEvent;
+    type: TDragItem;
+    source?: Id[];
+    itemsForGhost?: NodeList | HTMLDivElement[] | Element[];
+    ghost?: HTMLElement;
+    groupable?: boolean;
+    groupOnly?: boolean;
+}
 export interface IDragManager {
     setItem(id: Id, item: any): void;
-    onMouseDown(e: MouseEvent | TouchEvent, source?: Id[], itemsForGhost?: NodeList | HTMLDivElement[] | Element[]): void;
+    onMouseDown(config: IDragConfig): void;
     isDrag(): boolean;
     cancelCanDrop(event: MouseEvent | TouchEvent): void;
 }
 export declare const dragManager: IDragManager;
+export {};

package/codebase/types/ts-data/sources/datacollection/group.d.ts

@@ -0,0 +1,42 @@
+import { IDataItem } from "../types";
+export type TGroupOrderFunc = (i: IDataItem) => string;
+export type TAggregate = "sum" | "count" | "min" | "max" | "avg" | string;
+export interface IGroupOrder {
+    by: string | TGroupOrderFunc;
+    map?: {
+        [field: string]: [string, TAggregate] | ((i: IDataItem[]) => string | number);
+    };
+    summary?: "top" | "bottom";
+}
+export interface IGroupOrderConfig extends IGroupOrder {
+    by: string;
+}
+export type TGroupOrder = string | TGroupOrderFunc | IGroupOrder;
+export type TDisplayMode = "original" | "column" | "row";
+export interface IGroupConfig {
+    displayMode?: TDisplayMode;
+    showMissed?: boolean | string;
+    field?: string;
+}
+export interface IGroup {
+    group(order: TGroupOrder[], arr: IDataItem[], config: IGroupConfig): IDataItem[];
+    ungroup(arr?: IDataItem[]): IDataItem[];
+    isGrouped(): boolean;
+    getGroupedFields(): string[];
+    getGroupConfig(config?: IGroupConfig): IGroupConfig;
+}
+export declare class Group implements IGroup {
+    private _init;
+    private _config;
+    private _groupSet;
+    constructor();
+    group(order: TGroupOrder[], arr: IDataItem[], config?: IGroupConfig): IDataItem[];
+    ungroup(modifiedData?: IDataItem[]): IDataItem[];
+    isGrouped(): boolean;
+    getGroupedFields(): string[];
+    getGroupConfig(config?: IGroupConfig): IGroupConfig;
+    private _group;
+    private _addSummaryRow;
+    private _toAggregate;
+    private _getOrderConfig;
+}

package/codebase/types/ts-data/sources/datacollection.d.ts

@@ -1,7 +1,8 @@
 import { IEventSystem } from "../../ts-common/events";
 import { Id } from "../../ts-common/types";
 import { Sort } from "./datacollection/sort";
-import { DataCallback, DataEvents, IDataCollection, IDataItem, IDataProxy, IFilterCallback, IFilterConfig, IFilterMode, ISortMode, ITreeCollection, IUpdateObject, ReduceCallBack, Statuses, IDataEventsHandlersMap, DataDriver, IDataConfig, ISortConfig, IDataDriver, IFilterComplexMode, IFilter, IResetFilterConfig } from "./types";
+import { DataCallback, DataEvents, IDataCollection, IDataItem, IDataProxy, IFilterCallback, IFilterConfig, IFilterMode, ISortMode, ITreeCollection, IUpdateObject, ReduceCallBack, Statuses, IDataEventsHandlersMap, DataDriver, IDataConfig, ISortConfig, IDataDriver, IFilterComplexMode, IFilter, IResetFilterConfig, IGroupDataConfig } from "./types";
+import { TGroupOrder, IGroup } from "./datacollection/group";
 export declare class DataCollection<T extends IDataItem = IDataItem> implements IDataCollection<T> {
     loadData: Promise<any>;
     saveData: Promise<any>;
@@ -19,10 +20,16 @@ export declare class DataCollection<T extends IDataItem = IDataItem> implements
     protected _loaded: boolean;
     protected _initOrder: T[];
     protected _filters: IFilter;
+    protected _group: IGroup;
     private _changes;
     private _loader;
     constructor(config?: any, events?: IEventSystem<any>);
-    protected _reset(): void;
+    protected _reset(config?: {
+        grouping?: boolean;
+    }): void;
+    group(order: TGroupOrder[], config?: IGroupDataConfig): void;
+    ungroup(): void;
+    isGrouped(): boolean;
     add(newItem: IDataItem, index?: number): Id;
     add(newItem: IDataItem[], index?: number): Id[];
     remove(id: Id | Id[]): void;
@@ -65,11 +72,11 @@ export declare class DataCollection<T extends IDataItem = IDataItem> implements
     getMetaMap(obj: T): any;
     setRange(from: number, to: number): void;
     getRawData(from: number, to: number, order?: T[], mode?: number): T[];
-    protected _add(newItem: IDataItem, index: number): Id;
+    protected _add(newItem: IDataItem, index?: number): Id;
     protected _remove(id: Id): void;
     protected _copy(id: Id, index: number, target?: IDataCollection | ITreeCollection, targetId?: Id, key?: number): Id;
     protected _move(id: Id, index: number, target?: IDataCollection | ITreeCollection, targetId?: Id, key?: number, newId?: Id): Id;
-    protected _addCore(obj: IDataItem, index: number): Id;
+    protected _addCore(obj: IDataItem, index?: number): Id;
     protected _removeCore(id: Id): void;
     protected _parse_data(data: any[]): void;
     protected _approximate(data: any[], values: string[], maxNum: number): any[];
@@ -77,8 +84,10 @@ export declare class DataCollection<T extends IDataItem = IDataItem> implements
     protected _addToOrder(array: any[], obj: any, index?: number): void;
     protected _applySorters(by?: ISortMode): void;
     protected _applyFilters(rule?: IFilterMode | IFilterCallback): void;
-    protected _reapplyFilters(sort?: boolean): void;
+    protected _reapplyFilters(): void;
     protected _getRuleCallback(rule: IFilterMode): IFilterCallback;
     protected _getPureFilters(filters: IFilter): IFilter;
     protected _normalizeFilters(filters: any): any;
+    protected _checkFilterRule(rule: IFilterMode | IFilterCallback): boolean;
+    private _parse;
 }

package/codebase/types/ts-data/sources/helpers.d.ts

@@ -3,7 +3,7 @@ import { DataProxy } from "./dataproxy";
 import { IFilterCallback, IFilterMode, IDataCollection, IDataItem, ITreeCollection, DataDriver, IDataDriver, IFilter } from "./types";
 export declare function isEqualObj(a: any, b: any): boolean;
 export declare function naturalCompare(a: any, b: any): any;
-export declare function findByConf(item: any, conf: IFilterMode | IFilterCallback): any;
+export declare function findByConf(item: IDataItem, conf: IFilterMode | IFilterCallback, index?: number, array?: IDataItem[]): IDataItem;
 export declare function isDebug(): boolean;
 export declare function dhxWarning(msg: string): void;
 export declare function dhxError(msg: string): void;

package/codebase/types/ts-data/sources/methods.d.ts

@@ -0,0 +1,11 @@
+type Item = {
+    [key: string]: any;
+};
+export declare const methods: {
+    sum: (items: Item[], field: string) => number;
+    avg: (items: Item[], field: string) => number;
+    count: (items: Item[], field: string) => number;
+    min: (items: Item[], field: string) => number;
+    max: (items: Item[], field: string) => number;
+};
+export {};

package/codebase/types/ts-data/sources/treecollection.d.ts

@@ -1,6 +1,6 @@
 import { IEventSystem } from "../../ts-common/events";
 import { DataCollection } from "./datacollection";
-import { DataCallback, DataEvents, IDataCollection, IDataItem, ITreeCollection, IFilterCallback, IFilterMode, IFilterComplexMode, ITreeFilterConfig, DataDriver, ISortMode, IDataDriver } from "./types";
+import { DataCallback, DataEvents, IDataCollection, IDataItem, ITreeCollection, IFilterCallback, IFilterMode, IFilterComplexMode, ITreeFilterConfig, DataDriver, ISortMode, IDataDriver, IUpdateObject, ISortConfig } from "./types";
 import { Id } from "../../ts-common/types";
 export declare class TreeCollection<T extends IDataItem = IDataItem> extends DataCollection<T> implements ITreeCollection<T> {
     protected _childs: {
@@ -16,8 +16,9 @@ export declare class TreeCollection<T extends IDataItem = IDataItem> extends Dat
     getItems(id: Id): T[];
     getLength(id?: Id): number;
     removeAll(id?: Id): void;
+    update(id: Id, newItem: IUpdateObject, silent?: boolean): void;
     getIndex(id: Id): number;
-    sort(rule?: ISortMode): void;
+    sort(rule?: ISortMode, config?: ISortConfig): void;
     filter(rule?: IFilterMode | IFilterComplexMode | IFilterCallback, config?: ITreeFilterConfig, silent?: boolean): string;
     restoreOrder(): void;
     copy(id: Id, index: number, target?: IDataCollection | ITreeCollection, targetId?: Id): Id;
@@ -41,7 +42,10 @@ export declare class TreeCollection<T extends IDataItem = IDataItem> extends Dat
     protected _setParent(item: IDataItem, parent: Id): void;
     protected _copy(id: Id, index: number, target?: IDataCollection | ITreeCollection, targetId?: Id, key?: number): Id;
     protected _move(id: Id, index: number, target?: ITreeCollection | IDataCollection, targetId?: Id, key?: number): Id;
-    protected _reset(id?: Id): void;
+    protected _reset(config: {
+        id?: Id;
+        grouping: any;
+    }): void;
     protected _removeCore(id: any): void;
     protected _addToOrder(_order: any, obj: any, index: number): void;
     protected _parse_data(data: any, parent?: Id): void;
@@ -50,4 +54,6 @@ export declare class TreeCollection<T extends IDataItem = IDataItem> extends Dat
     private _serialize;
     private _applyFilter;
     protected _normalizeFilters(filters: any): any;
+    protected _checkFilterRule(rule: IFilterMode | IFilterComplexMode | IFilterCallback): boolean;
+    protected _applySorters(by?: ISortMode): void;
 }

package/codebase/types/ts-data/sources/types.d.ts

@@ -1,5 +1,7 @@
 import { IEventSystem } from "../../ts-common/events";
 import { anyFunction, IAnyObj, Id } from "../../ts-common/types";
+import { IGroupConfig, TGroupOrder } from "./datacollection/group";
+import { TDragItem } from "./DragManager";
 export interface IDataProxy {
     url: string;
     config?: any;
@@ -66,7 +68,6 @@ export interface IApproximate {
     maxNum: number;
 }
 export interface IDataConfig {
-    prep?: anyFunction;
     init?: anyFunction;
     update?: anyFunction;
     approximate?: IApproximate;
@@ -74,12 +75,18 @@ export interface IDataConfig {
     collapsed?: boolean;
     rootId?: Id;
 }
+export interface IGroupDataConfig extends IGroupConfig {
+    data?: IDataItem[];
+}
 export interface IDataCollection<T extends IDataItem = IDataItem> {
     config: IDataConfig;
     events: IEventSystem<DataEvents>;
     dataProxy: IDataProxy;
     loadData: Promise<any>;
     saveData: Promise<any>;
+    group(order: TGroupOrder[], config?: IGroupDataConfig): void;
+    ungroup(): void;
+    isGrouped(): boolean;
     load(url: IDataProxy | string, driver?: IDataDriver | DataDriver): Promise<any>;
     parse(data: T[] | string, driver?: DataDriver | IDataDriver): void;
     $parse(data: any[]): void;
@@ -170,7 +177,7 @@ export interface ITreeCollection<T extends IDataItem = IDataItem> extends IDataC
     getLength(id?: Id): number;
     getIndex(id: Id): number;
     getItems(id: Id): T[];
-    sort(rule?: ISortMode): void;
+    sort(rule?: ISortMode, config?: ISortConfig): void;
     map(callback: DataCallback<T>, parent?: Id, direct?: boolean): any;
     filter(rule?: IFilterMode | IFilterCallback, config?: ITreeFilterConfig, silent?: boolean): string;
     restoreOrder(): void;
@@ -215,6 +222,10 @@ export interface ITransferData {
     start?: Id;
     source?: Id[];
     target?: Id;
+    type?: TDragItem;
+    isWasColumn?: boolean;
+    groupable?: boolean;
+    groupOnly?: boolean;
 }
 export interface IDragConfig {
     dragCopy?: boolean;
@@ -240,7 +251,11 @@ export declare enum DataEvents {
     beforeLazyLoad = "beforelazyload",
     afterLazyLoad = "afterlazyload",
     beforeItemLoad = "beforeItemLoad",
-    afterItemLoad = "afterItemLoad"
+    afterItemLoad = "afterItemLoad",
+    beforeGroup = "beforeGroup",
+    afterGroup = "afterGroup",
+    beforeUnGroup = "beforeUnGroup",
+    afterUnGroup = "afterUnGroup"
 }
 export interface IDataEventsHandlersMap {
     [key: string]: (...args: any[]) => any;
@@ -258,6 +273,10 @@ export interface IDataEventsHandlersMap {
     [DataEvents.afterItemLoad]: (id: Id) => void;
     [DataEvents.beforeLazyLoad]: () => boolean | void;
     [DataEvents.afterLazyLoad]: (from: number, count: number) => void;
+    [DataEvents.beforeGroup]: (config: IGroupConfig) => boolean | void;
+    [DataEvents.afterGroup]: (grouped: string[], config: IGroupConfig) => void;
+    [DataEvents.beforeUnGroup]: (grouped: string[], config: IGroupConfig) => boolean | void;
+    [DataEvents.afterUnGroup]: (grouped: string[], config: IGroupConfig) => void;
 }
 export declare enum DragEvents {
     beforeDrag = "beforeDrag",
@@ -275,21 +294,20 @@ export interface IDragInfo {
     source: Id[];
     target: Id;
     dropPosition?: DropPosition;
-    dragItem?: "row" | "column";
 }
 export type DragMode = "target" | "both" | "source";
 export type DropBehaviour = "child" | "sibling" | "complex";
 export interface IDragEventsHandlersMap {
     [key: string]: (...args: any[]) => any;
-    [DragEvents.beforeDrag]: (data: IDragInfo, events: MouseEvent, ghost: HTMLElement) => void | boolean;
-    [DragEvents.dragStart]: (data: IDragInfo, events: MouseEvent) => void;
-    [DragEvents.dragOut]: (data: IDragInfo, events: MouseEvent) => void;
-    [DragEvents.dragIn]: (data: IDragInfo, events: MouseEvent) => void | boolean;
-    [DragEvents.canDrop]: (data: IDragInfo, events: MouseEvent) => void;
-    [DragEvents.cancelDrop]: (data: IDragInfo, events: MouseEvent) => void;
-    [DragEvents.beforeDrop]: (data: IDragInfo, events: MouseEvent) => void | boolean;
-    [DragEvents.afterDrop]: (data: IDragInfo, events: MouseEvent) => any;
-    [DragEvents.afterDrag]: (data: IDragInfo, events: MouseEvent) => any;
+    [DragEvents.beforeDrag]: (data: IDragInfo, events: MouseEvent, ghost: HTMLElement, type: TDragItem) => void | boolean;
+    [DragEvents.dragStart]: (data: IDragInfo, events: MouseEvent, type: TDragItem) => void;
+    [DragEvents.dragOut]: (data: IDragInfo, events: MouseEvent, type: TDragItem) => void;
+    [DragEvents.dragIn]: (data: IDragInfo, events: MouseEvent, type: TDragItem) => void | boolean;
+    [DragEvents.canDrop]: (data: IDragInfo, events: MouseEvent, type: TDragItem) => void;
+    [DragEvents.cancelDrop]: (data: IDragInfo, events: MouseEvent, type: TDragItem) => void;
+    [DragEvents.beforeDrop]: (data: IDragInfo, events: MouseEvent, type: TDragItem) => void | boolean;
+    [DragEvents.afterDrop]: (data: IDragInfo, events: MouseEvent, type: TDragItem) => any;
+    [DragEvents.afterDrag]: (data: IDragInfo, events: MouseEvent, type: TDragItem) => any;
 }
 export declare enum DataDriver {
     json = "json",

package/codebase/types/ts-form/sources/elements/input.d.ts

@@ -1,3 +1,4 @@
+import { INumberMask, IPatternMask } from "../../../ts-common/input";
 import { Label } from "./helper/label";
 import { IEventSystem } from "../../../ts-common/events";
 import { ItemEvent, IBaseLayoutItem, ILabel, IMessage, IBaseItem, IBaseState, IBaseHandlersMap } from "../types";
@@ -25,6 +26,8 @@ export interface IInputProps extends IBaseLayoutItem, ILabel, IMessage {
     min?: number | string;
     max?: number | string;
     step?: number | string;
+    numberMask?: INumberMask | boolean;
+    patternMask?: IPatternMask | string;
 }
 export interface IInputConfig extends IBaseItem, IBaseState, IInputProps {
     type: "input";
@@ -45,6 +48,7 @@ export interface IInput {
     clearValidate(): void;
     setValue(value: string | number): void;
     getValue(): string | number;
+    getText(): string;
     isFocused(): boolean;
     focus(): void;
     blur(): void;
@@ -91,6 +95,7 @@ export declare class Input extends Label implements IInput {
     clear(): void;
     setValue(value: string | number): void;
     getValue(): string | number;
+    getText(): string;
     isFocused(): boolean;
     focus(): void;
     blur(): void;
@@ -104,4 +109,6 @@ export declare class Input extends Label implements IInput {
         onkeydown: (event: KeyboardEvent) => void;
     };
     protected _draw(): any;
+    protected _applyValuePattern(value: string | number, input?: HTMLInputElement | null, onlyView?: boolean): string | number;
+    protected _removeValuePattern(value: string, lastCall?: boolean): string;
 }

package/codebase/types/ts-form/sources/elements/textarea.d.ts

@@ -1,6 +1,7 @@
 import { Input, IInputProps } from "./input";
 import { ItemEvent, ValidationFn, IBaseItem, IBaseState, IBaseLayoutItem, ILabel, IMessage, IBaseHandlersMap } from "../types";
 import { IEventSystem } from "../../../ts-common/events";
+import { INumberMask, IPatternMask } from "../../../ts-common/input";
 import { IFieldset } from "./fieldset";
 export interface ITextAreaProps extends IBaseLayoutItem, ILabel, IMessage {
     validation?: ValidationFn;
@@ -9,6 +10,8 @@ export interface ITextAreaProps extends IBaseLayoutItem, ILabel, IMessage {
     maxlength?: number | string;
     minlength?: number | string;
     resizable?: boolean;
+    numberMask?: INumberMask | boolean;
+    patternMask?: IPatternMask | string;
 }
 export interface ITextAreaConfig extends IBaseItem, IBaseState, ITextAreaProps {
     type: "textarea";
@@ -29,6 +32,7 @@ export interface ITextArea {
     clearValidate(): void;
     setValue(value: string): void;
     getValue(): string;
+    getText(): string;
     focus(): void;
     blur(): void;
     clear(): void;
@@ -60,9 +64,6 @@ export declare class Textarea extends Input implements ITextArea {
     protected _propsItem: string[];
     protected _props: string[];
     getValue(): string;
-    isFocused(): boolean;
-    focus(): void;
-    blur(): void;
     setProperties(propertyConfig: ITextAreaProps & IInputProps): void;
     getProperties(): ITextAreaProps & IInputProps;
     protected _initView(config: ITextAreaConfig): void;

package/codebase/types/ts-grid/index.d.ts

@@ -1,7 +1,7 @@
 export * from "./sources/Grid";
+export * from "./sources/ExtendedGrid";
 export * from "./sources/ProGrid";
 export * from "./sources/types";
 export * from "./sources/helpers/cells";
-export { getTreeCell } from "./sources/ui/Cells";
 export * from "./sources/helpers/data";
 export * from "./sources/helpers/main";

package/codebase/types/ts-grid/sources/Exporter.d.ts

@@ -1,29 +1,33 @@
-import { ICsvExportConfig, IGrid, IXlsxExportConfig } from "./types";
+import { ICsvExportConfig, IGrid, IXlsxExportConfig, ICellCss } from "./types";
 import { IPDFConfig, IPNGConfig, TExportType } from "../../ts-common/types";
-export declare class Exporter {
+export interface IExportData {
+    name: string;
+    columns: Array<{
+        width: number;
+    }>;
+    header: string[][];
+    data: any[];
+    styles: {
+        cells: any[];
+        css: {
+            [key: string]: ICellCss;
+        };
+    };
+}
+export interface IExporter {
+    pdf: (config?: IPDFConfig) => void;
+    png: (config?: IPNGConfig) => void;
+    xlsx: (config?: IXlsxExportConfig) => IExportData;
+    csv: (config?: ICsvExportConfig) => string;
+}
+export declare class Exporter implements IExporter {
     private _name;
     private _version;
     private _view;
     constructor(_name: string, _version: string, _view: IGrid);
     pdf(config?: IPDFConfig): void;
     png(config?: IPNGConfig): void;
-    xlsx(config?: IXlsxExportConfig): {
-        name: string;
-        columns: any[];
-        header: any[][];
-        data: string[][];
-        styles: {
-            cells: any[];
-            css: {
-                default: {
-                    color: string;
-                    background: string;
-                    fontSize: number;
-                    bold: boolean;
-                };
-            };
-        };
-    };
+    xlsx(config?: IXlsxExportConfig): IExportData;
     csv(config?: ICsvExportConfig): string;
     private _export;
     private getFlatCSV;

package/codebase/types/ts-grid/sources/ExtendedGrid.d.ts

@@ -0,0 +1,23 @@
+import { IGridConfig, ICol, IRow, IFooter, IHeader, IGroupOrderItem, IExtendedGrid, IExtendedGridConfig } from "./types";
+import { IDataCollection, IDataItem } from "../../ts-data";
+import { ScrollView } from "../../ts-common/ScrollView";
+import { Grid } from "./Grid";
+export declare class ExtendedGrid extends Grid implements IExtendedGrid {
+    scrollView: ScrollView;
+    config: IExtendedGridConfig;
+    constructor(container: HTMLElement | string | null, config?: IExtendedGridConfig);
+    protected _createView(): any;
+    protected _setEventHandlers(): void;
+    protected getNormalizeContentHeight(row: IFooter | IHeader, col: ICol, config: IGridConfig): number;
+    protected _prepareData(data: IDataItem[] | IDataCollection): IDataItem[] | IRow[];
+    protected _prepareDataFromTo(data: IDataCollection, from: number, to: number): IDataItem[];
+    protected _dragStart(event: any): void;
+    protected _group(order: IGroupOrderItem[]): void;
+    private _lazyLoad;
+    private _getGhostItem;
+    private _dragStartColumn;
+    private _dragStartGroupItem;
+    private _changeGroupItemAfterSort;
+    private _isGroupableColumn;
+    private _isGroupClosable;
+}

package/codebase/types/ts-grid/sources/Grid.d.ts

@@ -4,7 +4,8 @@ import { Id, ITouchParam } from "../../ts-common/types";
 import { View } from "../../ts-common/view";
 import { DataEvents, DragEvents, IDataCollection, IDataEventsHandlersMap, IDataItem, IDragEventsHandlersMap } from "../../ts-data";
 import { Exporter } from "./Exporter";
-import { Dirs, EditorType, GridEvents, IAdjustBy, ICellRect, ICol, IContentList, ICoords, IEventHandlersMap, IGrid, IGridConfig, IRow, IScrollState, ISelection, ISpan, GridSystemEvents, ISystemEventHandlersMap, IColumnsWidth, ISortingState, SortFunction, IHeaderFilter, IAdjustColumns, IFooter, IHeader, INormalizeColumnsParams } from "./types";
+import { ISelection } from "./Selection";
+import { Dirs, EditorType, GridEvents, IAdjustBy, ICellRect, ICol, IContentList, ICoords, IEventHandlersMap, IGrid, IGridConfig, IRow, IScrollState, ISpan, GridSystemEvents, ISystemEventHandlersMap, IColumnsWidth, ISortingState, SortFunction, IHeaderFilter, IAdjustColumns, IDirection, IFooter, IHeader, INormalizeColumnsParams, ISummaryList } from "./types";
 export declare class Grid extends View implements IGrid {
     version: string;
     name: "grid";
@@ -16,16 +17,20 @@ export declare class Grid extends View implements IGrid {
     selection: ISelection;
     keyManager: IKeyManager;
     protected _touch: ITouchParam;
+    protected _destructed: boolean;
     protected _scroll: IScrollState;
     protected _events: IEventSystem<GridSystemEvents, ISystemEventHandlersMap>;
     protected _htmlEvents: any;
-    private _sortDir;
-    private _sortBy;
-    private _filterData;
+    protected _sortState: {
+        by: Id;
+        dir: Dirs;
+    };
     protected _activeFilters: object;
+    private _filterData;
     private _hiddenFilters;
-    protected _destructed: boolean;
-    constructor(container: HTMLElement | string, config?: IGridConfig);
+    private _commonSummary;
+    private _colSummary;
+    constructor(container: HTMLElement | string | null, config?: IGridConfig);
     destructor(): void;
     setColumns(columns: ICol[]): void;
     addRowCss(rowId: Id, css: string): void;
@@ -54,16 +59,17 @@ export declare class Grid extends View implements IGrid {
     /** @deprecated See a documentation: https://docs.dhtmlx.com/ */
     edit(rowId: Id, colId: Id, editorType?: EditorType): void;
     paint(): void;
+    getSummary(colId?: Id): ISummaryList;
     protected _createView(): any;
     protected _parseColumns(configChanged?: boolean): void;
     protected normalizeColumns({ config, columns, configChanged }: INormalizeColumnsParams): void;
     protected getNormalizeContentHeight(row: IFooter | IHeader, col: ICol, config: IGridConfig): number;
     protected _parseData(): void;
-    protected _createCollection(prep: (data: any[]) => any[]): void;
+    protected _createCollection(): void;
     protected _getRowIndex(rowId: Id): number;
     protected _setEventHandlers(): void;
     protected _addEmptyRow(): void;
-    protected _sort(by: Id, dir?: Dirs, sortAs?: SortFunction): void;
+    protected _sort(by: Id, sortAs?: SortFunction): void;
     protected _clearTouchTimer(): void;
     protected _checkFilters(reset?: boolean): void;
     protected _setUniqueData(sync?: boolean): void;
@@ -81,6 +87,10 @@ export declare class Grid extends View implements IGrid {
     protected _normalizeDataType(): void;
     protected _applyLocalFilter(beforePrepareData?: boolean): void;
     protected _normalizeSpans(): void;
+    protected _hideColumn(column: ICol): void;
+    protected _showColumn(column: ICol): void;
+    protected _setSummary(): void;
+    private _applyMethod;
     private _canDataParse;
     private _init;
     private _attachDataCollection;
@@ -92,6 +102,6 @@ export declare class Grid extends View implements IGrid {
     private _render;
     private _initHotKey;
     private _normalizeConfig;
-    private _autoScroll;
+    protected _autoScroll(mode: IDirection): void;
     private _applyAutoWidth;
 }

package/codebase/types/ts-grid/sources/ProGrid.d.ts

@@ -1,17 +1,53 @@
-import { IGridConfig, ICol, IRow, IProGrid, IFooter, IHeader } from "./types";
-import { IDataCollection, IDataItem } from "../../ts-data";
 import { ScrollView } from "../../ts-common/ScrollView";
-import { Grid } from "./Grid";
-export declare class ProGrid extends Grid implements IProGrid {
+import { ITreeEventHandlersMap, TreeGridCollection, TreeGridEvents } from "../../ts-treegrid";
+import { EditorType, GridEvents, IAdjustBy, ICellRect, ICol, IContentList, ICoords, IEventHandlersMap, IHeaderFilter, IProGrid, IProGridConfig, ISortingState, ISpan, ISummaryList } from "./types";
+import { IKeyManager } from "../../ts-common/KeyManager";
+import { IEventSystem } from "../../ts-common/events";
+import { Id } from "../../ts-common/types";
+import { DataEvents, DragEvents, IDataEventsHandlersMap, IDragEventsHandlersMap, IDataCollection, IDataItem } from "../../ts-data";
+import { ISelection } from "./Selection";
+export declare class ProGrid implements IProGrid {
+    config: IProGridConfig;
     scrollView: ScrollView;
-    constructor(container: HTMLElement | string, config?: IGridConfig);
-    protected _createView(): any;
-    protected _setEventHandlers(): void;
-    protected getNormalizeContentHeight(row: IFooter | IHeader, col: ICol, config: IGridConfig): number;
-    protected _prepareData(data: IDataItem[] | IDataCollection): IDataItem[] | IRow[];
-    protected _prepareDataFromTo(data: IDataCollection, from: number, to: number): IDataItem[];
-    protected _dragStart(event: any): void;
-    private _lazyLoad;
-    private _getColumnGhost;
-    private _dragStartColumn;
+    events: IEventSystem<GridEvents | DataEvents | DragEvents | TreeGridEvents, IEventHandlersMap & IDataEventsHandlersMap & IDragEventsHandlersMap & ITreeEventHandlersMap>;
+    name: string;
+    data: IDataCollection<IDataItem> & TreeGridCollection;
+    selection: ISelection;
+    content: IContentList;
+    keyManager: IKeyManager;
+    export: any;
+    constructor(container: HTMLElement | string | null, config?: IProGridConfig);
+    paint(): void;
+    destructor(): void;
+    expand(rowId: Id): void;
+    collapse(rowId: Id): void;
+    expandAll(): void;
+    collapseAll(): void;
+    showColumn(colId: Id): void;
+    hideColumn(colId: Id): void;
+    isColumnHidden(colId: Id): boolean;
+    showRow(rowId: Id): void;
+    hideRow(rowId: Id): void;
+    isRowHidden(rowId: Id): boolean;
+    scrollTo(rowId: Id, colId: Id): void;
+    scroll(x?: number, y?: number): void;
+    getScrollState(): ICoords;
+    setColumns(col: ICol[]): void;
+    addRowCss(rowId: Id, css: string): void;
+    removeRowCss(rowId: Id, css: string): void;
+    addCellCss(rowId: Id, colId: Id, css: string): void;
+    removeCellCss(rowId: Id, colId: Id, css: string): void;
+    adjustColumnWidth(colId: Id, adjust?: IAdjustBy): void;
+    getCellRect(rowId: Id, colId: Id): ICellRect;
+    getColumn(colId: Id): ICol;
+    addSpan(spanObj: ISpan): void;
+    getSpan(rowId: Id, colId: Id): ISpan;
+    removeSpan(rowId: Id, colId: Id): void;
+    editCell(rowId: Id, colId: Id, editorType?: EditorType): void;
+    editEnd(withoutSave?: boolean): void;
+    getSortingState(): ISortingState;
+    getHeaderFilter(colId: Id): IHeaderFilter;
+    getSummary(colId?: Id): ISummaryList;
+    getRootNode(): HTMLElement;
+    getRootView(): void;
 }