@dhtmlx/vault 5.0.6

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/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;
+};

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

@@ -0,0 +1,23 @@
+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;
+export declare function isCssSupport(property: string, value: string): boolean;
+export declare function isRowEmpty(row: IRow): boolean;
+export declare function isSortable(config: IGridConfig, col: ICol): boolean;
+export declare function isAutoWidth(config: IGridConfig, col?: ICol): boolean;
+export declare function showTooltip(value: any, config: ITooltipConfig): void;
+export declare function isContentTooltip(config: IGridConfig, col: ICol, cell: any, type: "footer" | "header"): boolean;
+export declare function getTooltipConfig(config: IGridConfig, col?: ICol, cell?: IHeader | IFooter | ISpan, type?: "footer" | "header"): IGridTooltipConfig;
+export declare function isTooltip(config: IGridConfig, element: ICol | ISpan): boolean | IGridTooltipConfig;
+export declare function isHtmlEnable(config: IGridConfig, col: ICol, content?: IHeader | IFooter): boolean;
+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/locales/en.d.ts

@@ -0,0 +1,7 @@
+declare const locale: {
+    total: string;
+    groupText: string;
+    dropAreaTitle: string;
+    dropAreaPlaceholder: string;
+};
+export default locale;

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

@@ -0,0 +1,122 @@
+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 _calculateClippedGeometry;
+    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 _getSourceCellIndex;
+    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/modules/Exporter.d.ts

@@ -0,0 +1,80 @@
+import { IExportGridCell, IGrid, IProGrid, IProGridConfig, TExportConfigFunction } from "../types";
+import { ICsvDriverConfig } from "../../../ts-data";
+import { IPDFConfig, IPNGConfig, TExportType } from "../../../ts-common/types";
+export type ExportType = "pdf" | "png" | "csv" | "xlsx";
+export interface IXlsxExportConfig {
+    url?: string;
+    name?: string;
+    tableName?: string;
+    dateFormatMask?: string;
+    mapToExcelFormulas?: {
+        [key: string]: string;
+    };
+}
+export interface ICsvExportConfig extends ICsvDriverConfig {
+    name?: string;
+    asFile?: boolean;
+    flat?: boolean;
+    rowDelimiter?: string;
+    columnDelimiter?: string;
+}
+export interface IExportData {
+    data: {
+        name: string;
+        cells: (IExportGridCell | undefined)[][];
+        cols: {
+            width: number;
+        }[];
+        rows: {
+            height: number;
+        }[];
+        merged: {
+            from: {
+                row: number;
+                column: number;
+            };
+            to: {
+                row: number;
+                column: number;
+            };
+        }[];
+    }[];
+    styles: {
+        [key: string]: string;
+    }[];
+}
+export interface IExporter {
+    pdf: (config?: IPDFConfig) => Promise<void>;
+    png: (config?: IPNGConfig) => Promise<void>;
+    xlsx: (config?: IXlsxExportConfig) => Promise<IExportData>;
+    csv: (config?: ICsvExportConfig) => Promise<string>;
+}
+export interface IExportConfig extends IProGridConfig {
+    typeConfig?: IXlsxExportConfig | ICsvExportConfig | IPDFConfig | IPNGConfig;
+}
+export declare class Exporter implements IExporter {
+    private _xlsxWorker;
+    private _name;
+    private _version;
+    private _grid;
+    private _exportConfigCallback;
+    constructor(config: {
+        name: string;
+        version: string;
+        view: IProGrid | IGrid;
+        export: TExportConfigFunction | null;
+    });
+    pdf(typeConfig?: IPDFConfig): Promise<void>;
+    png(typeConfig?: IPNGConfig): Promise<void>;
+    xlsx(typeConfig?: IXlsxExportConfig): Promise<IExportData>;
+    csv(typeConfig?: ICsvExportConfig): Promise<string>;
+    private _getExportData;
+    private _xlsxExport;
+    private getFlatCSV;
+    private _getCSV;
+    protected _rawExport(typeConfig: IPNGConfig | IPDFConfig, mode: TExportType): Promise<void>;
+    private _getExportWidget;
+    private _getExportConfig;
+    private _getCallbackData;
+    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;
+}