@dhtmlx/grid 9.3.3

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

@@ -0,0 +1,340 @@
+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;
+    updateUrl?: (url?: string, params?: any) => void;
+    load?: () => Promise<any[] | string | void>;
+    save?: (data: any, mode: string) => Promise<any>;
+}
+export interface ILazyDataProxy extends IDataProxy {
+    config: ILazyConfig;
+}
+export interface ILazyConfig {
+    from?: number;
+    limit?: number;
+    delay?: number;
+    prepare?: number;
+}
+export type TSortDir = "asc" | "desc";
+export interface ISortMode {
+    by?: string | number;
+    dir?: TSortDir;
+    as?: (a: any) => any;
+    rule?: (a: any, b: any) => number;
+}
+export type ISortingState = ISortMode & ISortConfig;
+export type IFilterCallback = (obj: any) => boolean;
+export interface IFilterMode {
+    by?: Id;
+    match?: string | number | boolean;
+    compare?: (value: any, match: any, obj: any, multi?: boolean) => boolean;
+    multi?: any;
+}
+export interface IFilterComplexMode {
+    [key: string]: IFilterMode;
+}
+export interface IFilter {
+    [key: string]: IFilterParams;
+}
+export interface IFilterParams {
+    rule: IFilterMode | IFilterComplexMode | IFilterCallback;
+    config: IFilterConfig | ITreeFilterConfig;
+}
+export interface IFilterConfig {
+    id?: string;
+    add?: boolean;
+    smartFilter?: boolean;
+    permanent?: boolean;
+    $restore?: boolean;
+    $local?: boolean;
+}
+export interface IResetFilterConfig {
+    id?: string;
+    permanent?: boolean;
+}
+export interface ISortConfig {
+    smartSorting?: boolean;
+}
+export interface ITreeFilterConfig extends IFilterConfig {
+    type?: TreeFilterType;
+    level?: number;
+}
+export interface IUpdateObject {
+    [key: string]: any;
+}
+export interface IApproximate {
+    value: any;
+    maxNum: number;
+}
+export interface IDataConfig {
+    init?: anyFunction;
+    update?: anyFunction;
+    approximate?: IApproximate;
+    autoload?: string;
+    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;
+    add(newItem: IDataItem, index?: number): Id;
+    add(newItem: IDataItem[], index?: number): Id[];
+    add(newItem: IDataItem | IDataItem[], index?: number): Id | Id[];
+    remove(id: Id | Id[]): void;
+    removeAll(): void;
+    update(id: Id, newItem: IUpdateObject, silent?: boolean): void;
+    exists(id: Id): boolean;
+    getInitialData(): T[];
+    getItem(id: Id): T;
+    getIndex(id: Id): number;
+    getLength(): number;
+    isDataLoaded(from?: number, to?: number): boolean;
+    getId(index: number): Id;
+    filter(rule?: IFilterMode | IFilterCallback, config?: IFilterConfig, silent?: boolean): string;
+    resetFilter(config?: IResetFilterConfig, silent?: boolean): boolean;
+    getFilters(config?: {
+        permanent?: boolean;
+    }): IFilter;
+    getRawFilters(config?: {
+        permanent?: boolean;
+    }): IFilter;
+    find(rule: IFilterMode): T;
+    reduce<A>(callback: ReduceCallBack<T, A>, acc: A): A;
+    findAll(rule: IFilterMode): T[];
+    map(callback: DataCallback<T>): T[];
+    mapRange(from: number, to: number, callback: DataCallback<T>): T[];
+    sort(rule?: ISortMode, config?: ISortConfig): void;
+    getSortingStates(): ISortingState[];
+    serialize(driver?: DataDriver): T[];
+    copy(id: Id | Id[], index: number, target?: IDataCollection | ITreeCollection, targetId?: Id): Id | Id[];
+    move(id: Id | Id[], index: number, target?: IDataCollection | ITreeCollection, targetId?: Id): Id | Id[];
+    changeId(id: Id, newId?: Id, silent?: boolean): void;
+    forEach(callback: DataCallback<T>): void;
+    save(url: IDataProxy | string): void;
+    isSaved(): boolean;
+    getRawData(from: number, to: number, order?: T[] | null, mode?: number): T[];
+}
+export interface IDataChangeStack {
+    order: IDataChange[];
+}
+export type Statuses = "add" | "update" | "remove" | string;
+export interface IDataChange {
+    id: Id;
+    status: Statuses;
+    obj: any;
+    saving: boolean;
+    promise?: Promise<any>;
+    pending?: boolean;
+    error?: boolean;
+}
+export type RequestStatus = "saving" | "pending" | "error";
+export interface IDir {
+    [key: string]: any;
+    asc: number;
+    desc: number;
+}
+export interface IDataDriver {
+    toJsonArray(data: any): any[];
+    serialize(data: IAnyObj[]): any;
+    getRows(data: string): any[];
+    getFields(row: any): {
+        [key: string]: any;
+    };
+}
+export interface ICsvDriverConfig {
+    skipHeader?: number;
+    nameByHeader?: boolean;
+    names?: string[];
+    rowDelimiter?: string;
+    columnDelimiter?: string;
+}
+export declare enum TreeFilterType {
+    all = "all",
+    level = "level",
+    leafs = "leafs"
+}
+export type DataCallback<T> = (item: T, index?: number, array?: T[]) => any;
+export type ReduceCallBack<T, A> = (acc: A, item: T, index?: number) => A;
+export interface ITreeCollection<T extends IDataItem = IDataItem> extends IDataCollection<T> {
+    add(newItem: IDataItem, index?: number, parent?: Id): Id;
+    add(newItem: IDataItem[], index?: number, parent?: Id): Id[];
+    add(newItem: IDataItem | IDataItem[], index?: number, parent?: Id): Id | Id[];
+    getRoot(): Id;
+    getParent(id: Id): Id;
+    removeAll(id?: Id): void;
+    getLength(id?: Id): number;
+    getIndex(id: Id): number;
+    getItems(id: Id): T[];
+    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;
+    copy(id: Id, index: number, target?: IDataCollection | ITreeCollection, targetId?: Id): Id;
+    copy(id: Id[], index: number, target?: IDataCollection | ITreeCollection, targetId?: Id): Id[];
+    copy(id: Id | Id[], index: number, target?: IDataCollection | ITreeCollection, targetId?: Id): Id | Id[];
+    move(id: Id, index: number, target?: ITreeCollection | IDataCollection, targetId?: Id): Id;
+    move(id: Id[], index: number, target?: ITreeCollection | IDataCollection, targetId?: Id): Id[];
+    move(id: Id | Id[], index: number, target?: ITreeCollection | IDataCollection, targetId?: Id): Id | Id[];
+    eachChild(id: Id, callback: DataCallback<T>, direct?: boolean, checkItem?: (item: IDataItem) => boolean): void;
+    eachParent(id: Id, callback: DataCallback<T>, self?: boolean): void;
+    loadItems(id: Id, driver?: IDataDriver | DataDriver): void;
+    refreshItems(id: Id, driver?: IDataDriver | DataDriver): void;
+    haveItems(id: Id): boolean;
+    canCopy(id: Id, target: Id): boolean;
+    forEach(callback: DataCallback<T>, parent?: Id, level?: number): void;
+}
+export interface IDataItem {
+    id?: Id;
+    [key: string]: any;
+}
+export type DropPosition = "top" | "bottom" | "in";
+export interface IObjWithData {
+    name?: string;
+    data: ITreeCollection | IDataCollection;
+    events: IEventSystem<DragEvents, IDragEventsHandlersMap>;
+    config: IDragConfig;
+    id?: Id;
+}
+export interface ITransferData {
+    initXOffset?: number;
+    initYOffset?: number;
+    x?: number;
+    y?: number;
+    ghost?: HTMLElement;
+    componentId?: Id;
+    dragConfig?: IDragConfig;
+    component?: IObjWithData;
+    dropPosition?: DropPosition;
+    dropComponentId?: Id;
+    item?: HTMLElement;
+    start?: Id;
+    source?: Id[];
+    target?: Id;
+    type?: TDragItem;
+    isWasColumn?: boolean;
+    groupable?: boolean;
+    groupOnly?: boolean;
+}
+export interface IDragConfig {
+    dragCopy?: boolean;
+    dropBehaviour?: DropBehaviour;
+    dragMode?: DragMode;
+}
+export interface ICopyObject {
+    id: Id;
+    component: IObjWithData;
+    newId?: Id;
+}
+export declare enum DataEvents {
+    afterAdd = "afteradd",
+    beforeAdd = "beforeadd",
+    removeAll = "removeall",
+    beforeRemove = "beforeremove",
+    afterRemove = "afterremove",
+    change = "change",
+    filter = "filter",
+    dataRequest = "dataRequest",
+    load = "load",
+    loadError = "loaderror",
+    beforeLazyLoad = "beforelazyload",
+    afterLazyLoad = "afterlazyload",
+    beforeItemLoad = "beforeItemLoad",
+    afterItemLoad = "afterItemLoad",
+    beforeGroup = "beforeGroup",
+    afterGroup = "afterGroup",
+    beforeUnGroup = "beforeUnGroup",
+    afterUnGroup = "afterUnGroup"
+}
+export interface IDataEventsHandlersMap {
+    [key: string]: (...args: any[]) => any;
+    [DataEvents.change]: (id?: Id, status?: Statuses, updatedItem?: IDataItem) => void;
+    [DataEvents.filter]: (filter?: IFilter) => void;
+    [DataEvents.beforeAdd]: (newItem: IDataItem, batch: IDataItem[], index: number) => boolean | void;
+    [DataEvents.afterAdd]: (newItem: IDataItem, batch: IDataItem[], index: number) => void;
+    [DataEvents.beforeRemove]: (removedItem: IDataItem, batch: IDataItem[], index: number) => boolean | void;
+    [DataEvents.afterRemove]: (removedItem: IDataItem, batch: IDataItem[], index: number) => void;
+    [DataEvents.removeAll]: () => void;
+    [DataEvents.dataRequest]: (from: number, to: number) => void;
+    [DataEvents.load]: () => void;
+    [DataEvents.loadError]: (response: any) => void;
+    [DataEvents.beforeItemLoad]: (id: Id) => boolean | void;
+    [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",
+    dragStart = "dragStart",
+    dragOut = "dragOut",
+    dragIn = "dragIn",
+    canDrop = "canDrop",
+    cancelDrop = "cancelDrop",
+    beforeDrop = "beforeDrop",
+    afterDrop = "afterDrop",
+    afterDrag = "afterDrag"
+}
+export interface IDragInfo {
+    start: Id;
+    source: Id[];
+    target: Id;
+    dropPosition?: DropPosition;
+}
+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, 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",
+    csv = "csv",
+    xml = "xml"
+}
+export type AjaxResponseType = "json" | "xml" | "text" | "raw";
+export interface IAjaxHelperConfig {
+    headers: {
+        [key: string]: string;
+    };
+    responseType: AjaxResponseType;
+}
+export interface IAjaxHelper {
+    get<T>(url: string, data?: {
+        [key: string]: any;
+    } | string, config?: Partial<IAjaxHelperConfig>): Promise<T | void>;
+    post<T>(url: string, data?: {
+        [key: string]: any;
+    } | string, config?: Partial<IAjaxHelperConfig>): Promise<T | void>;
+    put<T>(url: string, data?: {
+        [key: string]: any;
+    } | string, config?: Partial<IAjaxHelperConfig>): Promise<T | void>;
+    delete<T>(url: string, data?: {
+        [key: string]: any;
+    } | string, config?: Partial<IAjaxHelperConfig>): Promise<T | void>;
+}

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

@@ -0,0 +1,7 @@
+export * from "./sources/Grid";
+export * from "./sources/ExtendedGrid";
+export * from "./sources/ProGrid";
+export * from "./sources/types";
+export * from "./sources/helpers/cells";
+export * from "./sources/helpers/data";
+export * from "./sources/helpers/main";

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

@@ -0,0 +1,47 @@
+import { IGridConfig, ICol, IRow, IFooter, IHeader, IGroupOrderItem, IExtendedGrid, IExtendedGridConfig, ISubViewCell } from "./types";
+import { IDataCollection, IDataItem } from "../../ts-data";
+import { ScrollView } from "../../ts-common/ScrollView";
+import { Id } from "../../ts-common/types";
+import { Grid } from "./Grid";
+import { IRange } from "./modules/Range";
+import { IBlockSelection } from "./modules/BlockSelection";
+import { IClipboard } from "./modules/Clipboard";
+import { IHistory } from "./modules/History";
+import { IProContentList } from "./ui/proContent";
+export declare class ExtendedGrid extends Grid implements IExtendedGrid {
+    range: IRange;
+    block: IBlockSelection;
+    clipboard: IClipboard;
+    history: IHistory;
+    scrollView: ScrollView;
+    config: IExtendedGridConfig;
+    content: IProContentList;
+    constructor(container: HTMLElement | string | null, config?: IExtendedGridConfig);
+    expand(rowId: Id): void;
+    collapse(rowId: Id): void;
+    expandAll(): void;
+    collapseAll(): void;
+    getSubRow(id: Id): ISubViewCell | null;
+    destructor(): void;
+    protected _createView(): any;
+    protected _init(): void;
+    protected _dragInit(): void;
+    protected _setHTMLEventHandlers(): void;
+    protected _setEventHandlers(): void;
+    protected _afterEditEndProcess(value: any, editableRow: any, editableColumn: any): void;
+    protected _setSort(): void;
+    protected getNormalizeContentHeight(row: IFooter | IHeader, col: ICol, config: IGridConfig): number;
+    protected _prepareData(data: IDataItem[] | IDataCollection): IRow[] | IDataItem[];
+    protected _prepareDataFromTo(data: IDataCollection, from: number, to: number): IDataItem[];
+    protected _dragStart(event: any): void;
+    protected _group(order: IGroupOrderItem[]): void;
+    protected _expand(row: IRow): boolean;
+    protected _collapse(row: IRow): boolean;
+    private _lazyLoad;
+    private _getGhostItem;
+    private _dragStartColumn;
+    private _dragStartGroupItem;
+    private _changeGroupItemAfterSort;
+    private _isGroupableColumn;
+    private _isGroupClosable;
+}

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

@@ -0,0 +1,114 @@
+import { IEventSystem } from "../../ts-common/events";
+import { IKeyManager } from "../../ts-common/KeyManager";
+import { Id, ITouchParam } from "../../ts-common/types";
+import { View } from "../../ts-common/view";
+import { DataEvents, DragEvents, IDataCollection, IDataEventsHandlersMap, IDataItem, IDragEventsHandlersMap, TSortDir } from "../../ts-data";
+import { Exporter } from "./modules/Exporter";
+import { ISelection } from "./modules/Selection";
+import { EditorType, GridEvents, IAdjustBy, ICellRect, ICol, ICoords, IEventHandlersMap, IGrid, IGridConfig, IRow, IScrollState, ISpan, GridSystemEvents, ISystemEventHandlersMap, IColumnsWidth, SortFunction, IAdjustColumns, IDirection, IFooter, IHeader, INormalizeColumnsParams, ISummaryList, ISortingStates } from "./types";
+import { IContentList, IHeaderFilter } from "./ui/content";
+import { IProContentList } from "./ui/proContent";
+export declare class Grid extends View implements IGrid {
+    version: string;
+    name: "grid";
+    data: IDataCollection;
+    config: IGridConfig;
+    events: IEventSystem<DataEvents | GridEvents | DragEvents, IEventHandlersMap & IDataEventsHandlersMap & IDragEventsHandlersMap>;
+    export: Exporter;
+    content: IContentList | IProContentList;
+    selection: ISelection;
+    keyManager: IKeyManager;
+    protected _touch: ITouchParam;
+    protected _destructed: boolean;
+    protected _scroll: IScrollState;
+    protected _events: IEventSystem<GridSystemEvents, ISystemEventHandlersMap>;
+    protected _htmlEvents: any;
+    protected _sortingStates: ISortingStates;
+    protected _activeFilters: object;
+    protected _dropManager: any;
+    private _filterData;
+    private _hiddenFilters;
+    private _commonSummary;
+    private _colSummary;
+    constructor(container: HTMLElement | string | null, config?: IGridConfig);
+    destructor(): void;
+    setColumns(columns: 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;
+    showColumn(colId: Id): void;
+    hideColumn(colId: Id): void;
+    isColumnHidden(colId: Id): boolean;
+    showRow(rowId: Id): void;
+    hideRow(rowId: Id): void;
+    isRowHidden(rowId: Id): boolean;
+    getScrollState(): ICoords;
+    scroll(x: number, y: number): void;
+    scrollTo(rowId: Id, colId: Id): 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;
+    getHeaderFilter(colId: Id): IHeaderFilter;
+    getSummary(colId?: Id): ISummaryList;
+    /** @deprecated See a documentation: https://docs.dhtmlx.com/suite/migration/ */
+    getSortingState(): {
+        dir?: TSortDir;
+        by?: Id;
+    };
+    protected _createView(): any;
+    protected _dragInit(): void;
+    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(): void;
+    protected _getRowIndex(rowId: Id): number;
+    protected _setHTMLEventHandlers(): void;
+    protected _setEventHandlers(): void;
+    protected _afterEditEndProcess(value: any, editableRow: any, editableColumn: any): void;
+    protected _addEmptyRow(): void;
+    protected _sort(by: Id, sortAs?: SortFunction, smartSorting?: boolean): void;
+    protected _setSort(): void;
+    protected _clearTouchTimer(): void;
+    protected _checkFilters(reset?: boolean): void;
+    protected _setUniqueData(sync?: boolean): void;
+    protected _checkSelectFilterValue(): void;
+    protected _clearFilterValue(allCols?: boolean): void;
+    protected _adjustColumns(): void;
+    protected _prepareData(data: IDataItem[] | IDataCollection): any[] | IDataItem[];
+    protected _adjustColumnsWidth({ rows, cols, adjust, }: IAdjustColumns): IColumnsWidth;
+    protected _prepareColumnData(data: any, type: "header" | "footer"): IRow[];
+    protected _dragStart(event: any): void;
+    protected _dragProcess(event: MouseEvent | TouchEvent, row: IRow, column?: ICol): void;
+    protected _getRowGhost(ids: Id[]): HTMLDivElement;
+    protected _initHooks(): {
+        didMount: () => void;
+    };
+    protected _normalizeDataType(): void;
+    protected _applyLocalFilter(beforePrepareData?: boolean): void;
+    protected _normalizeSpans(): void;
+    protected _hideColumn(column: ICol): void;
+    protected _showColumn(column: ICol): void;
+    protected _setSummary(): void;
+    protected _init(): void;
+    private _applyMethod;
+    private _canDataParse;
+    private _attachDataCollection;
+    private _setMarks;
+    private _checkMarks;
+    private _removeMarks;
+    private _detectColsTypes;
+    private _destroyContent;
+    private _render;
+    private _initHotKey;
+    private _normalizeConfig;
+    protected _autoScroll(mode: IDirection): void;
+    private _applyAutoWidth;
+    private _handleRow;
+}

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

@@ -0,0 +1,67 @@
+import { ScrollView } from "../../ts-common/ScrollView";
+import { TreeGridCollection } from "../../ts-treegrid";
+import { EditorType, GridEvents, IAdjustBy, ICellRect, ICol, ICoords, IEventHandlersMap, IProGrid, IProGridConfig, ISpan, ISubViewCell, 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, TSortDir } from "../../ts-data";
+import { ISelection } from "./modules/Selection";
+import { IRange } from "./modules/Range";
+import { IBlockSelection } from "./modules/BlockSelection";
+import { IClipboard } from "./modules/Clipboard";
+import { IHistory } from "./modules/History";
+import { IProContentList, IProHeaderFilter } from "./ui/proContent";
+export declare class ProGrid implements IProGrid {
+    config: IProGridConfig;
+    scrollView: ScrollView;
+    events: IEventSystem<GridEvents | DataEvents | DragEvents, IEventHandlersMap & IDataEventsHandlersMap & IDragEventsHandlersMap>;
+    name: string;
+    data: IDataCollection<IDataItem> & TreeGridCollection;
+    selection: ISelection;
+    content: IProContentList;
+    keyManager: IKeyManager;
+    export: any;
+    range: IRange;
+    block: IBlockSelection;
+    clipboard: IClipboard;
+    history: IHistory;
+    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;
+    getHeaderFilter(colId: Id): IProHeaderFilter;
+    getSummary(colId?: Id): ISummaryList;
+    getSubRow(id: Id): ISubViewCell | null;
+    getRootNode(): HTMLElement;
+    getRootView(): void;
+    /** @deprecated See a documentation: https://docs.dhtmlx.com/suite/migration/ */
+    getSortingState(): {
+        dir?: TSortDir;
+        by?: Id;
+    };
+}

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

@@ -0,0 +1,7 @@
+import "../../styles/grid.scss";
+import "../../styles/themes.scss";
+export { cssManager } from "../../ts-common/CssManager";
+export { awaitRedraw, setTheme } from "../../ts-common/dom";
+export { DataCollection, DataProxy, methods } from "../../ts-data";
+export { Grid } from "./Grid";
+export declare const i18n: any;

package/codebase/types/ts-grid/sources/helpers/cells.d.ts

@@ -0,0 +1,9 @@
+import { ICell, ICol, IGrid, IRow, ISpan } from "./../types";
+import { Id } from "../../../ts-common/types";
+export declare function getWidth(columns: ICol[], colspan: number, index: number): number;
+export declare function getSpanHeight(rows: IRow[], span: ISpan): number;
+export declare function getReducedColspan(columns: ICol[], colId: Id, colspan: number): number;
+export declare function getReducedRowspan(initialRows: IRow[], currRows: IRow[], rowIndex: number, span: ISpan): number;
+export declare function normalizeCell(cell: ICell, grid: IGrid): ICell;
+export declare function clearCells(grid: any, cells: ICell[]): void;
+export declare function formatValue(value: string, cell: ICell): any;

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

@@ -0,0 +1,36 @@
+import { IContainerConfig } from "../../../ts-common/core";
+import { ICol, IColumnsWidth, IGridConfig, IRow, AdjustTargetType, TOption, IScrollState, IVisibleRange, ISizes } from "./../types";
+import { Id } from "../../../ts-common/types";
+export declare function getTotalRowHeight(row: IRow): number;
+export declare function normalizeArray(obj: any, name: string): void;
+export declare function measureTextHeight({ text, width, lineHeight, font, htmlEnable, }: {
+    text?: string;
+    width?: number;
+    lineHeight?: number;
+    font?: string;
+    htmlEnable?: boolean;
+}): number;
+export declare function countColumns(config: IGridConfig, columns: ICol[]): number;
+export declare function calculateVisibleRange(viewPortSize: ISizes, scroll: IScrollState, config: IGridConfig, data: IRow[]): IVisibleRange;
+export declare function getNormalizeFilterData(arr: any[], name: Id, multiselection: boolean, editorType: ICol["editorType"]): any[];
+export declare const getMaxRowHeight: ({ cols, row, config, }: {
+    row: IRow;
+    cols: ICol[];
+    config?: IContainerConfig;
+}) => number;
+export declare const getCalculatedRowHeight: (height: number, config?: {
+    rowHeight: number;
+    verticalOffset?: number;
+}) => number;
+export declare const getTreeCellWidthOffset: (row: IRow, toArrow?: boolean) => number;
+export declare const getMaxColsWidth: (rows: IRow[], cols: ICol[], config: IContainerConfig, target: AdjustTargetType) => IColumnsWidth;
+export declare function applyPattern(value: string | number | boolean, col: ICol): string | number | boolean;
+export declare function getEditorOptions(col: ICol, row?: IRow): TOption[];
+export declare function getOptionValue(value: string, column: ICol): string;
+export declare function getValueForNumberColumn(col: ICol, value: any): any;
+export declare function getComboEditorValue(value: any, col: ICol, row: IRow): any;
+export declare function getEditorValue(value: any, options: TOption[]): any;
+export declare function getReverseScrollState(grid: any): {
+    x: number;
+    y: number;
+};

package/codebase/types/ts-grid/sources/helpers/default.d.ts

@@ -0,0 +1,6 @@
+import { IHistoryConfig } from "../modules/History";
+import { IDragPanelConfig, IGroup, ISubRowConfig } from "../types";
+export declare const getGroupDefaultConfig: (config?: IGroup | boolean) => IGroup;
+export declare const defaultSubRowConfig: Omit<ISubRowConfig, "view">;
+export declare const defaultDragPanelConfig: IDragPanelConfig;
+export declare const defaultHistoryConfig: IHistoryConfig;

package/codebase/types/ts-grid/sources/helpers/dom.d.ts

@@ -0,0 +1,3 @@
+import { Id } from "../../../ts-common/types";
+export declare function getRowNode(id: Id, root: HTMLElement, split?: "left" | "right"): HTMLElement;
+export declare function getVisibleRowNode(row: HTMLElement, width: number, offset: number): HTMLElement;

package/codebase/types/ts-grid/sources/helpers/keys.d.ts

@@ -0,0 +1,27 @@
+export declare function getKeysHandlers(grid: any): {
+    enter: () => void;
+    space: (e: any) => void;
+    escape: () => void;
+    tab: (e: any) => void;
+    delete: () => void;
+    "shift+tab": (e: any) => void;
+    arrowUp: (event: any) => void;
+    "ctrl+z": () => void;
+    "ctrl+shift+z": () => void;
+    "ctrl+enter": () => void;
+    "ctrl+arrowUp": (event: any) => void;
+    "shift+arrowUp": (event: any) => void;
+    "ctrl+shift+arrowUp": (event: any) => void;
+    arrowDown: (event: any) => void;
+    "ctrl+arrowDown": (event: any) => void;
+    "shift+arrowDown": (event: any) => void;
+    "ctrl+shift+arrowDown": (event: any) => void;
+    arrowRight: (event: any) => void;
+    "ctrl+arrowRight": (event: any) => void;
+    "shift+arrowRight": (event: any) => void;
+    "ctrl+shift+arrowRight": (event: any) => void;
+    arrowLeft: (event: any) => void;
+    "ctrl+arrowLeft": (event: any) => void;
+    "shift+arrowLeft": (event: any) => void;
+    "ctrl+shift+arrowLeft": (event: any) => void;
+};