@dhtmlx/vault 5.0.6

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

@@ -0,0 +1,17 @@
+import { IAnyObj, Id } from "../../ts-common/types";
+import { DataProxy } from "./dataproxy";
+import { IFilterCallback, IFilterMode, IDataCollection, IDataItem, ITreeCollection, DataDriver, IDataDriver, IFilter } from "./types";
+export declare function isEqualObj(a: any, b: any): boolean;
+export declare function naturalCompare(a: any, b: any): any;
+export declare function findByConf(item: IDataItem, conf: IFilterMode | IFilterCallback, index?: number, array?: IDataItem[]): IDataItem;
+export declare function isDebug(): boolean;
+export declare function dhxWarning(msg: string): void;
+export declare function dhxError(msg: string): void;
+export declare function toProxy(proxy: any): DataProxy;
+export declare function toDataDriver(driver: DataDriver | IDataDriver): IDataDriver;
+export declare function copyWithoutInner(obj: IAnyObj, forbidden?: IAnyObj): IAnyObj;
+export declare function isTreeCollection(obj: IDataCollection<any> | ITreeCollection<any> | IDataItem[]): obj is ITreeCollection<any>;
+export declare function hasJsonOrArrayStructure(str: any): boolean;
+export declare function isOnlyPermanentFilters(filters: IFilter): boolean;
+export declare function throwMoveWarning(id: Id, exists?: boolean): null;
+export declare function splitCsv(csv: string, delimiter: string): string[];

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

@@ -0,0 +1,9 @@
+import { DataProxy } from "./dataproxy";
+import { ILazyConfig, ILazyDataProxy } from "./types";
+export declare class LazyDataProxy extends DataProxy implements ILazyDataProxy {
+    config: ILazyConfig;
+    private _timeout;
+    private _cooling;
+    constructor(url: string, config?: any);
+    load<T = string>(): Promise<T>;
+}

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

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

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

@@ -0,0 +1,17 @@
+import { IEventSystem } from "../../ts-common/events";
+import { SelectionEvents, ISelection, ISelectionConfig, Id } from "../../ts-common/types";
+import { DataCollection } from "./datacollection";
+export declare class Selection implements ISelection {
+    events: IEventSystem<SelectionEvents>;
+    config: ISelectionConfig;
+    private _selected;
+    private _data;
+    constructor(config: ISelectionConfig, data: DataCollection, events?: IEventSystem<any>);
+    getId(): Id;
+    getItem(): any;
+    remove(id?: Id): boolean;
+    add(id: Id): void;
+    enable(): void;
+    disable(): void;
+    private _addSingle;
+}

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

@@ -0,0 +1,2 @@
+import { IAnyObj } from "../../../ts-common/types";
+export declare function jsonToXML(data: IAnyObj[], root?: string): string;

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

@@ -0,0 +1,72 @@
+import { IEventSystem } from "../../ts-common/events";
+import { DataCollection } from "./datacollection";
+import { DataCallback, DataEvents, IDataCollection, IDataItem, ITreeCollection, IFilterCallback, IFilterMode, IFilterComplexMode, ITreeFilterConfig, DataDriver, ISortMode, IDataDriver, IUpdateObject, ISortConfig } from "./types";
+import { Id } from "../../ts-common/types";
+export declare function addToOrder(store: any, obj: object, parent: Id, index: number): void;
+export declare class TreeCollection<T extends IDataItem = IDataItem> extends DataCollection<T> implements ITreeCollection<T> {
+    protected _children: {
+        [id: string]: T[];
+    };
+    protected _root: Id;
+    protected _initChildren: {
+        [id: string]: T[];
+    };
+    constructor(config?: any, events?: IEventSystem<DataEvents>);
+    add(newItem: IDataItem, index?: number, parent?: Id): Id;
+    add(newItem: IDataItem[], index?: number, parent?: Id): Id[];
+    getRoot(): Id;
+    getParent(id: Id, asObj?: boolean): Id;
+    getItems(id: Id): T[];
+    getLength(id?: Id): number;
+    removeAll(id?: Id): void;
+    update(id: Id, newItem: IUpdateObject, silent?: boolean): void;
+    getIndex(id: Id): number;
+    sort(rule?: ISortMode, config?: ISortConfig, ignore?: boolean): void;
+    filter(rule?: IFilterMode | IFilterComplexMode | 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[];
+    move(id: Id, index: number, target?: ITreeCollection | IDataCollection, targetId?: Id): Id;
+    move(id: Id[], index: number, target?: ITreeCollection | IDataCollection, targetId?: Id): Id[];
+    forEach(callback: DataCallback<any>, parent?: Id, level?: number): void;
+    eachChild(id: Id, callback: DataCallback<T>, direct?: boolean, checkItem?: (item: IDataItem) => boolean): void;
+    getNearId(id: Id): Id;
+    loadItems(id: Id, driver?: IDataDriver | DataDriver): void;
+    refreshItems(id: Id, driver?: IDataDriver | DataDriver): void;
+    eachParent(id: Id, callback: DataCallback<T>, self?: boolean): void;
+    haveItems(id: Id): boolean;
+    canCopy(id: Id, target: Id): boolean;
+    serialize(driver?: DataDriver, checkItem?: (item: any) => any): any;
+    getId(index: number, parent?: Id): Id;
+    map(callback: DataCallback<T>, parent?: Id, direct?: boolean): any[];
+    getRawData(from: number, to: number, order?: T[], mode?: number, parent?: Id): T[];
+    protected flatten(input: T[]): T[];
+    protected _add({ newItem, index, parent, order, batch, }: {
+        newItem: IDataItem;
+        batch: IDataItem[];
+        index: number;
+        parent: Id;
+        order?: number;
+    }): Id;
+    protected _setParent(item: IDataItem, parent: Id): void;
+    protected _copy(id: Id, index: number, target?: IDataCollection | ITreeCollection, targetId?: Id, key?: number): Id;
+    protected _move(id: Id, index: number, target?: ITreeCollection | IDataCollection, targetId?: Id, key?: number): Id;
+    protected _moveItem(id: any, targetId: any, index: any): void;
+    protected _reset(config: {
+        id?: Id;
+        grouping: any;
+    }): void;
+    protected _removeCore(id: Id): void;
+    private _removeFromParentList;
+    private _removeChildren;
+    private _removeFromOrders;
+    protected _addToOrder(_order: any, obj: any, index: number): void;
+    protected _parse_data(data: any, parent?: Id): void;
+    protected _parseItem(item: any): void;
+    private _recursiveFilter;
+    private _serialize;
+    private _applyFilter;
+    protected _normalizeFilters(filters: any): any;
+    protected _checkFilterRule(rule: IFilterMode | IFilterComplexMode | IFilterCallback): boolean;
+    protected _applySorters(): void;
+}

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-dataview/index.d.ts

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

package/codebase/types/ts-dataview/sources/DataView.d.ts

@@ -0,0 +1,41 @@
+import { VNode } from "../../ts-common/dom";
+import { List } from "../../ts-list";
+import { Id, IHandlers } from "../../ts-common/types";
+import { IDataViewConfig, IDataView } from "./types";
+export declare class DataView extends List implements IDataView {
+    config: IDataViewConfig;
+    constructor(node: HTMLElement | string, config?: IDataViewConfig);
+    scrollTo(id: Id): void;
+    protected _scrollTo(id: Id, el: HTMLElement): void;
+    protected _didRedraw(vm: any): void;
+    protected _renderItem(item: any, index: number): VNode;
+    protected _renderList(): VNode;
+    protected _getHotkeys(): IHandlers;
+    protected getDataViewItemAriaAttrs(context: this, item: any): {
+        "aria-roledescription": string;
+        "aria-grabbed": string;
+        role: string;
+        "aria-selected": string;
+    } | {
+        "aria-roledescription"?: undefined;
+        "aria-grabbed": string;
+        role: string;
+        "aria-selected": string;
+    } | {
+        "aria-roledescription": string;
+        "aria-grabbed"?: undefined;
+        role: string;
+        "aria-selected": string;
+    } | {
+        "aria-roledescription"?: undefined;
+        "aria-grabbed"?: undefined;
+        role: string;
+        "aria-selected": string;
+    };
+    protected getDataViewAriaAttrs(config: any, itemsCount: any, rowsCount: any, itemsInRow: any): {
+        role: string;
+        "aria-label": string;
+        "aria-multiselectable": string;
+        "aria-readonly": string;
+    };
+}

package/codebase/types/ts-dataview/sources/ProDataView.d.ts

@@ -0,0 +1,11 @@
+import { ScrollView } from "../../ts-common/ScrollView";
+import { IProDataView, IDataViewConfig } from "./types";
+import { DataView } from "./DataView";
+import { VNode } from "../../ts-common/dom";
+export declare class ProDataView extends DataView implements IProDataView {
+    scrollView: ScrollView;
+    constructor(node: HTMLElement | string, config?: IDataViewConfig);
+    destructor(): void;
+    scrollTo(id: string): void;
+    protected _renderList(): VNode;
+}

package/codebase/types/ts-dataview/sources/editors/InputEditor.d.ts

@@ -0,0 +1,16 @@
+import { IDataViewConfig, IDataViewItem } from "../types";
+import { DataView } from "../DataView";
+export declare class InputEditor {
+    protected _handlers: {
+        [key: string]: (...args: any[]) => void;
+    };
+    protected _mode: boolean;
+    protected _config: IDataViewConfig;
+    protected _dataView: DataView;
+    protected _item: IDataViewItem;
+    protected _input: HTMLInputElement;
+    constructor(item: IDataViewItem, dataView: DataView);
+    endEdit(): void;
+    toHTML(isLastItemInRow: boolean): any;
+    protected _initHandlers(): void;
+}

package/codebase/types/ts-dataview/sources/editors/editors.d.ts

@@ -0,0 +1,4 @@
+import { InputEditor } from "./InputEditor";
+import { DataView } from "../DataView";
+import { IDataViewItem } from "../types";
+export declare function getEditor(item: IDataViewItem, dataView: DataView): InputEditor;

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

@@ -0,0 +1,63 @@
+import { DataCollection, DataEvents, DragEvents, IDataEventsHandlersMap, IDataItem, IDragEventsHandlersMap } from "../../ts-data";
+import { IEventSystem } from "../../ts-common/events";
+import { ISelection, MultiselectionMode, IListConfig, IListEventHandlersMap, ListEvents } from "../../ts-list";
+import { ScrollView } from "../../ts-common/ScrollView";
+import { Id } from "../../ts-common/types";
+export interface IDataViewConfig extends IListConfig {
+    data?: DataCollection<any> | any[];
+    itemsInRow?: number;
+    height?: number | string;
+    itemHeight?: number | string;
+    gap?: number;
+    template?: (item: any) => string;
+    keyNavigation?: boolean | (() => boolean);
+    css?: string;
+    selection?: boolean;
+    multiselection?: boolean | MultiselectionMode;
+    editable?: boolean;
+    eventHandlers?: {
+        [eventName: string]: {
+            [className: string]: (event: Event, id: Id) => void | boolean;
+        };
+    };
+    /** @deprecated See a documentation: https://docs.dhtmlx.com/ */
+    editing?: boolean;
+    /** @deprecated See a documentation: https://docs.dhtmlx.com/ */
+    multiselectionMode?: MultiselectionMode;
+}
+export interface IDataView<T extends IDataItem = any> {
+    config: IDataViewConfig;
+    data: DataCollection<T>;
+    events: IEventSystem<DataEvents | DragEvents | ListEvents, IDataEventsHandlersMap & IDragEventsHandlersMap & IListEventHandlersMap>;
+    selection: ISelection;
+    paint(): void;
+    destructor(): void;
+    editItem(id: Id): void;
+    getFocusItem(): T;
+    setFocus(id: Id): void;
+    resetFocus(): void;
+    getFocus(): Id;
+    /** @deprecated See a documentation: https://docs.dhtmlx.com/ */
+    disableSelection(): void;
+    /** @deprecated See a documentation: https://docs.dhtmlx.com/ */
+    enableSelection(): void;
+}
+export interface IProDataView extends IDataView {
+    scrollView: ScrollView;
+}
+export declare enum DataViewEvents {
+    click = "click",
+    doubleClick = "doubleclick",
+    focusChange = "focuschange",
+    beforeEditStart = "beforeEditStart",
+    afterEditStart = "afterEditStart",
+    beforeEditEnd = "beforeEditEnd",
+    afterEditEnd = "afterEditEnd",
+    itemRightClick = "itemRightClick",
+    itemMouseOver = "itemMouseOver",
+    /** @deprecated See a documentation: https://docs.dhtmlx.com/ */
+    contextmenu = "contextmenu"
+}
+export interface IDataViewItem {
+    [key: string]: any;
+}

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): IDataItem[] | IRow[];
+    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;
+}