mdt-client 1.0.26 → 1.0.29

package/types/_core/scripts/views/containers/containerMixin.d.ts

@@ -0,0 +1,79 @@
+/// <reference types="mithril" />
+import { MessageCtrl } from "../../common/controls/Message";
+import { Button } from "../../helpers/ui/el";
+interface CloseMixinOptions {
+    expanded?: any;
+    events?: any;
+}
+export declare abstract class CloseMixin {
+    options: any;
+    beforeUnload: any;
+    close: (x?: any, options?: {
+        showWarning?: boolean;
+        preventConfirm?: boolean;
+    }) => boolean;
+    events: {
+        close: any[];
+        closed: any[];
+    };
+    constructor(options: CloseMixinOptions);
+    then(fn: any, closeOptions?: CloseOptions): this;
+    private saveCallbackOnContainerChange;
+    private saveOnContainerChangeFlag;
+    getSavedCallbacks(): {
+        closed: any[];
+    };
+}
+interface CloseOptions {
+    /** Колбэк не должен вызваться, если меняется контейнер (из модального в сайдбар и наоборот) */
+    shouldRemoveOnContainerChange: boolean;
+}
+export declare const ctrlList: any[];
+export interface ContainerMixinOptions extends CloseMixinOptions {
+    title?: _mithril.MithrilProperty<string>;
+    tabTitle?: _mithril.MithrilProperty<string>;
+    code?: _mithril.MithrilProperty<string>;
+    routeWarn?: boolean;
+    buttons?: Button[];
+    icon?: string;
+    cssClass?: string;
+    containerCommands?: Button[];
+    initContainer?: (container: ContainerMixin) => void;
+}
+export interface ContainerContent {
+    title?: _mithril.MithrilProperty<string>;
+    tabTitle?: _mithril.MithrilProperty<string>;
+    code?: _mithril.MithrilProperty<string>;
+    initContainer?: (c: ContainerMixin, o?: ContainerMixinOptions) => any;
+    icon?: _mithril.MithrilProperty<string>;
+}
+export declare abstract class ContainerMixin extends CloseMixin {
+    content: ContainerContent;
+    options: ContainerMixinOptions;
+    $attrs: _mithril.MithrilAttributes;
+    buttons: Button[];
+    extendedBtns: Button[];
+    title: _mithril.MithrilPromiseProperty<any> & {
+        onchange: (v?: any) => any;
+    };
+    tabTitle: any;
+    code: _mithril.MithrilPromiseProperty<any> & {
+        onchange: (v?: any) => any;
+    };
+    subtitle: _mithril.MithrilPromiseProperty<any> & {
+        onchange: (v?: any) => any;
+    };
+    message: MessageCtrl;
+    moreBtn: Button;
+    icon: _mithril.MithrilPromiseProperty<any> & {
+        onchange: (v?: any) => any;
+    };
+    moreBtnVisible: boolean;
+    abstract initContainer(t: any): void;
+    constructor(content: ContainerContent, options?: ContainerMixinOptions);
+    hasButtons(): boolean;
+    getCommands: (isExtended?: any) => Button[];
+    registerCommandsSource(callback: (isExtended?: boolean) => Button[]): void;
+    getMoreButton(extendedBtns: Button[]): Button;
+}
+export {};

package/types/_core/scripts/views/containers/modal.d.ts

@@ -0,0 +1,67 @@
+import { ContainerContent, ContainerMixin, ContainerMixinOptions } from "./containerMixin";
+declare type onResizeCallback = (data: ModalSizingState) => void;
+export interface ModalSizingState {
+    full: boolean;
+    width: number;
+    height: number;
+}
+export interface ModalOptions extends ContainerMixinOptions {
+    class?: any;
+    initContainer?: any;
+    size?: "lg" | "sm" | "md";
+    css?: any;
+    title?: any;
+    icon?: any;
+    type?: any;
+    backdrop?: boolean;
+    closeOnBackdrop?: boolean;
+    initialSizingState?: ModalSizingState;
+    onResize?: onResizeCallback;
+}
+export declare enum ModalTypeIcon {
+    primary = 0,
+    danger = "skull",
+    warning = "exclamation-square",
+    success = "check",
+    info = "info-square"
+}
+export declare class ModalCtrl extends ContainerMixin {
+    ctrl: ContainerContent;
+    options: ModalOptions;
+    type: any;
+    $prevActiveElement: any;
+    hideMainButtons: boolean;
+    constructor(ctrl: ContainerContent, options: ModalOptions);
+    initContainer(): void;
+    closeOnRouteChange(): void;
+    getIcon(): any;
+    getButtonType(button: any): any;
+    closeOnBackdrop(): boolean;
+    initContainerCommands(): void;
+    static baseSettings: {
+        [key: string]: ModalOptions;
+    };
+}
+export declare class Draggable {
+    private el;
+    constructor(el: any, container: any);
+    stop: () => void;
+    startMoving(el: any, container: any, e: any): void;
+    stopMoving(el: any): void;
+    move(el: any, x: any, y: any): void;
+}
+interface ResizableOptions {
+    bottomLimit?: () => number;
+    onResize?: onResizeCallback;
+}
+export declare class Resizable {
+    private options?;
+    elsData: {
+        element: HTMLElement;
+        startWidth?: number;
+        startHeight?: number;
+    }[];
+    constructor(resizeEl: HTMLElement | HTMLElement[], triggerEl: any, options?: ResizableOptions);
+    initDrag(e: any): void;
+}
+export {};

package/types/_core/scripts/views/containers/popover.d.ts

@@ -0,0 +1,24 @@
+import { UIAnimateOptions, UIAnimateFadeParams, UIAnimateSlideParams } from "../../helpers/ui/animate";
+import { DOMPosition } from "../../helpers/ui/dom";
+import { ContainerMixin, ContainerMixinOptions } from "./containerMixin";
+export interface PopoverCtrlAnimateOptions {
+    name: "slide" | "fade";
+    params?: UIAnimateFadeParams | UIAnimateSlideParams;
+    options?: UIAnimateOptions;
+}
+export interface PopoverCtrlOptions extends ContainerMixinOptions {
+    placement?: "left" | "top" | "right" | "bottom";
+    position?: DOMPosition;
+    class?: string;
+    icon?: string;
+    animate?: {
+        show: PopoverCtrlAnimateOptions;
+        hide: PopoverCtrlAnimateOptions;
+        options?: UIAnimateOptions;
+    };
+}
+export declare class PopoverCtrl extends ContainerMixin {
+    options: PopoverCtrlOptions;
+    constructor(ctrl: any, options: PopoverCtrlOptions);
+    initContainer(): void;
+}

package/types/_core/scripts/views/containers/side.d.ts

@@ -0,0 +1,16 @@
+import { ContainerMixin, ContainerMixinOptions } from "./containerMixin";
+import { Panel } from "../form/controls";
+export interface SideOptions extends ContainerMixinOptions {
+    hideCloseButton?: boolean;
+    expanded?: boolean;
+}
+export declare class SideCtrl extends ContainerMixin {
+    state: any;
+    key: string;
+    hideMainButtons: boolean;
+    hideCloseButton: boolean;
+    hideEmptyToolbar: boolean;
+    constructor(content: any, options?: SideOptions);
+    initContainerCommands(panel: Panel): void;
+    initContainer(): void;
+}

package/types/_core/scripts/views/controls/Alert.d.ts

@@ -0,0 +1,18 @@
+import { Notification } from "../../services/NotificationService";
+export interface AlertOptions {
+    duration?: number;
+}
+export declare class AlertCtrl {
+    msg: Notification;
+    static DURATION: {
+        SHORT: number;
+        MEDIUM: number;
+        LONG: number;
+    };
+    events: {
+        removed: any[];
+    };
+    options: AlertOptions;
+    constructor(msg: Notification, options?: AlertOptions);
+    remove(): void;
+}

package/types/_core/scripts/views/controls/ContextMenu.d.ts

@@ -0,0 +1,24 @@
+/// <reference types="mithril" />
+import { ActionItem } from "../../helpers/ui/el";
+export interface ContextMenuOptions {
+    enabled: (e?: any, ctrl?: ContextMenu) => boolean;
+    onContextMenu: (e?: any, ctrl?: ContextMenu) => void;
+}
+export declare class ContextMenu {
+    items: ActionItem[];
+    options: ContextMenuOptions;
+    position: {
+        x: number;
+        y: number;
+    };
+    events: {
+        show: any[];
+        hide: any[];
+    };
+    constructor(items?: ActionItem[], options?: ContextMenuOptions);
+    private onContextMenu;
+    attach(obj: _mithril.MithrilVirtualElement): void;
+    attachNode(node: any): void;
+    show(x: any, y: any): void;
+    hide(): void;
+}

package/types/_core/scripts/views/controls/Control.d.ts

@@ -0,0 +1,7 @@
+export declare type Control = {};
+export declare enum ControlSize {
+    ExtraSmall = 1,
+    Small = 2,
+    Normal = 3,
+    Large = 4
+}

package/types/_core/scripts/views/controls/DropdownMenu.d.ts

@@ -0,0 +1,86 @@
+import { ActionItem, Button } from "../../helpers/ui/el";
+import { ViewElement } from "mdtScripts/helpers/types";
+import { Record } from "mdtScripts/common/Record";
+declare type Placement = "left" | "top" | "right" | "bottom";
+declare type Position = "left" | "right";
+interface Options {
+    position?: Position;
+    placement?: Placement;
+}
+interface DDFocusElement {
+    $focusEl?: HTMLOrSVGElement;
+}
+export interface DropdownMenuCtrlOptions {
+    placement?: Placement;
+    position?: Position;
+    focusReturn?: boolean;
+    autoselect?: boolean;
+    hShift?: number;
+    class?: string;
+    translate?: boolean;
+    events?: {
+        show?: ((ctrl?: DropdownMenuCtrl, el?: HTMLElement, ctx?: any) => any)[];
+        positioned?: ((ctrl?: DropdownMenuCtrl, el?: HTMLElement) => any)[];
+        close?: ((item?: ActionItem, ctrl?: DropdownMenuCtrl) => any)[];
+    };
+    captureClickOnClose?: boolean;
+    closeParentOnSelect?: boolean;
+    $attrs?: any;
+    backdrop?: boolean;
+    resizable?: boolean;
+    /**
+     * @default 16
+     */
+    outerPadding?: number;
+}
+interface DropdownMenuEvents {
+    show: ((ctrl?: DropdownMenuCtrl, el?: HTMLElement, ctx?: any) => void)[];
+    positioned: ((ctrl?: DropdownMenuCtrl, el?: HTMLElement) => void)[];
+    close: ((r?: false | Button, ctrl?: DropdownMenuCtrl) => void)[];
+}
+export declare type DropdownMenuItem = Button & DDFocusElement & {
+    additionalText?: string;
+    zone?: {
+        right: () => ViewElement;
+    };
+    row?: Record;
+};
+export declare class DropdownMenuCtrl {
+    static divider: ActionItem;
+    static readonly code = "dropdown-code";
+    private _idx;
+    items: DropdownMenuItem[];
+    $viewState: DropdownView;
+    isShown: boolean;
+    dirty: boolean;
+    events: DropdownMenuEvents;
+    static shown: DropdownMenuCtrl[];
+    options: DropdownMenuCtrlOptions;
+    parent: DropdownMenuCtrl;
+    $ignoreFirstCloseOnClick?: boolean;
+    stateElements: any[];
+    constructor(options?: DropdownMenuCtrlOptions, parent?: DropdownMenuCtrl);
+    idx(v?: any): number;
+    private _move;
+    move(up?: boolean): any;
+    resetSelect(): void;
+    active(): false | DropdownMenuItem;
+    show(items?: ActionItem[], replace?: boolean): void;
+    closeChildren(): void;
+    close(r?: any): void;
+    then(fn: any): this;
+    select(r: any): void;
+    closeOnRouteChange(): void;
+    hasIcon(index: any): boolean;
+}
+export interface DropdownView {
+    target: any;
+}
+interface Rect {
+    x?: number;
+    y?: number;
+    w?: number;
+    h?: number;
+}
+export declare function reposite(win: Rect, target: Rect, dropdown: Rect, options: Options): Rect;
+export {};

package/types/_core/scripts/views/controls/DropdownMenuService.d.ts

@@ -0,0 +1,5 @@
+import { DropdownMenuOptions } from "mdtScripts/components/dropdown/menu/dropdownMenu";
+import { ViewElement } from "mdtScripts/helpers/types";
+import { DropdownMenuItem } from "./DropdownMenu";
+export declare type DropdownMenuItemView = (item: DropdownMenuItem, index: number) => ViewElement;
+export declare function getDropdownMenuContentOptions(items: DropdownMenuItem[], itemView: DropdownMenuItemView): DropdownMenuOptions;

package/types/_core/scripts/views/controls/JsonViewControl.d.ts

@@ -0,0 +1,16 @@
+import ObjectViewControl from "./ObjectFormatControl";
+interface JsonViewControlOptions {
+    toggleMode?: boolean;
+    formattedMode?: boolean;
+}
+export default class JsonViewControl {
+    source?: string;
+    objectFormat: ObjectViewControl;
+    formattedValue: string;
+    error: "";
+    options: JsonViewControlOptions;
+    constructor(source?: string, options?: JsonViewControlOptions);
+    setData(source: string): void;
+    changeMode: () => void;
+}
+export {};

package/types/_core/scripts/views/controls/JsonViewFieldControl.d.ts

@@ -0,0 +1,11 @@
+import { FieldCtrl } from "../form/field";
+import JsonViewControl from "./JsonViewControl";
+export declare type JsonViewFieldCtrlOptions = {};
+export default class JsonFormatFieldCtrl {
+    options: JsonViewFieldCtrlOptions;
+    fieldCtrl: FieldCtrl;
+    content: JsonViewControl;
+    hasReadonly: boolean;
+    constructor(options: JsonViewFieldCtrlOptions, fieldCtrl: FieldCtrl);
+    private parseSourceToString;
+}

package/types/_core/scripts/views/controls/MessageText.d.ts

@@ -0,0 +1,4 @@
+export declare class MessageTextCtrl {
+    content: any;
+    constructor(content: any);
+}

package/types/_core/scripts/views/controls/NotifiationsCtrl.d.ts

@@ -0,0 +1,8 @@
+import { NotificationService } from "../../services/NotificationService";
+import { ContainerMixin } from "../containers/containerMixin";
+export declare class NotificationsCtrl {
+    service: NotificationService;
+    container: ContainerMixin;
+    initContainer(container: ContainerMixin): void;
+    constructor();
+}

package/types/_core/scripts/views/controls/ObjectFormatControl.d.ts

@@ -0,0 +1,5 @@
+export default class ObjectFormatControl {
+    data: any;
+    constructor(data?: any);
+    setData(data: any): void;
+}

package/types/_core/scripts/views/controls/Reorder.d.ts

@@ -0,0 +1,25 @@
+import { LayoutCtrl } from "../form/Layout";
+export declare class Reorder<T> {
+    getList: (T: any) => T[];
+    options: {
+        container?: any;
+        layout?: LayoutCtrl;
+    };
+    events: {
+        started: any[];
+        moved: any[];
+        ended: any[];
+    };
+    progress: {
+        item: any;
+        list: T[];
+    };
+    constructor(getList: (T: any) => T[], options?: {
+        container?: any;
+        layout?: LayoutCtrl;
+    });
+    start(item: any): void;
+    insert(ctrl?: Reorder<T>, index?: any): void;
+    move(target: any, after?: boolean, ctrl?: Reorder<T>): void;
+    end(): void;
+}

package/types/_core/scripts/views/controls/ReorderView.d.ts

@@ -0,0 +1,22 @@
+/// <reference types="mithril" />
+import { Reorder } from "./Reorder";
+export declare class ReorderView {
+    static reorders: Reorder<any>[];
+    static VERTICAL_AFTER_LIMIT: number;
+    static transformContainer(ctrl: Reorder<any>, container: _mithril.MithrilVirtualElement): void;
+    static transformItem(ctrl: Reorder<any>, item: any, itemEl: _mithril.MithrilVirtualElement): _mithril.MithrilVirtualElement;
+    static addReorder(reorder: Reorder<any>): void;
+    static removeReorder(reorder: Reorder<any>): void;
+    static addUiBindings(): void;
+    static removeUiBindings(): void;
+    static progress: any;
+    static lastEl: {
+        lastHoverEl: any;
+        lastContainerEl: any;
+    };
+    static selectEl(e: any, className: string, lastElName: string, getEl: Function): void;
+    static selectTargetContainer(e: any): void;
+    static mousedown(e: any): void;
+    static mousemove(e: any): void;
+    static mouseup(): void;
+}

package/types/_core/scripts/views/controls/Resizer.d.ts

@@ -0,0 +1,32 @@
+export interface ResizerOptions {
+    minSizes?: any;
+    maxSizes?: any;
+    unit?: string;
+    force?: boolean;
+    direction?: string;
+    handleStyle?: string;
+    handlePosition?: string;
+    itemsIndependent?: boolean;
+}
+export interface ResizingInfo {
+    index: number;
+    startSize: number;
+    containerSize: number;
+}
+export declare class Resizer {
+    value: (index: number, size?: number) => any;
+    inited: boolean;
+    resizing: ResizingInfo;
+    options: ResizerOptions;
+    events: {
+        resizeStarted: any[];
+        resizeProgress: any[];
+        resized: any[];
+    };
+    constructor(value: (index: number, size?: number) => any, options?: ResizerOptions);
+    getSize(index: number): any;
+    setSize(index: number, size: number): any;
+    start(index: number, containerSize: number): void;
+    resize(diffPx: number): void;
+    end(): void;
+}

package/types/_core/scripts/views/controls/ResizerView.d.ts

@@ -0,0 +1,8 @@
+/// <reference types="mithril" />
+import { Resizer } from "./Resizer";
+export declare class ResizerView {
+    static inited: boolean;
+    static transformContainer(ctrl: Resizer, container: _mithril.MithrilVirtualElement): _mithril.MithrilVirtualElement;
+    static transformItem(ctrl: Resizer, item: _mithril.MithrilVirtualElement, index: number, length: number): _mithril.MithrilVirtualElement[];
+    static init(): void;
+}

package/types/_core/scripts/views/controls/SplitBlock.d.ts

@@ -0,0 +1,21 @@
+import { Resizer } from "./Resizer";
+import { SplitBlockSection } from "./SplitBlockSection";
+export interface SplitBlockOptions {
+    saveState?: boolean;
+    storageKey?: string;
+    events?: any;
+}
+export declare class SplitBlockCtrl {
+    sections: SplitBlockSection[];
+    options: SplitBlockOptions;
+    inited: boolean;
+    events: {
+        created: any[];
+    };
+    resizer: Resizer;
+    constructor(sections: SplitBlockSection[], options?: SplitBlockOptions);
+    get storageKey(): string;
+    get pageStorageKey(): string;
+    saveState(): void;
+    loadState(): void;
+}

package/types/_core/scripts/views/controls/SplitBlockSection.d.ts

@@ -0,0 +1,27 @@
+import { Animator } from "../Animator";
+export interface SplitBlockSectionOptions {
+    class?: string;
+    size?: number;
+    collapsible?: boolean;
+    visible?: () => boolean;
+}
+export declare class SplitBlockSection {
+    control: any;
+    events: {
+        updated: any[];
+        collapsed: any[];
+    };
+    collapsed: boolean;
+    unpinned: boolean;
+    collapsing: boolean;
+    scrollX: number;
+    scrollY: number;
+    class: string;
+    size: number;
+    collapsible: boolean;
+    uncollapsing: boolean;
+    animator: Animator;
+    visible: () => boolean;
+    constructor(control: any, options?: SplitBlockSectionOptions);
+    toggleCollapsed(): void;
+}

package/types/_core/scripts/views/controls/UserProfile.d.ts

@@ -0,0 +1,19 @@
+import { SchemaManager } from "../../services/SchemaManager";
+import { SecurityManager } from "../../services/SecurityManager";
+export declare class UserProfile {
+    private key;
+    theme(name?: any): any;
+    private setTheme;
+}
+export declare class UserProfileCtrl {
+    schema: SchemaManager;
+    sec: SecurityManager;
+    profile: UserProfile;
+    title: string;
+    form: any;
+    content: any;
+    record: any;
+    currentData: any;
+    constructor();
+    initContainer(container: any): void;
+}

package/types/_core/scripts/views/controls/panels/Panel.d.ts

@@ -0,0 +1,59 @@
+import { Animator } from "../../Animator";
+import { Button } from "mdtScripts/helpers/ui/el";
+export interface PanelOptions {
+    pinned?: boolean;
+    focused?: boolean;
+    minimized?: boolean;
+    maximized?: boolean;
+    closable?: boolean;
+    minimizable?: boolean;
+    actionsEnabled?: boolean;
+    control?: any;
+    useAnimations?: boolean;
+    unminimizeAction?: any;
+}
+export declare class Panel implements PanelOptions {
+    control: any;
+    actionsEnabled: any;
+    wasPinned: any;
+    minimizing: any;
+    unminimizing: any;
+    maximizing: any;
+    unmaximizing: any;
+    adding: any;
+    wasMinimized: any;
+    closing: any;
+    useAnimations: any;
+    animator: Animator;
+    events: {
+        update: any[];
+        closing: any[];
+        close: any[];
+    };
+    unminimizeAction: null;
+    _pinned: any;
+    private _focused;
+    private _animating;
+    _minimized: any;
+    _maximized: any;
+    set pinned(value: any);
+    get pinned(): any;
+    set focused(value: any);
+    get focused(): any;
+    set minimized(value: any);
+    get minimized(): any;
+    set maximized(value: any);
+    get maximized(): any;
+    constructor(options: PanelOptions);
+    beforeUnload(): boolean;
+    close(makeSure?: boolean): boolean;
+    isMaximized: () => boolean;
+    pin(force?: boolean): void;
+    maximize(force?: boolean): void;
+    minimize(force?: boolean): void;
+    getManageCommands(): {
+        minimize: (extend: Button) => Button;
+        maximize: (extend: Button) => Button;
+        pin: (extend: Button) => Button;
+    };
+}

package/types/_core/scripts/views/controls/panels/PanelContainer.d.ts

@@ -0,0 +1,34 @@
+import { Resizer } from "../Resizer";
+import { Panel } from "./Panel";
+export interface PanelContainerOptions {
+    class?: string;
+    storageKey?: string;
+    maxPinnedPanels?: number;
+}
+export interface PanelContainerAddOptions {
+    animate?: boolean;
+}
+export declare class PanelContainer {
+    options: PanelContainerOptions;
+    list: Panel[];
+    isPinned: (p: Panel) => boolean;
+    isUnpinned: (p: Panel) => any;
+    sizes: {
+        pinned: number;
+        unpinned: number;
+    };
+    resizerValue: (filter: any, index: any, size?: any) => any;
+    resizers: {
+        pinned: Resizer;
+        unpinned: Resizer;
+    };
+    constructor(options?: PanelContainerOptions);
+    add(panel: Panel, options?: PanelContainerAddOptions): void;
+    remove(panel: Panel): void;
+    update(options?: any): void;
+    beforeUnload(): boolean;
+    _onPanelPin(panel: any): void;
+    getStorageKey(): string;
+    saveState(): void;
+    loadState(): void;
+}