dhx-chart 8.2.3 → 8.2.5

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

@@ -0,0 +1,161 @@
+import { Id } from "../../ts-common/types";
+type textAlign = "left" | "center" | "right";
+type textVerticalAlign = "top" | "center" | "bottom";
+type strokeType = "line" | "dash" | any;
+type arrows = "filled" | any;
+type connectType = "straight" | "curved" | "elbow";
+type fontStyle = "normal" | "italic" | "oblique";
+export { SelectionEvents } from "../../ts-common/types";
+export interface IItemConfig {
+    id?: Id;
+    type?: string;
+    parent?: string;
+    img?: string;
+    x?: number;
+    y?: number;
+    dx?: number;
+    dy?: number;
+    height?: number;
+    width?: number;
+    angle?: number;
+    text?: string;
+    title?: string;
+    css?: string;
+    color?: string;
+    hidden?: boolean;
+    from?: string;
+    to?: string;
+    points?: ICoords[];
+    fill?: string;
+    stroke?: string;
+    extraLinesStroke?: string;
+    strokeWidth?: number;
+    strokeType?: strokeType;
+    strokeDash?: string;
+    fontColor?: string;
+    fontStyle?: fontStyle;
+    fontWeight?: string;
+    fontSize?: number;
+    textAlign?: textAlign;
+    textVerticalAlign?: textVerticalAlign;
+    lineHeight?: number;
+    open?: boolean;
+    dir?: string;
+    $count?: number;
+    $kids?: any[];
+    $selected?: boolean;
+    $expandColor?: string;
+    $parent?: string;
+    $shape?: IShape;
+    $move?: boolean;
+    $connectMode?: boolean;
+}
+export interface IButtonConfig {
+    content: any;
+    check?: any;
+    id: Id;
+    css?: any;
+}
+export interface IDiagramConfig {
+    toolbar?: IButtonConfig[];
+    type?: string;
+    select?: boolean;
+    defaultShapeType?: string;
+    defaultLinkType?: string;
+    scale?: number;
+    scroll?: boolean;
+    dragMode?: boolean;
+    showGrid?: boolean;
+    gridStep?: number;
+    margin?: {
+        x?: number;
+        y?: number;
+        itemX?: number;
+        itemY?: number;
+    };
+    lineGap?: number;
+    $svg?: any;
+}
+export interface IBoxSize {
+    left: number;
+    right: number;
+    top: number;
+    bottom: number;
+}
+export interface IShape {
+    config: IItemConfig;
+    id: Id;
+    move(x: number, y: number): any;
+    resize(width: number, height: number): any;
+    rotate(angle: number): any;
+    update(config: IItemConfig): any;
+    getPoint(x: number, y: number): ICoords;
+    toSVG(): string;
+    getCenter(): ICoords;
+    setCss(value: string): any;
+    getMetaInfo(): any[];
+    isConnector(): boolean;
+    getBox(): IBoxSize;
+    canResize(): boolean;
+}
+export interface ICoords {
+    x: number;
+    y: number;
+    side?: string;
+    $custom?: boolean;
+}
+export interface ILinkConfig extends IItemConfig {
+    id?: string;
+    from: string;
+    to: string;
+    type?: strokeType;
+    arrow?: string;
+    backArrow?: arrows;
+    forwardArrow?: arrows;
+    fromSide?: string;
+    toSide?: string;
+    cornersRadius?: number;
+    points?: ICoords[];
+    connectType?: connectType;
+    $selected?: boolean;
+    $move?: boolean;
+    $selectedPoint?: string;
+}
+export type FilterHandler = (item: IItemConfig) => boolean;
+export interface IDiagram {
+    config: IDiagramConfig;
+    collapseItem(id: string): any;
+    expandItem(id: string): any;
+    paint(): any;
+    getScrollState(): ICoords;
+    scrollTo(x: number, y: number): any;
+    showItem(id: string): any;
+}
+export interface IContent {
+    shapes?: string;
+    width?: number;
+    height?: number;
+    minX?: number;
+    minY?: number;
+    gap?: number;
+    container?: any;
+    root?: string;
+    scroll?: any;
+}
+export type SelectShape = (item: IItemConfig) => boolean;
+export type ActionShape = (item: IItemConfig) => void;
+export declare enum DiagramEvents {
+    scroll = "scroll",
+    beforeCollapse = "beforecollapse",
+    afterCollapse = "aftercollapse",
+    beforeExpand = "beforeexpand",
+    afterExpand = "afterexpand",
+    shapeMouseDown = "shapemousedown",
+    shapeClick = "shapeclick",
+    shapedDblClick = "shapedblclick",
+    shapeIconClick = "shapeiconclick",
+    beforeRender = "beforerender",
+    shapeHover = "shapeHover",
+    emptyAreaClick = "emptyAreaClick",
+    load = "load"
+}

package/codebase/types/ts-diagram/tests/stubs.d.ts

@@ -0,0 +1,25 @@
+export declare const diagramWithImgData: ({
+    id: string;
+    text: string;
+    title: string;
+    img: string;
+    from?: undefined;
+    to?: undefined;
+    type?: undefined;
+} | {
+    id: string;
+    text: string;
+    img: string;
+    title?: undefined;
+    from?: undefined;
+    to?: undefined;
+    type?: undefined;
+} | {
+    id: string;
+    from: string;
+    to: string;
+    type: string;
+    text?: undefined;
+    title?: undefined;
+    img?: undefined;
+})[];

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

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

package/codebase/types/ts-form/sources/Form.d.ts

@@ -0,0 +1,55 @@
+import { IEventSystem } from "../../ts-common/events";
+import { View } from "../../ts-common/view";
+import { Layout, ILayoutConfig, ICellConfig } from "../../ts-layout";
+import { IAnyObj } from "../../ts-common/types";
+import { FormEvents, IItemConfig, IFormEventHandlersMap, IForm, ClearMethod, IFormConfig, TFormDataCallback, TProps } from "./types";
+export declare class Form extends View implements IForm {
+    config: IFormConfig;
+    events: IEventSystem<FormEvents, IFormEventHandlersMap>;
+    layout: Layout;
+    private _isValid;
+    protected _attachments: {
+        [name: string]: any;
+    };
+    protected _state: {
+        [key: string]: any;
+    };
+    private container;
+    constructor(container: HTMLElement | string, config: IFormConfig);
+    paint(): void;
+    send(url: string, method?: string, asFormData?: boolean): Promise<any> | void;
+    clear(method?: ClearMethod): void;
+    setValue(obj: IAnyObj): void;
+    getValue<T extends boolean = false>(asFormData?: boolean): T extends true ? FormData : IAnyObj;
+    getItem(name: string): any;
+    validate(silent?: boolean): boolean;
+    setProperties(arg: string | {
+        [name: string]: TProps;
+    }, props?: TProps): void;
+    getProperties(name?: string): {
+        [name: string]: TProps;
+    } | TProps;
+    show(): void;
+    hide(init?: boolean): void;
+    setFocus(name: string): void;
+    blur(name: string): void;
+    isVisible(name?: string): boolean;
+    disable(): void;
+    enable(): void;
+    isDisabled(name?: string): boolean;
+    forEach(callback: TFormDataCallback): void;
+    destructor(): void;
+    getRootView(): any;
+    protected _addLayoutItem(item: IItemConfig): ICellConfig;
+    protected _initItemHandlers(item: IItemConfig, name: string): void;
+    protected _changeProps(name: any, props: any): void;
+    private _addLayoutItems;
+    private _checkLayoutConfig;
+    protected _createLayoutConfig(config: IFormConfig, layoutConfig: ILayoutConfig): void;
+    protected _initUI(container: HTMLElement | string): void;
+    private _clear;
+    private _clearValidate;
+    private _formContainerShow;
+    private _formContainerHide;
+    private _send;
+}

package/codebase/types/ts-form/sources/ProForm.d.ts

@@ -0,0 +1,7 @@
+import { Form } from "./Form";
+import { IFormConfig, IItemConfig } from "./types";
+export declare class ProForm extends Form {
+    constructor(container: HTMLElement | string, config: IFormConfig);
+    protected _initItemHandlers(item: IItemConfig, name: string): void;
+    protected _initUI(container: HTMLElement | string): void;
+}

package/codebase/types/ts-form/sources/elements/ToggleButton.d.ts

@@ -0,0 +1,77 @@
+import { IBaseLayoutItem, IBaseItem, IBaseState, IBaseHandlersMap, ItemEvent } from "../types";
+import { View } from "../../../ts-common/view";
+import { IFieldset } from "./fieldset";
+import { IEventSystem } from "../../../ts-common/events";
+export type IToggleValue = number | string;
+export interface IToggleButtonProps extends IBaseLayoutItem {
+    full?: boolean;
+    text?: string;
+    icon?: string;
+    offText?: string;
+    offIcon?: string;
+    value?: IToggleValue;
+}
+export interface IToggleButtonConfig extends IBaseItem, IBaseState, IToggleButtonProps {
+    type: "toggle";
+    selected?: boolean;
+    $group?: boolean;
+    $gap?: number;
+    $extraCss?: string;
+}
+export interface IToggleButton {
+    parent?: IFieldset;
+    config: IToggleButtonConfig;
+    events: IEventSystem<ItemEvent, IToggleButtonHandlersMap>;
+    setValue(selected: boolean, silent?: boolean): void;
+    getValue(): IToggleValue | boolean;
+    isSelected(): boolean;
+    show(): void;
+    hide(init?: boolean): void;
+    isVisible(): boolean;
+    focus(): void;
+    blur(): void;
+    disable(): void;
+    enable(): void;
+    isDisabled(): boolean;
+    setProperties(config: IToggleButtonProps): void;
+    getProperties(): IToggleButtonProps;
+    destructor(): void;
+    paint(): void;
+}
+export interface IToggleButtonHandlersMap extends IBaseHandlersMap {
+    [ItemEvent.beforeChange]: (value: IToggleValue | boolean) => boolean | void;
+    [ItemEvent.change]: (value: IToggleValue | boolean) => void;
+    [ItemEvent.focus]: (value: IToggleValue | boolean) => void;
+    [ItemEvent.blur]: (value: IToggleValue | boolean) => void;
+    [ItemEvent.keydown]: (event: KeyboardEvent) => void;
+    [ItemEvent.beforeHide]: (value: IToggleValue | boolean, init: boolean) => boolean | void;
+    [ItemEvent.beforeShow]: (value: IToggleValue | boolean) => boolean | void;
+    [ItemEvent.afterHide]: (value: IToggleValue | boolean, init: boolean) => void;
+    [ItemEvent.afterShow]: (value: IToggleValue | boolean) => void;
+    [ItemEvent.beforeChangeProperties]: (config: IToggleButtonProps) => boolean | void;
+    [ItemEvent.afterChangeProperties]: (config: IToggleButtonProps) => void;
+}
+export declare class ToggleButton extends View implements IToggleButton {
+    parent?: IFieldset;
+    config: IToggleButtonConfig;
+    events: IEventSystem<ItemEvent, IToggleButtonHandlersMap>;
+    private props;
+    private handlers;
+    constructor(container: HTMLElement | string | null, config: IToggleButtonConfig);
+    setValue(selected?: boolean, silent?: boolean): void;
+    getValue(): IToggleValue | boolean;
+    isSelected(): boolean;
+    show(): void;
+    hide(init?: boolean): void;
+    isVisible(): boolean;
+    focus(): void;
+    blur(): void;
+    disable(): void;
+    enable(): void;
+    isDisabled(): boolean;
+    setProperties(config: IToggleButtonProps): void;
+    getProperties(): IToggleButtonProps;
+    destructor(): void;
+    protected draw(): any;
+    private initHandlers;
+}

package/codebase/types/ts-form/sources/elements/ToggleGroup.d.ts

@@ -0,0 +1,95 @@
+import { IBaseItem, IBaseState, IBaseLayoutItem, IBaseHandlersMap, ItemEvent } from "../types";
+import { IToggleButtonConfig, IToggleValue, IToggleButtonProps } from "./ToggleButton";
+import { View } from "../../../ts-common/view";
+import { IFieldset } from "./fieldset";
+import { IEventSystem } from "../../../ts-common/events";
+export interface IToggleGroupValue {
+    [id: string]: IToggleValue | boolean;
+}
+export interface IToggleGroupProps extends IBaseLayoutItem {
+    options?: IToggleButtonConfig[];
+    full?: boolean;
+    gap?: number;
+    multiselection?: boolean;
+}
+export interface IToggleGroupConfig extends IBaseItem, IBaseState, IToggleGroupProps {
+    type: "togglegroup";
+    options: IToggleButtonConfig[];
+    value?: IToggleGroupValue;
+}
+export interface IToggleGroup {
+    parent?: IFieldset;
+    config: IToggleGroupConfig;
+    events: IEventSystem<ItemEvent, IToggleGroupHandlersMap>;
+    setValue(value: IToggleGroupValue): void | boolean;
+    getValue(): IToggleGroupValue;
+    getValue(id: string): IToggleValue | boolean;
+    getValue(id?: string): IToggleGroupValue | IToggleValue | boolean;
+    isSelected(): {
+        [id: string]: boolean;
+    };
+    isSelected(id: string): boolean;
+    isSelected(id?: string): boolean | {
+        [id: string]: boolean;
+    };
+    show(id?: string): void;
+    hide(id?: string, init?: boolean): void;
+    isVisible(id?: string): boolean;
+    focus(id?: string): void;
+    blur(): void;
+    disable(id?: string): void;
+    enable(id?: string): void;
+    isDisabled(id?: string): boolean;
+    setProperties(config: IToggleGroupProps): void;
+    setProperties(config: IToggleButtonProps, id: string): void;
+    setProperties(config: IToggleGroupProps | IToggleButtonProps, id?: string): void;
+    getProperties(): IToggleGroupProps;
+    getProperties(id: string): IToggleButtonProps;
+    getProperties(id?: string): IToggleGroupProps | IToggleButtonProps;
+    destructor(): void;
+}
+export interface IToggleGroupHandlersMap extends IBaseHandlersMap {
+    [ItemEvent.beforeChange]: (value: IToggleGroupValue) => boolean | void;
+    [ItemEvent.change]: (value: IToggleGroupValue) => void;
+    [ItemEvent.focus]: (value: IToggleGroupValue, id: string) => void;
+    [ItemEvent.blur]: (value: IToggleGroupValue, id: string) => void;
+    [ItemEvent.keydown]: (event: KeyboardEvent, id: string) => void;
+    [ItemEvent.beforeHide]: (value: IToggleGroupValue, id?: string, init?: boolean) => boolean | void;
+    [ItemEvent.beforeShow]: (value: IToggleGroupValue, id?: string) => boolean | void;
+    [ItemEvent.afterHide]: (value: IToggleGroupValue, id?: string, init?: boolean) => void;
+    [ItemEvent.afterShow]: (value: IToggleGroupValue, id?: string) => void;
+    [ItemEvent.beforeChangeProperties]: (config: IToggleGroupProps | IToggleButtonProps, id?: string) => boolean | void;
+    [ItemEvent.afterChangeProperties]: (config: IToggleGroupProps | IToggleButtonProps, id?: string) => void;
+}
+export declare class ToggleGroup extends View implements IToggleGroup {
+    parent?: IFieldset;
+    config: IToggleGroupConfig;
+    events: IEventSystem<ItemEvent, IToggleGroupHandlersMap>;
+    private items;
+    private props;
+    constructor(container: HTMLElement | string | null, config: IToggleGroupConfig);
+    setValue(value: IToggleGroupValue): void | boolean;
+    getValue(): IToggleGroupValue;
+    getValue(id: string): IToggleValue | boolean;
+    isSelected(): {
+        [id: string]: boolean;
+    };
+    isSelected(id: string): boolean;
+    show(id?: string): void;
+    hide(id?: string, init?: boolean): void;
+    isVisible(id?: string): boolean;
+    focus(id?: string): void;
+    blur(): void;
+    disable(id?: string): void;
+    enable(id?: string): void;
+    isDisabled(id?: string): boolean;
+    setProperties(config: IToggleGroupProps): void;
+    setProperties(config: IToggleButtonProps, id: string): void;
+    getProperties(): IToggleGroupProps;
+    getProperties(id: string): IToggleButtonProps;
+    destructor(): void;
+    private initView;
+    private initHandlers;
+    private draw;
+    private checkVisibleOrder;
+}

package/codebase/types/ts-form/sources/elements/avatar.d.ts

@@ -0,0 +1,119 @@
+import { VNode } from "../../../ts-common/dom";
+import { IHandlers } from "../../../ts-common/types";
+import { IEventSystem } from "../../../ts-common/events";
+import { Label } from "./helper/label";
+import { ItemEvent, IBaseHandlersMap, IBaseItem, IBaseState, IBaseLayoutItem, ILabel, IMessage } from "../types";
+import { FileStatus, IParams } from "./simplevault";
+import { IFieldset } from "./fieldset";
+export interface IUploadValue {
+    id?: string;
+    file?: File;
+    src?: string;
+    path?: string;
+    status?: FileStatus;
+    progress?: number;
+    request?: XMLHttpRequest;
+}
+export interface IAvatarProps extends IBaseLayoutItem, ILabel, IMessage {
+    validation?: (value: IUploadValue) => boolean;
+    readOnly?: boolean;
+    removeIcon?: boolean;
+    size?: "small" | "medium" | "large" | number;
+    circle?: boolean;
+    alt?: string;
+    icon?: string;
+    placeholder?: string;
+    preview?: string;
+    accept?: string;
+    target?: string;
+    fieldName?: string;
+    autosend?: boolean;
+    params?: IParams;
+    headerParams?: IParams;
+    updateFromResponse?: boolean;
+}
+export interface IAvatarConfig extends IBaseItem, IBaseState, IAvatarProps {
+    type: "avatar";
+    value?: IUploadValue;
+}
+export interface IAvatar {
+    parent?: IFieldset;
+    config: IAvatarConfig;
+    events: IEventSystem<ItemEvent, IAvatarEventHandlersMap>;
+    send(params?: IParams): void;
+    selectFile(): void;
+    setValue(value: IUploadValue): void;
+    getValue(): IUploadValue;
+    clear(): void;
+    disable(): void;
+    enable(): void;
+    isDisabled(): boolean;
+    show(): void;
+    hide(init?: boolean): void;
+    isVisible(): boolean;
+    validate(silent?: boolean, validateValue?: IUploadValue): boolean;
+    clearValidate(): void;
+    setProperties(propertyConfig: IAvatarProps): void;
+    getProperties(): IAvatarProps;
+    focus(): void;
+    blur(): void;
+    destructor(): void;
+}
+export interface IAvatarEventHandlersMap extends IBaseHandlersMap {
+    [ItemEvent.beforeChange]: (value: IUploadValue) => boolean | void;
+    [ItemEvent.change]: (value: IUploadValue) => void;
+    [ItemEvent.beforeHide]: (value: IUploadValue, init: boolean) => boolean | void;
+    [ItemEvent.beforeShow]: (value: IUploadValue) => boolean | void;
+    [ItemEvent.afterHide]: (value: IUploadValue, init: boolean) => void;
+    [ItemEvent.afterShow]: (value: IUploadValue) => void;
+    [ItemEvent.beforeValidate]: (value: IUploadValue) => boolean | void;
+    [ItemEvent.afterValidate]: (value: IUploadValue, isValidate: boolean) => void;
+    [ItemEvent.beforeUploadFile]: (value: IUploadValue) => boolean | void;
+    [ItemEvent.uploadBegin]: (value: IUploadValue) => void;
+    [ItemEvent.uploadProgress]: (progress: number, value: IUploadValue) => void;
+    [ItemEvent.uploadComplete]: (value: IUploadValue) => void;
+    [ItemEvent.uploadFail]: (value: IUploadValue) => void;
+    [ItemEvent.uploadFile]: (value: IUploadValue, extra?: {
+        [key: string]: string;
+    }) => void;
+    [ItemEvent.beforeChangeProperties]: (properties: IAvatarProps) => boolean | void;
+    [ItemEvent.afterChangeProperties]: (properties: IAvatarProps) => void;
+}
+export declare class Avatar extends Label implements IAvatar {
+    parent: IFieldset;
+    config: IAvatarConfig;
+    events: IEventSystem<ItemEvent, IAvatarEventHandlersMap>;
+    protected _handlers: IHandlers;
+    protected _propsItem: string[];
+    protected _props: string[];
+    private _isUpload;
+    private _dragover;
+    private _dragoverTimeout;
+    constructor(container: null | string | HTMLElement, config: IAvatarConfig);
+    send(params?: IParams): void;
+    selectFile(): void;
+    setValue(value: IUploadValue): void;
+    private _setValue;
+    getValue(): IUploadValue;
+    clear(): void;
+    disable(): void;
+    enable(): void;
+    isDisabled(): boolean;
+    show(): void;
+    hide(init?: boolean): void;
+    isVisible(): boolean;
+    validate(silent?: boolean, value?: IUploadValue): boolean;
+    clearValidate(): void;
+    setProperties(propertyConfig: IAvatarProps): void;
+    getProperties(): IAvatarProps;
+    focus(): void;
+    blur(): void;
+    destructor(): void;
+    protected _initView(config: IAvatarConfig): void;
+    protected _initHandlers(): void;
+    protected _draw(): VNode;
+    private _drawImage;
+    private _drawPreview;
+    private _drawCover;
+    private _createFormData;
+}

package/codebase/types/ts-form/sources/elements/button.d.ts

@@ -0,0 +1,70 @@
+import { View } from "../../../ts-common/view";
+import { ItemEvent, IBaseLayoutItem, IBaseItem, IBaseState, IBaseHandlersMap } from "../types";
+import { IEventSystem } from "../../../ts-common/events";
+import { IFieldset } from "./fieldset";
+export interface IButtonProps extends IBaseLayoutItem {
+    submit?: boolean;
+    url?: string;
+    text?: string;
+    icon?: string;
+    view?: "flat" | "link";
+    size?: "small" | "medium";
+    color?: "danger" | "secondary" | "primary" | "success";
+    full?: boolean;
+    circle?: boolean;
+    loading?: boolean;
+}
+export interface IButtonConfig extends IButtonProps, IBaseItem, IBaseState {
+    type: "button";
+    /** @deprecated See a documentation: https://docs.dhtmlx.com/ */
+    value?: string;
+}
+export interface IButton {
+    parent?: IFieldset;
+    config: IButtonConfig;
+    events: IEventSystem<ItemEvent, IButtonHandlersMap>;
+    destructor(): void;
+    show(): void;
+    hide(init?: boolean): void;
+    isVisible(): boolean;
+    disable(): void;
+    enable(): void;
+    isDisabled(): boolean;
+    setProperties(propertyConfig: IButtonProps): void;
+    getProperties(): IButtonProps;
+    focus(): void;
+    blur(): void;
+}
+export interface IButtonHandlersMap extends IBaseHandlersMap {
+    [ItemEvent.click]: (events: Event) => void;
+    [ItemEvent.focus]: (text: string) => void;
+    [ItemEvent.blur]: (text: string) => void;
+    [ItemEvent.keydown]: (event: KeyboardEvent) => void;
+    [ItemEvent.beforeHide]: (text: string, init: boolean) => boolean | void;
+    [ItemEvent.beforeShow]: (text: string) => boolean | void;
+    [ItemEvent.afterHide]: (text: string, init: boolean) => void;
+    [ItemEvent.afterShow]: (text: string) => void;
+    [ItemEvent.beforeChangeProperties]: (properties: IButtonProps) => boolean | void;
+    [ItemEvent.afterChangeProperties]: (properties: IButtonProps) => void;
+}
+export declare class Button extends View implements IButton {
+    parent: IFieldset;
+    config: IButtonConfig;
+    events: IEventSystem<ItemEvent, IButtonHandlersMap>;
+    private _handlers;
+    private _propsItem;
+    private _props;
+    constructor(container: HTMLElement | string | null, config: any);
+    destructor(): void;
+    setProperties(propertyConfig: IButtonProps): void;
+    getProperties(): IButtonProps;
+    show(): void;
+    hide(init?: boolean): void;
+    isVisible(): boolean;
+    disable(): void;
+    enable(): void;
+    isDisabled(): boolean;
+    focus(): void;
+    blur(): void;
+    protected _draw(): any;
+}