dhx-chart 8.2.4 → 8.2.5

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

@@ -0,0 +1,40 @@
+import { ISpacer, ISeparator, IMenuItem, NavigationBarEvents, DataEvents, INavbar, INavbarEventHandlersMap, ITitle, ICustomHTML, INavItem } from "../../ts-navbar";
+import { IEventSystem } from "../../ts-common/events";
+import { IDataEventsHandlersMap, TreeCollection } from "../../ts-data";
+import { ScrollView } from "../../ts-common/ScrollView";
+export interface ISidebarConfig {
+    css?: string;
+    menuCss?: string;
+    data?: any[] | TreeCollection<ISidebarElement>;
+    width?: number | string;
+    minWidth?: number | string;
+    collapsed?: boolean;
+}
+export type ISidebarElement = ISeparator | ISpacer | ITitle | INavItem | IMenuItem | ICustomHTML;
+export interface ISidebar extends INavbar {
+    config: ISidebarConfig;
+    events: IEventSystem<DataEvents | NavigationBarEvents, IDataEventsHandlersMap & INavbarEventHandlersMap & SidebarEvents & ISidebarEventHandlersMap>;
+    toggle(): void;
+    isCollapsed(): boolean;
+    expand(): void;
+    collapse(): void;
+}
+export interface IProSidebar extends ISidebar {
+    scrollView: ScrollView;
+}
+export declare enum SidebarEvents {
+    beforeCollapse = "beforeCollapse",
+    afterCollapse = "afterCollapse",
+    beforeExpand = "beforeExpand",
+    afterExpand = "afterExpand",
+    /** @deprecated See a documentation: https://docs.dhtmlx.com/ */
+    toggle = "toggle"
+}
+export interface ISidebarEventHandlersMap {
+    [key: string]: (...args: any[]) => any;
+    [SidebarEvents.beforeCollapse]: () => boolean | void;
+    [SidebarEvents.afterCollapse]: () => void;
+    [SidebarEvents.beforeExpand]: () => boolean | void;
+    [SidebarEvents.afterExpand]: () => void;
+    [SidebarEvents.toggle]: () => any;
+}

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

@@ -0,0 +1,2 @@
+import "../../styles/slider.scss";
+export { Slider } from "./Slider";

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

@@ -1,5 +1,5 @@
-export declare type Direction = "vertical" | "horizontal";
-export declare type ActiveSlider = "tooltip" | "extraTooltip" | "none";
+export type Direction = "vertical" | "horizontal";
+export type ActiveSlider = "tooltip" | "extraTooltip" | "none";
 export interface ISlider {
     config: ISliderConfig;
     paint(): void;
@@ -31,7 +31,7 @@ export interface ISliderEventHandlersMap {
     [SliderEvents.mousedown]: (event: Event) => void;
     [SliderEvents.mouseup]: (event: Event) => void;
 }
-export declare type ILabelPosition = "left" | "top";
+export type ILabelPosition = "left" | "top";
 export interface ISliderConfig {
     min?: number;
     max?: number;

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

@@ -0,0 +1,2 @@
+export * from "./sources/Tabbar";
+export * from "./sources/types";

package/codebase/types/ts-tabbar/sources/Tabbar.d.ts

@@ -0,0 +1,38 @@
+import { EventSystem } from "../../ts-common/events";
+import { Layout, LayoutEvents, ILayoutEventHandlersMap } from "../../ts-layout";
+import { ITabbarConfig, TabbarEvents, ITabbarEventHandlersMap, ITabbar, ITab } from "./types";
+export declare class Tabbar extends Layout implements ITabbar {
+    config: ITabbarConfig;
+    events: EventSystem<TabbarEvents | LayoutEvents, ITabbarEventHandlersMap | ILayoutEventHandlersMap>;
+    private _tabsContainer;
+    protected _cells: ITab[];
+    private _beforeScrollSize;
+    private _afterScrollSize;
+    private _keyManager;
+    private _tabFontSize;
+    constructor(container: any, config: ITabbarConfig);
+    toVDOM(): any;
+    destructor(): void;
+    getWidget(): any;
+    setActive(id: string): void;
+    getActive(): string;
+    addTab(config: ITabbarConfig, index: number): void;
+    removeTab(id: string): void;
+    disableTab(id: string): boolean;
+    enableTab(id: string): void;
+    isDisabled(id?: string): boolean;
+    /** @deprecated See a documentation: https://docs.dhtmlx.com/ */
+    removeCell(id: string): void;
+    protected _initHandlers(): void;
+    private _isHorizontalMode;
+    private _focusTab;
+    private _getEnableTabs;
+    private _getIndicatorPosition;
+    private _drawTabs;
+    private _getSizes;
+    private _normalizeSize;
+    private _getTabAutoWidth;
+    private _getTabAutoHeight;
+    private _getTabContainer;
+    private _initHotkeys;
+}

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

@@ -0,0 +1,2 @@
+import "../../styles/tabbar.scss";
+export { Tabbar } from "./Tabbar";

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

@@ -0,0 +1,64 @@
+import { ILayoutConfig, LayoutEvents, ILayoutEventHandlersMap, ICellConfig, ICell } from "../../ts-layout";
+import { EventSystem } from "../../ts-common/events";
+import { Position } from "../../ts-common/html";
+export interface ITabbarConfig extends ILayoutConfig {
+    mode?: Position;
+    noContent?: boolean;
+    css?: string;
+    disabled?: string | string[];
+    closable?: boolean | string[];
+    activeTab?: string;
+    tabAutoWidth?: boolean;
+    tabAutoHeight?: boolean;
+    tabWidth?: number | string;
+    tabHeight?: number | string;
+    tabAlign?: "left" | "start" | "center" | "middle" | "right" | "end";
+    /** @deprecated See a documentation: https://docs.dhtmlx.com/ */
+    closeButtons?: boolean;
+}
+export interface ITab extends ICell {
+    config: ITabConfig;
+}
+export interface ITabConfig extends ICellConfig {
+    tabAutoWidth?: boolean;
+    tabAutoHeight?: boolean;
+    tabWidth?: number | string;
+    tabHeight?: number | string;
+}
+export declare enum TabbarEvents {
+    beforeChange = "beforeChange",
+    change = "change",
+    beforeClose = "beforeClose",
+    afterClose = "afterClose",
+    /** @deprecated See a documentation: https://docs.dhtmlx.com/ */
+    close = "close"
+}
+export interface ITabbar {
+    config: ITabbarConfig;
+    events: EventSystem<TabbarEvents | LayoutEvents, ITabbarEventHandlersMap | ILayoutEventHandlersMap>;
+    toVDOM(nodes?: any[]): any;
+    paint(): void;
+    destructor(): void;
+    getId(index: number): string;
+    getCell(id: string): ICell;
+    setActive(id: string): void;
+    getWidget(): any;
+    getActive(): string;
+    removeTab(id: string): void;
+    addTab(config: ITabbarConfig, index: number): void;
+    disableTab(id: string): boolean;
+    enableTab(id: string): void;
+    isDisabled(id?: string): boolean;
+    /** @deprecated See a documentation: https://docs.dhtmlx.com/ */
+    removeCell(id: string): void;
+    /** @deprecated See a documentation: https://docs.dhtmlx.com/ */
+    addCell(config: ITabbarConfig, index: number): any;
+}
+export interface ITabbarEventHandlersMap {
+    [key: string]: (...args: any[]) => any;
+    [TabbarEvents.beforeChange]: (id: string, prev: string) => boolean | void;
+    [TabbarEvents.change]: (id: string, prev: string) => void;
+    [TabbarEvents.beforeClose]: (id: string) => boolean | void;
+    [TabbarEvents.afterClose]: (id: string) => void;
+    [TabbarEvents.close]: (id: string) => any;
+}

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

@@ -0,0 +1,3 @@
+import "../../styles/timepicker.scss";
+export { Timepicker } from "./Timepicker";
+export declare const i18n: any;

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

@@ -0,0 +1,2 @@
+export * from "./sources/Toolbar";
+export * from "./sources/ProToolbar";

package/codebase/types/ts-toolbar/sources/ProToolbar.d.ts

@@ -0,0 +1,10 @@
+import { Toolbar, IToolbar } from "./Toolbar";
+import { ScrollView } from "../../ts-common/ScrollView";
+export interface IProToolbar extends IToolbar {
+    scrollView: ScrollView;
+}
+export declare class ProToolbar extends Toolbar implements IProToolbar {
+    scrollView: ScrollView;
+    constructor(element?: string | HTMLElement, config?: any);
+    protected _draw(element: any): any;
+}

package/codebase/types/ts-toolbar/sources/Toolbar.d.ts

@@ -0,0 +1,32 @@
+import { Id } from "../../ts-common/types";
+import { TreeCollection } from "../../ts-data";
+import { IState, Navbar, INavbar, IButton, IImageButton, ISelectButton, IInput, ISeparator, ISpacer, ITitle, ICustomHTML, INavItem, IMenuItem, IDatePicker } from "../../ts-navbar";
+export interface IToolbarConfig {
+    css?: string;
+    menuCss?: string;
+    data?: any[] | TreeCollection<IToolbarElement>;
+}
+export interface IToolbar extends INavbar {
+    data: TreeCollection<IToolbarElement>;
+    config: IToolbarConfig;
+    getState(id?: Id): IState;
+    setState(state: IState): void;
+}
+export type IToolbarElement = IButton | IImageButton | ISelectButton | IInput | ISeparator | ISpacer | ITitle | ICustomHTML | INavItem | IMenuItem | IDatePicker;
+export declare class Toolbar extends Navbar<IToolbarElement> implements IToolbar {
+    data: TreeCollection<IToolbarElement>;
+    config: IToolbarConfig;
+    constructor(element?: string | HTMLElement, config?: any);
+    getState(id?: Id): IState;
+    setState(state: IState): void;
+    setFocus(id: Id): void;
+    protected _customHandlers(): {
+        input: (e: Event) => void;
+        tooltip: (e: MouseEvent) => void;
+    };
+    protected _getFactory(): any;
+    protected _draw(element: any): any;
+    protected _getMode(item: any, root: any): "right" | "bottom";
+    protected _close(e: MouseEvent): void;
+    protected _setRoot(id: Id): void;
+}

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

@@ -0,0 +1,4 @@
+import "../../styles/toolbar.scss";
+import "../../styles/calendar.scss";
+export { TreeCollection } from "../../ts-data";
+export { Toolbar } from "./Toolbar";

package/codebase/types/ts-toolbar/sources/entry_pro.d.ts

@@ -0,0 +1,2 @@
+export * from "./entry";
+export { ProToolbar as Toolbar } from "./ProToolbar";

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

@@ -0,0 +1,3 @@
+export * from "./sources/Tree";
+export * from "./sources/Editor";
+export * from "./sources/types";

package/codebase/types/ts-tree/sources/Editor.d.ts

@@ -0,0 +1,42 @@
+import { VNode } from "../../ts-common/dom";
+import { IEventSystem } from "../../ts-common/events";
+export declare enum EditorMode {
+    editText = "text",
+    selectItem = "select"
+}
+export declare enum EditorEvents {
+    begin = "begin",
+    end = "end"
+}
+export interface IEditorConfig {
+    item?: any;
+    mode: EditorMode;
+    options?: string[];
+}
+export interface IEditor {
+    config: IEditorConfig;
+    events: IEventSystem<EditorEvents>;
+    edit(targetId: string, config: IEditorConfig): VNode;
+    isEditable(): boolean;
+}
+export declare class Editor implements IEditor {
+    config: IEditorConfig;
+    events: IEventSystem<EditorEvents>;
+    private _item;
+    private _handlers;
+    private _currentValue;
+    private _active;
+    private _targetId;
+    private _documentClick;
+    private _keyManager;
+    constructor();
+    edit(targetId: string, config: IEditorConfig): any;
+    isEditable(): boolean;
+    private _draw;
+    private _addHotkeys;
+    private _removeHotkeys;
+    private _finishEdit;
+    private _clear;
+    private _initOuterClick;
+    private _removeClickListener;
+}

package/codebase/types/ts-tree/sources/Tree.d.ts

@@ -0,0 +1,58 @@
+import { IEventSystem } from "../../ts-common/events";
+import { Id } from "../../ts-common/types";
+import { View } from "../../ts-common/view";
+import { Selection, TreeCollection, DataEvents, DragEvents, IDataEventsHandlersMap, IDragEventsHandlersMap } from "../../ts-data";
+import { IEditorConfig } from "./Editor";
+import { ITree, ITreeConfig, ITreeState, TreeEvents, ITreeEventHandlersMap, ITreeItem } from "./types";
+export declare class Tree<T extends object = object> extends View implements ITree {
+    config: ITreeConfig;
+    data: TreeCollection<T & ITreeItem>;
+    events: IEventSystem<DataEvents | TreeEvents | DragEvents, IDataEventsHandlersMap & ITreeEventHandlersMap & IDragEventsHandlersMap>;
+    selection: Selection;
+    private _editor;
+    private _handlers;
+    private _isSelectionActive;
+    private _root;
+    private _focusId;
+    private _right;
+    private _keyManager;
+    private _touch;
+    private _isDraget;
+    constructor(container: HTMLElement | string, config?: ITreeConfig);
+    focusItem(id: Id): void;
+    destructor(): void;
+    editItem(id: Id, config?: IEditorConfig): void;
+    getState(): ITreeState;
+    setState(state: ITreeState): void;
+    toggle(id: Id): void;
+    getChecked(): Id[];
+    checkItem(id: Id): void;
+    collapse(id: Id): void;
+    collapseAll(): void;
+    expand(id: Id): void;
+    expandAll(): void;
+    uncheckItem(id: Id): void;
+    /** @deprecated See a documentation: https://docs.dhtmlx.com/ */
+    close(id: Id): void;
+    /** @deprecated See a documentation: https://docs.dhtmlx.com/ */
+    closeAll(): void;
+    /** @deprecated See a documentation: https://docs.dhtmlx.com/ */
+    open(id: Id): void;
+    /** @deprecated See a documentation: https://docs.dhtmlx.com/ */
+    openAll(): void;
+    /** @deprecated See a documentation: https://docs.dhtmlx.com/ */
+    unCheckItem(id: Id): void;
+    private _draw;
+    private _initEvents;
+    private _autoScroll;
+    private _scrollTo;
+    private _initHandlers;
+    private _dblClick;
+    private _clearTouchTimer;
+    private _dragStart;
+    private _getRightPos;
+    private _drawItems;
+    private _updateItemCheck;
+    private _updateParents;
+    private _initHotkeys;
+}

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

@@ -0,0 +1,6 @@
+import "../../styles/tree.scss";
+import "../../styles/themes.scss";
+export { awaitRedraw, setTheme } from "../../ts-common/dom";
+export { TreeCollection } from "../../ts-data";
+export { Tree } from "./Tree";
+export { ContextMenu } from "../../ts-menu";

package/codebase/types/ts-tree/sources/entry_pro.d.ts

@@ -0,0 +1,2 @@
+export * from "./entry";
+export { dataDriversPro as dataDrivers } from "../../ts-data";

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

@@ -0,0 +1,119 @@
+import { IEventSystem } from "../../ts-common/events";
+import { Id } from "../../ts-common/types";
+import { TreeCollection, DataEvents, DragEvents, IDragConfig, IDataItem, IDragEventsHandlersMap, Selection } from "../../ts-data";
+import { IEditorConfig } from "./Editor";
+export interface ITreeState {
+    [id: string]: {
+        selected: SelectStatus;
+        open: boolean;
+    };
+}
+export interface ITreeItem extends IDataItem {
+    parent: string;
+    opened?: boolean;
+    $mark?: SelectStatus;
+    checkbox?: boolean;
+    $autoload?: boolean;
+    $selected?: boolean;
+    $editor?: boolean;
+}
+export interface ITreeCustomIcon {
+    file?: string;
+    folder?: string;
+    openFolder?: string;
+}
+export declare enum SelectStatus {
+    unselected = 0,
+    selected = 1,
+    indeterminate = 2
+}
+export type ItemIcon = "file" | "folder" | "openFolder";
+export interface ITreeConfig extends IDragConfig {
+    data?: TreeCollection<any> | any[];
+    css?: string;
+    keyNavigation?: boolean;
+    autoload?: string;
+    checkbox?: boolean;
+    isFolder?: (obj: any) => boolean;
+    icon?: ITreeCustomIcon;
+    editable?: boolean;
+    selection?: boolean;
+    rootId?: Id;
+    itemHeight?: number | string;
+    template?: (item: ITreeItem, isFolder: boolean) => string;
+    eventHandlers?: {
+        [eventName: string]: {
+            [className: string]: (event: Event, item: ITree) => void | boolean;
+        };
+    };
+    collapsed?: boolean;
+    $editable?: boolean;
+    /** @deprecated See a documentation: https://docs.dhtmlx.com/ */
+    editing?: boolean;
+}
+export interface ITree {
+    data: TreeCollection;
+    events: IEventSystem<DataEvents | DragEvents | TreeEvents>;
+    selection: Selection;
+    config: ITreeConfig;
+    paint(): void;
+    destructor(): void;
+    editItem(id: Id, config: IEditorConfig): void;
+    getState(): ITreeState;
+    setState(state: ITreeState): void;
+    focusItem(id: Id): void;
+    toggle(id: Id): void;
+    getChecked(): Id[];
+    checkItem(id: Id): void;
+    collapse(id: Id): void;
+    collapseAll(): void;
+    expand(id: Id): void;
+    expandAll(): void;
+    uncheckItem(id: Id): void;
+    /** @deprecated See a documentation: https://docs.dhtmlx.com/ */
+    close(id: Id): void;
+    /** @deprecated See a documentation: https://docs.dhtmlx.com/ */
+    closeAll(): void;
+    /** @deprecated See a documentation: https://docs.dhtmlx.com/ */
+    open(id: Id): void;
+    /** @deprecated See a documentation: https://docs.dhtmlx.com/ */
+    openAll(): void;
+    /** @deprecated See a documentation: https://docs.dhtmlx.com/ */
+    unCheckItem(id: Id): void;
+}
+export declare enum TreeEvents {
+    itemClick = "itemclick",
+    itemDblClick = "itemdblclick",
+    itemRightClick = "itemrightclick",
+    beforeCollapse = "beforeCollapse",
+    afterCollapse = "afterCollapse",
+    beforeExpand = "beforeExpand",
+    afterExpand = "afterExpand",
+    beforeEditStart = "beforeEditStart",
+    afterEditStart = "afterEditStart",
+    beforeEditEnd = "beforeEditEnd",
+    afterEditEnd = "afterEditEnd",
+    focusChange = "focusChange",
+    beforeCheck = "beforeCheck",
+    afterCheck = "afterCheck",
+    /** @deprecated See a documentation: https://docs.dhtmlx.com/ */
+    itemContextMenu = "itemcontextmenu"
+}
+export interface ITreeEventHandlersMap extends IDragEventsHandlersMap {
+    [key: string]: (...args: any[]) => any;
+    [TreeEvents.itemClick]: (id: Id, e: Event) => any;
+    [TreeEvents.itemRightClick]: (id: Id, e: Event) => void;
+    [TreeEvents.itemDblClick]: (id: Id, e: Event) => void;
+    [TreeEvents.beforeCollapse]: (id: Id) => boolean | void;
+    [TreeEvents.afterCollapse]: (id: Id) => void;
+    [TreeEvents.beforeExpand]: (id: Id) => boolean | void;
+    [TreeEvents.afterExpand]: (id: Id) => void;
+    [TreeEvents.beforeEditStart]: (value: string, id: Id) => boolean | void;
+    [TreeEvents.afterEditStart]: (value: string, id: Id) => void;
+    [TreeEvents.beforeEditEnd]: (value: string, id: Id) => boolean | void;
+    [TreeEvents.afterEditEnd]: (value: string, id: Id) => void;
+    [TreeEvents.focusChange]: (index: number, id: Id) => void;
+    [TreeEvents.beforeCheck]: (index: number, id: Id) => boolean | void;
+    [TreeEvents.afterCheck]: (index: number, id: Id, value: boolean) => void;
+    [TreeEvents.itemContextMenu]: (id: Id, e: Event) => any;
+}

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

@@ -0,0 +1,3 @@
+export * from "./sources/TreeGrid";
+export * from "./sources/types";
+export * from "./sources/TreeGridCollection";

package/codebase/types/ts-treegrid/sources/TreeGrid.d.ts

@@ -0,0 +1,30 @@
+import { GridEvents, IEventHandlersMap, ProGrid, ICellRect, IColumnsWidth, ISpan, IAdjustColumns } from "../../ts-grid";
+import { IEventSystem } from "../../ts-common/events";
+import { DataEvents, DragEvents, IDataEventsHandlersMap, IDragEventsHandlersMap, IDataItem } from "../../ts-data";
+import { TreeGridCollection } from "./TreeGridCollection";
+import { ITreeEventHandlersMap, ITreeGrid, ITreeGridConfig, TreeGridEvents } from "./types";
+import { Id } from "../../ts-common/types";
+export declare class TreeGrid extends ProGrid implements ITreeGrid {
+    config: ITreeGridConfig;
+    data: TreeGridCollection;
+    events: IEventSystem<DataEvents | GridEvents | DragEvents | TreeGridEvents, IEventHandlersMap & IDataEventsHandlersMap & IDragEventsHandlersMap & ITreeEventHandlersMap>;
+    private _pregroupData;
+    constructor(container: HTMLElement, config: ITreeGridConfig);
+    scrollTo(rowId: Id, colId: Id): void;
+    expand(rowId: Id): void;
+    collapse(rowId: Id): void;
+    expandAll(): void;
+    collapseAll(): void;
+    groupBy(property: string | ((item: IDataItem) => string)): void;
+    ungroup(): void;
+    showRow(rowId: Id): void;
+    hideRow(rowId: Id): void;
+    getCellRect(rowId: Id, colId: Id): ICellRect;
+    getSpan(rowId: Id, colId: Id): ISpan;
+    protected _adjustColumnsWidth({ rows, cols, totalCols, adjust, }: IAdjustColumns): IColumnsWidth;
+    protected _createCollection(prep: (data: any[]) => any[]): void;
+    protected _getRowIndex(rowId: Id): number;
+    protected _setEventHandlers(): void;
+    private _groupBy;
+    private _serialize;
+}

package/codebase/types/ts-treegrid/sources/TreeGridCollection.d.ts

@@ -0,0 +1,20 @@
+import { IEventSystem } from "../../ts-common/events";
+import { DataCallback, DataDriver, DataEvents, IDataItem, TreeCollection } from "../../ts-data";
+import { TreeGridEvents } from "./types";
+import { Id } from "../../ts-common/types";
+export declare class TreeGridCollection extends TreeCollection {
+    constructor(config?: any, events?: IEventSystem<DataEvents | TreeGridEvents>);
+    eachChild(id: Id, cb: any, direct?: boolean, checkItem?: (item: IDataItem) => boolean): void;
+    getMaxLevel(): number;
+    getLevel(id: Id): number;
+    serialize(driver?: DataDriver): any[];
+    getPlainIndex(id: Id): number;
+    map(cb: DataCallback<IDataItem>, parent?: Id, direct?: boolean): IDataItem[];
+    mapVisible(cb: DataCallback<IDataItem>, parent?: Id, direct?: boolean): IDataItem[];
+    protected _parse_data(data: any, parent?: Id): void;
+    protected _copy(id: Id, index: number, target?: TreeGridCollection, targetId?: Id, key?: number): Id;
+    protected _addToOrder(_order: any, obj: any, index: number): void;
+    protected _removeCore(id: Id): void;
+    protected _setParent(item: IDataItem, parent: Id): void;
+    private _checkItems;
+}

package/codebase/types/ts-treegrid/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 { TreeGridCollection } from "./TreeGridCollection";
+export { TreeGrid } from "./TreeGrid";
+export declare const i18n: any;

package/codebase/types/ts-treegrid/sources/entry_pro.d.ts

@@ -0,0 +1,2 @@
+export * from "./entry";
+export { dataDriversPro as dataDrivers } from "../../ts-data";

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

@@ -0,0 +1,32 @@
+import { DataEvents, DragEvents, IDataEventsHandlersMap, IDragEventsHandlersMap, IDataItem } from "../../ts-data";
+import { GridEvents, IEventHandlersMap, IGrid, IGridConfig } from "../../ts-grid";
+import { IEventSystem } from "../../ts-common/events";
+import { Id } from "../../ts-common/types";
+export interface ITreeGridConfig extends IGridConfig {
+    rootParent?: Id;
+    dragExpand?: boolean;
+    collapsed?: boolean;
+}
+export interface ITreeGrid extends IGrid {
+    events: IEventSystem<DataEvents | GridEvents | DragEvents | TreeGridEvents, IEventHandlersMap & IDataEventsHandlersMap & IDragEventsHandlersMap & ITreeEventHandlersMap>;
+    scrollTo(rowId: Id, colId: Id): void;
+    expand(rowId: Id): void;
+    collapse(rowId: Id): void;
+    expandAll(): void;
+    collapseAll(): void;
+    groupBy(property: string | ((item: IDataItem) => string)): void;
+    ungroup(): void;
+}
+export declare enum TreeGridEvents {
+    beforeCollapse = "beforeCollapse",
+    afterCollapse = "afterCollapse",
+    beforeExpand = "beforeExpand",
+    afterExpand = "afterExpand"
+}
+export interface ITreeEventHandlersMap {
+    [key: string]: (...args: any[]) => any;
+    [TreeGridEvents.beforeCollapse]: (rowId: Id) => boolean | void;
+    [TreeGridEvents.afterCollapse]: (rowId: Id) => any;
+    [TreeGridEvents.beforeExpand]: (rowId: Id) => boolean | void;
+    [TreeGridEvents.afterExpand]: (rowId: Id) => any;
+}

package/codebase/types/ts-treegrid/tests/Grid.d.ts

@@ -0,0 +1 @@
+export {};

package/codebase/types/ts-treegrid/tests/TreeGrid.d.ts

@@ -0,0 +1 @@
+export {};