dhx-chart 9.1.6 → 9.2.1

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

@@ -6,6 +6,7 @@ export declare const locale: {
     cancel: string;
 };
 export declare function getFormattedDate(format: string, date: Date): string;
+export declare function getExcelDate(date: Date): number;
 export declare function stringToDate(str: string, format: string, validate?: boolean): any;
 export declare class DateHelper {
     static nullTimestampDate: Date;

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

@@ -29,6 +29,7 @@ export declare class Group implements IGroup {
     private _init;
     private _config;
     private _groupSet;
+    private _groupOrderFields;
     constructor();
     group(order: TGroupOrder[], arr: IDataItem[], config?: IGroupConfig): IDataItem[];
     ungroup(modifiedData?: IDataItem[]): IDataItem[];

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

@@ -3,7 +3,15 @@ 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";
 export declare class ExtendedGrid extends Grid implements IExtendedGrid {
+    range: IRange;
+    block: IBlockSelection;
+    clipboard: IClipboard;
+    history: IHistory;
     scrollView: ScrollView;
     config: IExtendedGridConfig;
     constructor(container: HTMLElement | string | null, config?: IExtendedGridConfig);
@@ -12,9 +20,12 @@ export declare class ExtendedGrid extends Grid implements IExtendedGrid {
     expandAll(): void;
     collapseAll(): void;
     getSubRow(id: Id): ISubViewCell | null;
+    destructor(): void;
     protected _createView(): any;
+    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): IDataItem[] | IRow[];

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

@@ -3,8 +3,8 @@ 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 "./Exporter";
-import { ISelection } from "./Selection";
+import { Exporter } from "./modules/Exporter";
+import { ISelection } from "./modules/Selection";
 import { EditorType, GridEvents, IAdjustBy, ICellRect, ICol, IContentList, ICoords, IEventHandlersMap, IGrid, IGridConfig, IRow, IScrollState, ISpan, GridSystemEvents, ISystemEventHandlersMap, IColumnsWidth, SortFunction, IHeaderFilter, IAdjustColumns, IDirection, IFooter, IHeader, INormalizeColumnsParams, ISummaryList, ISortingStates } from "./types";
 export declare class Grid extends View implements IGrid {
     version: string;
@@ -23,6 +23,7 @@ export declare class Grid extends View implements IGrid {
     protected _htmlEvents: any;
     protected _sortingStates: ISortingStates;
     protected _activeFilters: object;
+    protected _dropManager: any;
     private _filterData;
     private _hiddenFilters;
     private _commonSummary;
@@ -59,6 +60,7 @@ export declare class Grid extends View implements IGrid {
         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;
@@ -67,6 +69,7 @@ export declare class Grid extends View implements IGrid {
     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;
@@ -80,6 +83,7 @@ export declare class Grid extends View implements IGrid {
     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;

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

@@ -5,7 +5,11 @@ 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 "./Selection";
+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";
 export declare class ProGrid implements IProGrid {
     config: IProGridConfig;
     scrollView: ScrollView;
@@ -16,6 +20,10 @@ export declare class ProGrid implements IProGrid {
     content: IContentList;
     keyManager: IKeyManager;
     export: any;
+    range: IRange;
+    block: IBlockSelection;
+    clipboard: IClipboard;
+    history: IHistory;
     constructor(container: HTMLElement | string | null, config?: IProGridConfig);
     paint(): void;
     destructor(): void;

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

@@ -5,3 +5,5 @@ 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

@@ -1,5 +1,5 @@
 import { IContainerConfig } from "../../../ts-common/core";
-import { ICol, IColumnsWidth, IGridConfig, IRow, AdjustTargetType, TOption, IScrollState, IRange, ISizes } from "./../types";
+import { ICol, IColumnsWidth, IGridConfig, IRow, AdjustTargetType, TOption, IScrollState, IVisibleRange, ISizes } from "./../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, }: {
@@ -10,7 +10,7 @@ export declare function measureTextHeight({ text, width, lineHeight, font, htmlE
     htmlEnable?: boolean;
 }): number;
 export declare function countColumns(config: IGridConfig, columns: ICol[]): number;
-export declare function calculateVisibleRange(viewPortSize: ISizes, scroll: IScrollState, config: IGridConfig, data: IRow[]): IRange;
+export declare function calculateVisibleRange(viewPortSize: ISizes, scroll: IScrollState, config: IGridConfig, data: IRow[]): IVisibleRange;
 export declare function getUnique(arr: any[], name: string, multiselection: boolean, editorType: ICol["editorType"]): any[];
 export declare const getMaxRowHeight: ({ cols, row, config, }: {
     row: IRow;
@@ -29,3 +29,7 @@ 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

@@ -1,3 +1,6 @@
-import { IGroup, ISubRowConfig } from "../types";
+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/keys.d.ts

@@ -1,26 +1,27 @@
-import { IGrid, IDirection, IProGrid } from "../types";
-export declare function selectionMove(e: KeyboardEvent, grid: IGrid | IProGrid, dir: IDirection, range: number, toEnd?: boolean, ctrlUp?: boolean, shiftUp?: boolean): void;
 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: (e: any) => void;
+    arrowUp: (event: any) => void;
+    "ctrl+z": () => void;
+    "ctrl+shift+z": () => void;
     "ctrl+enter": () => void;
-    "ctrl+arrowUp": (e: any) => void;
-    "shift+arrowUp": (e: any) => void;
-    "ctrl+shift+arrowUp": (e: any) => void;
-    arrowDown: (e: any) => void;
-    "ctrl+arrowDown": (e: any) => void;
-    "shift+arrowDown": (e: any) => void;
-    "ctrl+shift+arrowDown": (e: any) => void;
-    arrowRight: (e: any) => void;
-    "ctrl+arrowRight": (e: any) => void;
-    "shift+arrowRight": (e: any) => void;
-    "ctrl+shift+arrowRight": (e: any) => void;
-    arrowLeft: (e: any) => void;
-    "ctrl+arrowLeft": (e: any) => void;
-    "shift+arrowLeft": (e: any) => void;
-    "ctrl+shift+arrowLeft": (e: any) => 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;
 };

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

@@ -1,5 +1,7 @@
 import { ICellCss, ICol, IFooter, IGridConfig, IGridTooltipConfig, IHeader, IRow, ISpan } from "../types";
 import { ITooltipConfig } from "../../../ts-message";
+import { Id } from "../../../ts-common/types";
+import { ITreeCollection } from "../../../ts-data";
 export declare function transpose(arr: any[][], transform?: any): any[][];
 export declare function getStyleByClass(cssClass: string, targetClass: string, def: ICellCss, container?: HTMLElement): ICellCss;
 export declare function removeHTMLTags(str: string): string;
@@ -15,3 +17,7 @@ export declare function isHtmlEnable(config: IGridConfig, col: ICol, content?: I
 export declare function getTotalWidth(columns: ICol[]): number;
 export declare function getTotalHeight(rows: IRow[]): number;
 export declare function scrollFixedColsAndRows(e: WheelEvent): void;
+export declare function isWasmSupported(): boolean;
+export declare function getLastChild(id: any, data: any, deep?: boolean): Id | null;
+export declare function getClosestTop(id: Id, data: ITreeCollection): Id | null;
+export declare function getClosestBottom(id: Id, data: ITreeCollection, ignore?: boolean): Id | null;

package/codebase/types/ts-grid/sources/modules/BlockSelection.d.ts

@@ -0,0 +1,120 @@
+import { VNode } from "../../../ts-common/dom";
+import { ICell, IExtendedGrid, IProGrid } from "../types";
+import { IEventSystem } from "../../../ts-common/events";
+export type DragDirection = "up" | "down" | "right" | "left";
+export type HandleAxis = "x" | "y" | "xy";
+export type RangeMode = "range" | "manual";
+export declare enum BlockSelectionEvents {
+    blockSelectionValidate = "blockSelectionValidate",
+    blockSelectionStart = "blockSelectionStart",
+    beforeBlockSelectionMove = "beforeBlockSelectionMove",
+    afterBlockSelectionMove = "afterBlockSelectionMove",
+    blockSelectionEnd = "blockSelectionEnd",
+    beforeBlockSelectionApply = "beforeBlockSelectionApply",
+    afterBlockSelectionApply = "afterBlockSelectionApply",
+    beforeBlockHandleApply = "beforeBlockHandleApply",
+    afterBlockHandleApply = "afterBlockHandleApply",
+    blockHandleMouseDown = "blockHandleMouseDown"
+}
+export interface IBlockSelectionEventsHandlersMap {
+    [key: string]: (...args: any[]) => any;
+    [BlockSelectionEvents.blockSelectionValidate]: (validateCell: ICell, handle: boolean, event: MouseEvent | TouchEvent) => boolean | void;
+    [BlockSelectionEvents.blockSelectionStart]: (startCell: ICell, endCell: ICell, handle: boolean, event: MouseEvent | TouchEvent) => void;
+    [BlockSelectionEvents.beforeBlockSelectionMove]: (startCell: ICell, nextCell: ICell, focusCell: ICell | null, dragDirection: DragDirection | null, event: MouseEvent | TouchEvent) => void;
+    [BlockSelectionEvents.afterBlockSelectionMove]: (startCell: ICell, endCell: ICell, focusCell: ICell | null, dragDirection: DragDirection | null, event: MouseEvent | TouchEvent) => void;
+    [BlockSelectionEvents.blockSelectionEnd]: (startCell: ICell, endCell: ICell, handle: boolean, event: MouseEvent | TouchEvent) => void;
+    [BlockSelectionEvents.beforeBlockSelectionApply]: (startCell: ICell, endCell: ICell, handle: boolean, event: MouseEvent | TouchEvent) => boolean | void;
+    [BlockSelectionEvents.afterBlockSelectionApply]: (startCell: ICell, endCell: ICell, handle: boolean, event: MouseEvent | TouchEvent) => void;
+    [BlockSelectionEvents.beforeBlockHandleApply]: (startCell: ICell, endCell: ICell, dragDirection: DragDirection | null, event: MouseEvent | TouchEvent) => boolean | void;
+    [BlockSelectionEvents.afterBlockHandleApply]: (startCell: ICell, endCell: ICell, dragDirection: DragDirection | null, event: MouseEvent | TouchEvent) => void;
+    [BlockSelectionEvents.blockHandleMouseDown]: (event: MouseEvent | TouchEvent) => void;
+}
+export interface IHandleHandler {
+    cell: ICell;
+    array: ICell[];
+    range: ICell[];
+    dir: DragDirection;
+    index: number;
+    grid: IProGrid;
+}
+export interface IHandleHistory {
+    prev: any;
+    current: any;
+}
+export interface IHandleConfig {
+    allowAxis?: HandleAxis;
+    handler?: boolean | ((args: IHandleHandler) => IHandleHistory | void);
+}
+export interface IBlockSelectionConfig {
+    disabled?: boolean;
+    mode?: RangeMode;
+    handle?: boolean | IHandleConfig;
+    area?: boolean;
+}
+export interface IBlockSelection {
+    config: IBlockSelectionConfig;
+    events: IEventSystem<BlockSelectionEvents, IBlockSelectionEventsHandlersMap>;
+    enable(): void;
+    disable(): void;
+    isDisabled(): boolean;
+    /**
+     * @private
+     * This method destroys the module
+     */
+    destructor(): void;
+    /**
+     * @private
+     * This method is for internal use and should not be called directly
+     */
+    toHTML(): VNode | VNode[];
+}
+export declare class BlockSelection implements IBlockSelection {
+    config: IBlockSelectionConfig;
+    events: IEventSystem<BlockSelectionEvents, IBlockSelectionEventsHandlersMap>;
+    private _grid;
+    private _startCell;
+    private _endCell;
+    private _focusStartCell;
+    private _focusEndCell;
+    private _selectionBounds;
+    private _startCellRect;
+    private _endCellRect;
+    private _focusCellRect;
+    private _startPoint;
+    private _dragDirection;
+    private _disabled;
+    private _isHandleActive;
+    private _handlers;
+    private readonly HANDLE_OFFSET;
+    private readonly MOVE_THRESHOLD;
+    constructor(grid: IProGrid | IExtendedGrid);
+    enable(): void;
+    disable(): void;
+    isDisabled(): boolean;
+    destructor(): void;
+    toHTML(): VNode | null;
+    private _getAreaNode;
+    private _getStartCellNode;
+    private _getHandleAreaNode;
+    private _getHandleNode;
+    private _initConfig;
+    private _initHandlers;
+    private _blockSelectionValidate;
+    private _blockSelectionStart;
+    private _blockSelectionMove;
+    private _blockSelectionEnd;
+    private _updateSelectionBounds;
+    private _resetMoveState;
+    private _applyAreaSelection;
+    private _applyHandle;
+    private _getDragDirection;
+    private _calculateBounds;
+    private _isCellFixed;
+    private _getFixedItems;
+    private _isColumnFixed;
+    private _setHandlers;
+    private _removeHandlers;
+    private _getPageCoords;
+    private _cellHandler;
+    private _paint;
+}

package/codebase/types/ts-grid/sources/modules/Clipboard.d.ts

@@ -0,0 +1,55 @@
+import { IEventSystem } from "../../../ts-common/events";
+import { ICell } from "../types";
+export declare enum ClipboardEvents {
+    beforeCopy = "beforeCopy",
+    afterCopy = "afterCopy",
+    copyError = "copyError",
+    beforePaste = "beforePaste",
+    afterPaste = "afterPaste",
+    pasteError = "pasteError"
+}
+export interface IClipboardEventsHandlersMap {
+    [key: string]: (...args: any[]) => any;
+    [ClipboardEvents.beforeCopy]: (isCut: boolean) => boolean | void;
+    [ClipboardEvents.afterCopy]: (isCut: boolean) => void;
+    [ClipboardEvents.copyError]: (error: string) => void;
+    [ClipboardEvents.beforePaste]: () => boolean | void;
+    [ClipboardEvents.afterPaste]: () => void;
+    [ClipboardEvents.pasteError]: (error: string) => void;
+}
+export interface IClipboardConfig {
+    copyModifier?: (value: any, cell: ICell, cut: boolean) => string;
+    cutModifier?: (value: any, cell: ICell) => string;
+    pasteModifier?: (value: any, cell: ICell) => any;
+}
+export interface IClipboard {
+    config: IClipboardConfig;
+    events: IEventSystem<ClipboardEvents, IClipboardEventsHandlersMap>;
+    copy(event?: ClipboardEvent): void;
+    paste(event?: ClipboardEvent): void;
+    cut(event?: ClipboardEvent): void;
+    /**
+     * @private
+     * This method destroys the module
+     */
+    destructor(): void;
+}
+export declare class Clipboard implements IClipboard {
+    config: IClipboardConfig;
+    events: IEventSystem<ClipboardEvents, IClipboardEventsHandlersMap>;
+    private _grid;
+    private _handler;
+    constructor(grid: any);
+    copy(event?: ClipboardEvent): void;
+    cut(event?: ClipboardEvent): void;
+    paste(event?: ClipboardEvent): void;
+    destructor(): void;
+    private _prepareClipboardData;
+    private _initHandlers;
+    private _isFocused;
+    private _getNextId;
+    private _processPaste;
+    private _clearCells;
+    private _setFocus;
+    private _paint;
+}

package/codebase/types/ts-grid/sources/modules/DropManager.d.ts

@@ -0,0 +1,21 @@
+import { VNode } from "../../../ts-common/dom";
+export declare class DropManager {
+    private _isTreeMode;
+    private _grid;
+    private _dragState;
+    private _dragType;
+    constructor({ view }: {
+        view: any;
+    });
+    toHTML(state?: any): VNode;
+    private _getDropLineNode;
+    private _getVerticalDropLine;
+    private _getHorizontalDropLine;
+    private _init;
+    private _getNextRow;
+    private _isColumnFixed;
+    private _getTopPosition;
+    private _getBottomPosition;
+    private _toggleRowDraggable;
+    private _isSameComponent;
+}

package/codebase/types/ts-grid/sources/{Exporter.d.ts → modules/Exporter.d.ts}

@@ -1,18 +1,29 @@
-import { ICsvExportConfig, IGrid, IXlsxExportConfig, ICellCss } from "./types";
-import { IPDFConfig, IPNGConfig, TExportType } from "../../ts-common/types";
+import { ICsvExportConfig, IExportGridCell, IGrid, IXlsxExportConfig } from "../types";
+import { IPDFConfig, IPNGConfig, TExportType } from "../../../ts-common/types";
 export interface IExportData {
-    name: string;
-    columns: Array<{
-        width: number;
-    }>;
-    header: string[][];
-    data: any[];
+    data: {
+        name: string;
+        cells: (IExportGridCell | undefined)[][];
+        cols: {
+            width: number;
+        }[];
+        rows: {
+            height: number;
+        }[];
+        merged: {
+            from: {
+                row: number;
+                column: number;
+            };
+            to: {
+                row: number;
+                column: number;
+            };
+        }[];
+    }[];
     styles: {
-        cells: any[];
-        css: {
-            [key: string]: ICellCss;
-        };
-    };
+        [key: string]: string;
+    }[];
 }
 export interface IExporter {
     pdf: (config?: IPDFConfig) => void;
@@ -24,14 +35,16 @@ export declare class Exporter implements IExporter {
     private _name;
     private _version;
     private _view;
+    private _xlsxWorker;
     constructor(_name: string, _version: string, _view: IGrid);
     pdf(config?: IPDFConfig): void;
     png(config?: IPNGConfig): void;
-    xlsx(config?: IXlsxExportConfig): IExportData;
+    xlsx(c?: IXlsxExportConfig): IExportData;
     csv(config?: ICsvExportConfig): string;
     private _export;
     private getFlatCSV;
     private _getCSV;
     protected _rawExport(config: IPNGConfig | IPDFConfig, mode: TExportType, view: any): void;
     private _getHash;
+    private _getXlsxWorker;
 }

package/codebase/types/ts-grid/sources/modules/History.d.ts

@@ -0,0 +1,72 @@
+import { IEventSystem } from "../../../ts-common/events";
+import { IExtendedGrid, IProGrid, IRow } from "../types";
+export type ActionType = "add" | "remove" | "removeAll" | "change";
+export interface IAction {
+    type: ActionType;
+    batch: IRow[];
+    inverse?: IAction;
+    timestamp?: number;
+}
+export declare enum HistoryEvents {
+    beforeUndo = "beforeUndo",
+    afterUndo = "afterUndo",
+    beforeRedo = "beforeRedo",
+    afterRedo = "afterRedo",
+    beforeAdd = "beforeAdd",
+    afterAdd = "afterAdd",
+    error = "error"
+}
+export interface IHistoryEventsHandlersMap {
+    [key: string]: (...args: any[]) => any;
+    [HistoryEvents.beforeUndo]: (action: IAction) => boolean | void;
+    [HistoryEvents.afterUndo]: (action: IAction) => void;
+    [HistoryEvents.beforeRedo]: (action: IAction) => boolean | void;
+    [HistoryEvents.afterRedo]: (action: IAction) => void;
+    [HistoryEvents.beforeAdd]: (action: IAction) => boolean | void;
+    [HistoryEvents.afterAdd]: (action: IAction) => void;
+    [HistoryEvents.error]: (error: string, action: IAction | null) => void;
+}
+export interface IHistoryConfig {
+    limit?: number;
+    disabled?: boolean;
+}
+export interface IHistory {
+    config: IHistoryConfig;
+    events: IEventSystem<HistoryEvents, IHistoryEventsHandlersMap>;
+    add(action: IAction): void;
+    remove(): void;
+    removeAll(): void;
+    undo(): void;
+    redo(): void;
+    canUndo(): boolean;
+    canRedo(): boolean;
+    getHistory(): IAction[];
+    disable(): void;
+    enable(): void;
+    isDisabled(): boolean;
+    destructor(): void;
+}
+export declare class History implements IHistory {
+    config: IHistoryConfig;
+    events: IEventSystem<HistoryEvents, IHistoryEventsHandlersMap>;
+    private _history;
+    private _redoStack;
+    private _isDisabled;
+    private static readonly VALID_ACTION_TYPES;
+    constructor(grid: IProGrid | IExtendedGrid);
+    add(action: IAction): void;
+    remove(): void;
+    removeAll(): void;
+    undo(): void;
+    redo(): void;
+    canUndo(): boolean;
+    canRedo(): boolean;
+    getHistory(): IAction[];
+    disable(): void;
+    enable(): void;
+    isDisabled(): boolean;
+    destructor(): void;
+    private _initConfig;
+    private _initHandlers;
+    private _fireError;
+}

package/codebase/types/ts-grid/sources/modules/Range.d.ts

@@ -0,0 +1,71 @@
+import { IEventSystem } from "../../../ts-common/events";
+import { Id } from "../../../ts-common/types";
+import { ICell, IExtendedGrid, IProGrid } from "../types";
+export interface IRangeSelection {
+    xStart?: Id;
+    xEnd?: Id;
+    yStart?: Id;
+    yEnd?: Id;
+}
+export interface IRangeCell {
+    x?: Id;
+    y?: Id;
+}
+export interface IRangeConfig {
+    disabled?: boolean;
+}
+export declare enum RangeEvents {
+    beforeSetRange = "beforeSetRange",
+    afterSetRange = "afterSetRange",
+    beforeResetRange = "beforeResetRange",
+    afterResetRange = "afterResetRange"
+}
+export interface IRangeEventsHandlersMap {
+    [key: string]: (...args: any[]) => any;
+    [RangeEvents.beforeSetRange]: (range: IRangeSelection) => boolean | void;
+    [RangeEvents.afterSetRange]: (range: IRangeSelection) => void;
+    [RangeEvents.beforeResetRange]: (range: IRangeSelection) => boolean | void;
+    [RangeEvents.afterResetRange]: (range: IRangeSelection) => void;
+}
+export interface IRange {
+    config: IRangeConfig;
+    events: IEventSystem<RangeEvents, IRangeEventsHandlersMap>;
+    setRange(range: IRangeSelection, join?: boolean): boolean;
+    resetRange(): boolean;
+    getRange(): IRangeSelection | null;
+    getRangedCells(): ICell[];
+    isRanged(cell: IRangeCell): boolean;
+    enable(): void;
+    disable(): void;
+    isDisabled(): boolean;
+    /**
+     * @private
+     * This method destroys the module
+     */
+    destructor(): void;
+}
+export declare class Range implements IRange {
+    config: IRangeConfig;
+    events: IEventSystem<RangeEvents, IRangeEventsHandlersMap>;
+    private _grid;
+    private _range;
+    private _cells;
+    private _xSet;
+    private _ySet;
+    private _disabled;
+    constructor(grid: IExtendedGrid | IProGrid);
+    setRange(range: IRangeSelection, join?: boolean): boolean;
+    resetRange(): boolean;
+    getRange(): IRangeSelection | null;
+    getRangedCells(): ICell[];
+    isRanged(cell: IRangeCell): boolean;
+    enable(): void;
+    disable(): void;
+    isDisabled(): boolean;
+    destructor(): void;
+    private _resetRange;
+    private _getColumnRange;
+    private _getRowRange;
+    private _isAllowedRange;
+    private _initHandlers;
+}

package/codebase/types/ts-grid/sources/{columnsResizer.d.ts → modules/Resizer.d.ts}

@@ -1,2 +1,2 @@
-import { IGrid, IProGrid } from "./types";
+import { IGrid, IProGrid } from "../types";
 export declare function startResize(grid: IGrid | IProGrid, column: string, ev: MouseEvent & TouchEvent, cb: any): void;