mdt-client 1.0.26 → 1.0.29

package/types/components/dropdown/menuActionItem/dropdownMenuItemOptions.d.ts

@@ -1,7 +1,8 @@
+import { Icon } from "mdtScripts/components/icon/iconOptions";
 import { FormattedText } from "mdtScripts/helpers/formattedText";
 import { CSSClassName, ViewElement, Valued } from "mdtScripts/helpers/types";
 export interface DropdownMenuItemBaseOptions {
-    icon?: Valued<string>;
+    icon?: Valued<Icon>;
     title: Valued<string>;
     additionalTitle?: string;
     tooltip?: Valued<FormattedText>;

package/types/components/icon/icon.d.ts

@@ -0,0 +1,4 @@
+/// <reference types="mithril" />
+import { Icon, IconOptions } from "./iconOptions";
+export declare function icon(icon: Icon, options?: IconOptions): _mithril.MithrilVirtualElement;
+export declare function iconEl(icon: string, options?: IconOptions): HTMLElement;

package/types/components/tooltip/controllers/globalEventHandler.d.ts

@@ -0,0 +1,19 @@
+import { CursorPosition } from "./tooltipGenerator";
+import { FormattedText } from "mdtScripts/helpers/formattedText";
+declare class TooltipGlobalEventHandlerClass {
+    private targetEl;
+    private currentElement;
+    private tooltipGenerator;
+    private timeout;
+    private cursorPosition;
+    generateEvent(triggerElement: Element): void;
+    updateTooltipPosition(cursorPosition: CursorPosition): void;
+    clearTooltip(): void;
+    onElementClick(triggerElement: Element): void;
+    setTooltip(el: Element, content: FormattedText): void;
+    private dispatchEvent;
+    private removeTooltip;
+    private clearLinks;
+}
+export declare const TooltipGlobalEventHandler: TooltipGlobalEventHandlerClass;
+export {};

package/types/components/tooltip/controllers/tooltipGenerator.d.ts

@@ -0,0 +1,11 @@
+import { TooltipTarget } from "./tooltipTarget";
+export interface CursorPosition {
+    x: number;
+    y: number;
+}
+export declare class TooltipGenerator {
+    private tooltipEl;
+    renderTooltip(targetEl: TooltipTarget, cursorPosition: CursorPosition): void;
+    removeTooltip(): void;
+    private updatePosition;
+}

package/types/components/tooltip/controllers/tooltipPositionController.d.ts

@@ -0,0 +1,31 @@
+import { CursorPosition } from "./tooltipGenerator";
+export declare function setTooltipPosition(tooltipElement: HTMLElement, cursorPosition: CursorPosition, contextElement: Element, arrowEl?: HTMLElement): void;
+export declare function getTooltipXPos(cursorXPos: number, xPosByTarget: number, arrowOffset: number): number;
+interface TooltipConfig {
+    cursorOffset: number;
+}
+interface TooltipArrowConfig {
+    size: number;
+    tooltipBoundingOffset: number;
+}
+declare type TooltipArrowStyle = Partial<CSSStyleDeclaration>;
+export declare class TooltipPositionController {
+    private config;
+    arrowController: TooltipArrowPositionController;
+    constructor(config: TooltipConfig);
+    setArrowController(controller: TooltipArrowPositionController): void;
+    getTooltipOffset(): number;
+}
+export declare class TooltipArrowPositionController {
+    private arrowEl;
+    private config;
+    constructor(arrowEl: HTMLElement, config: TooltipArrowConfig);
+    isArrowExist(): boolean;
+    getArrowEl(): HTMLElement;
+    getTooltipOffsetByArrowSize(): number;
+    getArrowOffset(): number;
+    getArrowSize(): number;
+    getArrowXPos(cursorXPos: number, tooltipBlockXPos: number): number;
+    getArrowStyle(): TooltipArrowStyle;
+}
+export {};

package/types/components/tooltip/controllers/tooltipTarget.d.ts

@@ -0,0 +1,10 @@
+import { FormattedText } from "mdtScripts/helpers/formattedText";
+import { TooltipOptions } from "../tooltip";
+export declare class TooltipTarget {
+    private el;
+    private content;
+    constructor(el: Element, content: FormattedText);
+    getTooltipContentOptions(): TooltipOptions;
+    contains(element: Element): boolean;
+    getElement(): Element;
+}

package/types/components/tooltip/tooltip.d.ts

@@ -0,0 +1,9 @@
+import "./tooltip.less";
+export interface TooltipOptions {
+    textContent: string;
+    isMarkdown?: boolean;
+    showArrow?: boolean;
+}
+export declare function tooltipElement(options: TooltipOptions): HTMLElement;
+export declare function createElement(tagName: string, classList: string): HTMLElement;
+export declare function findArrowInTooltip(tooltipEl: HTMLElement): HTMLElement;

package/types/dm/scripts/CloneFormCtrl.d.ts

@@ -0,0 +1,12 @@
+import { DmFormCtrl } from "./DmFormCtrl";
+export declare class CloneFormCtrl extends DmFormCtrl {
+    private table;
+    private ids;
+    title: string;
+    single: boolean;
+    constructor(table: any, ids: any[]);
+    exec(confirm?: any): any;
+    copiedMessage(): string;
+    copyingMessage(): string;
+    initContainer(container: any): void;
+}

package/types/dm/scripts/DeleteFormCtrl.d.ts

@@ -0,0 +1,12 @@
+import { DmFormCtrl } from "./DmFormCtrl";
+export declare class DeleteFormCtrl extends DmFormCtrl {
+    private table;
+    private ids;
+    title: string;
+    single: boolean;
+    constructor(table: any, ids: any[]);
+    exec(confirm?: any): any;
+    deletedMessage(): string;
+    deletingMessage(): string;
+    initContainer(container: any): void;
+}

package/types/dm/scripts/DmFormCtrl.d.ts

@@ -0,0 +1,12 @@
+/// <reference types="mithril" />
+import { LinkedFieldActionCtrl } from "./LinkedFieldAction";
+export declare abstract class DmFormCtrl {
+    actions: LinkedFieldActionCtrl;
+    getActionsCtrl(): LinkedFieldActionCtrl;
+    getValue(): {
+        ID_ObjectField: any;
+        ID_Action: any;
+    }[];
+    abstract exec(confirm?: any): any;
+    execute(confirm?: any): _mithril.MithrilPromise<unknown>;
+}

package/types/dm/scripts/DmService.d.ts

@@ -0,0 +1,10 @@
+import { Record } from "_core/scripts/common/Record";
+export declare class DmService {
+    actions: Record[];
+    init(): void;
+    clone(table: any, ids: any, confirm: any, actions: any): any;
+    copy(data: any): any;
+    delete(table: any, ids: any, confirm: any, actions: any): any;
+    merge(table: any, primaryId: any, ids: any, confirm: any, actions: any): any;
+    getActions(): Record[];
+}

package/types/dm/scripts/DmTypes.d.ts

@@ -0,0 +1,15 @@
+import { Button } from "mdtScripts/views/form/controls/monacoEditor/jsonSchemas/Button.schema";
+export interface MergeListExtenderPublicOptions {
+    /**
+     * Скрыть кнопку объединения
+     */
+    hideMerge?: boolean;
+    /**
+     * Скрыть кнопку копирования
+     */
+    hideCopy?: boolean;
+    /**
+     * Кнопка копирования
+     */
+    copyButton?: Button;
+}

package/types/dm/scripts/LinkedFieldAction.d.ts

@@ -0,0 +1,33 @@
+import { Record } from "_core/scripts/common/Record";
+import { ListCtrl } from "_core/scripts/views/list/ListCtrl";
+export declare class LinkedFieldActionCtrl {
+    list: ListCtrl;
+    value: Record;
+    rows: Record[];
+    events: {
+        changed: any[];
+    };
+    constructor();
+    init(rows: Record[]): void;
+}
+export declare class LinkedFieldActionColumn {
+    ctrls: any;
+    events: {
+        changed: any[];
+    };
+    constructor();
+    get(row: any): any;
+}
+export declare class LinkedFieldMessageColumn {
+}
+export declare class LinkedFieldSelectActionCtrl {
+    row: any;
+    actions: any;
+    any: any;
+    events: {
+        changed: any[];
+    };
+    value: any;
+    constructor(row: any);
+    update(val: any): void;
+}

package/types/dm/scripts/MergeFormCtrl.d.ts

@@ -0,0 +1,13 @@
+import { FormCtrl } from "_core/scripts/views/form/form";
+import { Record } from "_core/scripts/common/Record";
+import { DmFormCtrl } from "./DmFormCtrl";
+export declare class MergeFormCtrl extends DmFormCtrl {
+    private table;
+    private ids;
+    title: string;
+    record: Record;
+    form: FormCtrl;
+    constructor(table: any, ids: any[]);
+    exec(confirm?: any): any;
+    initContainer(container: any): void;
+}

package/types/dm/scripts/MergeHelper.d.ts

@@ -0,0 +1,17 @@
+/// <reference types="mithril" />
+import { Table } from "_core/scripts/common/Table";
+import { FormCtrl } from "_core/scripts/views/form/form";
+import { Record } from "_core/scripts/common/Record";
+import { Query } from "_core/scripts/services/api/Query";
+export interface ICopyRowOptions {
+    formCreated?: (form: FormCtrl) => void;
+    formInited?: (form: FormCtrl) => void;
+    formSaved?: (form: FormCtrl) => void;
+    formFetch?: (query: Query) => void;
+    formExtConfigs?: any;
+    primaryButtonTitle?: string;
+    copyMethod?: (record: Record) => _mithril.MithrilPromise<any>;
+}
+export declare class MergeHelper {
+    static copyRow(table: Table, id: number, options: ICopyRowOptions): void;
+}

package/types/dm/scripts/MergeListExtender.d.ts

@@ -0,0 +1,25 @@
+import { ActionItem } from "mdtHelpers/ui/el";
+import { ListCtrl } from "_core/scripts/views/list/ListCtrl";
+import { MergeListExtenderPublicOptions } from "./DmTypes";
+export interface MergeListExtConfig {
+    merge?: MergeListExtenderOptions;
+}
+declare type CopyMode = "extended" | "simple";
+export interface MergeListExtenderOptions extends MergeListExtenderPublicOptions {
+    filter?: () => boolean;
+    enabled?: Function | boolean;
+    visible?: Function | boolean;
+    buttons?: Array<any>;
+    formExtConfig?: any;
+    /** Явное определение режима копирования */
+    copyMode?: CopyMode;
+    copyButton?: Partial<ActionItem>;
+}
+export declare class MergeListExtender {
+    list: ListCtrl;
+    private options;
+    constructor(list: ListCtrl, options: MergeListExtenderOptions);
+    mergeRows(rows: any): void;
+    cloneRows(rows: any): void;
+}
+export {};

package/types/dm/scripts/module.d.ts

@@ -0,0 +1,4 @@
+export declare enum CopyActionCodes {
+    skip = "S",
+    copy = "C"
+}

package/types/helpers/PositionCalculator.d.ts

@@ -0,0 +1,59 @@
+import { ComputePositionConfig } from "@floating-ui/core";
+interface FloatingElementOffset {
+    enabled: boolean;
+    size?: number;
+    mainAxisSize?: number;
+    crossAxisSize?: number;
+}
+interface FloatingElementShift {
+    enabled: boolean;
+    padding?: number;
+}
+interface FloatingElementFlip {
+    enabled: boolean;
+}
+interface FloatingElementArrow {
+    element: HTMLElement;
+}
+interface FloatingElementSize {
+    apply: (args: {
+        floating: DOMRect;
+        reference: DOMRect;
+    } & Pick<DOMRect, "height" | "width">) => void;
+    padding?: number;
+}
+interface ComputingBaseOptions {
+    offset?: FloatingElementOffset;
+    boundingShift?: FloatingElementShift;
+    flipElement?: FloatingElementFlip;
+    arrow?: FloatingElementArrow;
+    size?: FloatingElementSize;
+    placement?: "top" | "top-start" | "top-end" | "bottom" | "bottom-start" | "bottom-end" | "left" | "left-start" | "left-end" | "right" | "right-start" | "right-end";
+}
+declare type VirtualElementBoundingRect = () => Omit<DOMRect, "toJSON">;
+export interface ComputingOptionsWithVirtualElReference extends ComputingBaseOptions {
+    boundingClientRect: VirtualElementBoundingRect;
+    contextElement?: Element;
+}
+declare type ComputingOptionsWithCursorHTMLElReference = ComputingBaseOptions;
+interface ElementPosition {
+    x: number;
+    y: number;
+}
+interface FloatingElementPosition extends ElementPosition {
+    additionalElementsData?: FloatingElementAdditionalElement;
+}
+interface FloatingElementAdditionalElement {
+    arrow: ElementPosition;
+}
+export declare function computeElementPositionByElement(floatingEl: HTMLElement, referenceElement: Element, options: ComputingOptionsWithCursorHTMLElReference): Promise<FloatingElementPosition>;
+export declare function computeElementPositionByVirtualEl(floatingEl: HTMLElement, options: ComputingOptionsWithVirtualElReference): Promise<FloatingElementPosition>;
+export declare class FloatingUILibOptionsBuilder {
+    getLibOptions(options: ComputingBaseOptions): Partial<ComputePositionConfig>;
+    private appendFlipMiddleware;
+    private appendShiftMiddleware;
+    private appendOffsetMiddleware;
+    private appendArrowMiddleware;
+    private appendSizeMiddleware;
+}
+export {};

package/types/helpers/formattedText.d.ts

@@ -3,6 +3,7 @@ export declare type FormattedText = string | {
     text: string;
     type: FormattedTextType;
 };
-export declare function getTooltipAttributeByType(text: FormattedText): "data-tooltip" | "data-tooltip-md";
 export declare function getTextContent(text: FormattedText): string;
+export declare function getFormattedTextType(text: FormattedText): FormattedTextType;
+export declare function getTranslatedFormattedText(text: FormattedText, translateFn: (text: string) => string): FormattedText;
 export {};

package/types/helpers/types.d.ts

@@ -5,6 +5,7 @@ export interface AnyObject {
 export declare type MithrilStyleAttribute = {
     width?: CSSSizeUnit;
 } & AnyObject;
+export declare type MithrilContext<T = Record<string, unknown>> = T;
 declare type CSSSizeUnit = string;
 export declare type NotifierType = "log" | "error" | "warn" | "info" | "success";
 export interface NotifierOptions {
@@ -19,15 +20,21 @@ export declare type ViewElement = _mithril.MithrilVirtualElement | _mithril.Mith
 export declare type CommandEvent = Event | _mithril.MithrilEvent;
 export declare type CSSClassName = string;
 export declare type MithrilControl = ViewControl | ContentControl;
-interface ViewControl {
+export interface ViewControl {
     $view(): _mithril.MithrilVirtualElement | string;
+    [key: string]: any;
 }
-interface ContentControl {
+export interface ContentControl {
     content: any;
+    [key: string]: any;
 }
 export declare type Markdown = string;
 export declare type ColorStyle = "default" | "primary" | "success" | "info" | "warning" | "danger" | "fatal";
 export declare type ButtonStyle = ColorStyle;
 export declare type ObjectCode = string;
 export declare type Valued<T> = T | (() => T);
+export declare type Timeout = ReturnType<typeof setTimeout>;
+export declare type MithrilAttributes = _mithril.MithrilAttributes & {
+    [name: string]: any;
+};
 export {};

package/types/helpers/ui/setTooltip.d.ts

@@ -0,0 +1,12 @@
+import { FormattedText } from "../formattedText";
+import { MithrilContext } from "../types";
+export interface ComponentConfigParams {
+    el: HTMLElement;
+    inited: boolean;
+    ctx: MithrilContext<{
+        onTooltip: (e: Event) => void;
+    }>;
+}
+export declare type TooltipContent = (el: HTMLElement) => FormattedText;
+export declare function setTooltip(tooltipContent: TooltipContent, { el, inited, ctx }: ComponentConfigParams): void;
+export declare function isElementTextCropped(el: HTMLElement): boolean;

package/types/helpers/utils/classNames.d.ts

@@ -0,0 +1,2 @@
+export declare function classNames(...args: any[]): string;
+export declare function mClassNames(...args: any[]): string;

package/types/helpers/utils/object.d.ts

@@ -0,0 +1 @@
+export declare function hasOwnProperty(object: Record<never, unknown>, name: string): boolean;

package/types/helpers/utils/stringifyControlSize.d.ts

@@ -0,0 +1,3 @@
+import { ControlSize } from "mdtScripts/views/controls/Control";
+export declare type ComponentSize = "small" | "normal" | "large";
+export declare function stringifyControlSize(size: ControlSize): ComponentSize;

package/types/helpers/utils/v.d.ts

@@ -0,0 +1,2 @@
+import { Valued } from "../types";
+export declare function v<T>(prop: Valued<T>, ...args: any[]): T;

package/types/helpers/zone/IZone.d.ts

@@ -1,7 +1,6 @@
 /// <reference types="mithril" />
 import { MithrilControl } from "../types";
 export interface IZone {
-    getZone(): MithrilControl[];
     remove(content: MithrilControl): void;
     push(content: MithrilControl): void;
     render(): _mithril.MithrilVirtualElement[];

package/types/helpers/zone/Zones.d.ts

@@ -0,0 +1,2 @@
+export declare class Zones<T extends readonly string[]> {
+}

package/types/inline/scripts/CellList.d.ts

@@ -0,0 +1,14 @@
+export declare class CellList extends Array {
+    constructor();
+    events: {
+        added: any[];
+        removed: any[];
+        changed: any[];
+    };
+    private mixinProperties;
+    add(cell: any): boolean;
+    has(cell: any): boolean;
+    toggle(cell: any): boolean;
+    remove(cell: any): boolean;
+    clear(): void;
+}

package/types/inline/scripts/Editor.d.ts

@@ -0,0 +1,93 @@
+import { InlineListExtenderOptions } from "inline/scripts/ListExtender";
+import { ListCtrl } from "_core/scripts/views/list/ListCtrl";
+import { CellList } from "./CellList";
+import { Cell } from "./module";
+import { InlineObjectRulesValidator } from "./validation/inlineValidator";
+interface EditorEventTypes {
+    onGridClick: ({ event, cell }: {
+        event: any;
+        cell: any;
+    }) => void | false;
+    onGridDblClick: ({ event, cell }: {
+        event: any;
+        cell: any;
+    }) => void | false;
+    onEnterKeyup: (event: any) => void | false;
+    onEdit: () => void | false;
+}
+declare type EditorEvents = {
+    [P in keyof EditorEventTypes]?: EditorEventTypes[P][];
+};
+export declare class InlineEditor {
+    options: InlineListExtenderOptions;
+    selectedCells: CellList;
+    invalidCells: CellList;
+    editedCells: CellList;
+    deletedRows: any[];
+    addedRows: any[];
+    scrollToCell: Cell;
+    list: ListCtrl;
+    private toolbarUpdated;
+    private _edited;
+    private _activeCell;
+    private _copiedCell;
+    private _toolbarMore;
+    private buttonVisible;
+    private sending;
+    private toolbarItems;
+    events: EditorEvents;
+    objectRulesValidator: InlineObjectRulesValidator;
+    constructor(options?: any);
+    fullEdit: boolean;
+    private _editing;
+    set editing(value: boolean);
+    get editing(): boolean;
+    get activeCell(): Cell;
+    set activeCell(value: Cell);
+    get copiedCell(): Cell;
+    set copiedCell(value: Cell);
+    set edited(value: boolean);
+    get edited(): boolean;
+    isCellSelectable(cell: any): any;
+    isColumnModifiable(col: any): boolean | import("../../_core/scripts/common/Field").Field;
+    isCellModifiable(row: any, col: any): number;
+    isCellEditable(cell: any): boolean;
+    isCellDeletable(cell: any): number | false;
+    isRowDeletable(row: any): number;
+    addRowAvailable(): boolean;
+    addRow(): void;
+    edit(): boolean;
+    private canEdit;
+    isActiveCell(cell: Cell): boolean;
+    save(selected?: boolean): boolean;
+    cancel(): boolean;
+    rollback(makeSure?: boolean, onConfirmClose?: any): true | void;
+    validateEditedRows(): Promise<any>;
+    private runSend;
+    send(makeSure?: boolean): Promise<unknown>;
+    validate(): void;
+    validateRow(row: any): boolean;
+    getError(): any;
+    showError(): void;
+    showValidationErrors(errors: any): void;
+    reset(skipDeletedRows?: boolean): void;
+    forgetRow(row: any): void;
+    cleanCellEdit(cellToClean: Cell): void;
+    deleteRow(row: any): void;
+    restoreRow(row: any): void;
+    rollbackRow(row: any): void;
+    rollbackCell(cell: any): void;
+    update(): void;
+    updateState(): void;
+    getSelectedRows(): any[];
+    getEditedRows(): any[];
+    getNewRows(): any[];
+    selectCellsBetween(start: any, end: any, unselect?: any): CellList;
+    setValue(cell: any, value: any, value$?: any): boolean;
+    deleteValues(): void;
+    deleteValue(cell: Cell): void;
+    copyValue(from: Cell, to: Cell): void;
+    copy(): void;
+    paste(): boolean;
+}
+export {};

package/types/inline/scripts/ListExtender.d.ts

@@ -0,0 +1,41 @@
+import { ListCtrl } from "_core/scripts/views/list/ListCtrl";
+import { FKDropdownControlOptions } from "./easyInline/FKDropdown";
+import { InlineEditor } from "./Editor";
+import { InlineListExtenderPublicOptions } from "./ListExtenderTypes";
+export interface InlineListExt {
+    inline?: InlineListExtender;
+}
+export interface InlineListExtConfig {
+    inline?: InlineListExtenderOptions;
+}
+declare type InheritedPublicOptions = Omit<InlineListExtenderPublicOptions, "controlSettings"> & {
+    controlSettings?: {
+        [fieldCode: string]: FKDropdownControlOptions;
+    };
+};
+export interface InlineListExtenderOptions extends InheritedPublicOptions {
+    readonly?: () => boolean | boolean;
+    onchange?: (row: any, field: any, value: any) => void;
+    ondelete?: (row: any) => void;
+    onadded?: (row: any) => void;
+    events?: {
+        change?: any[];
+        updated?: any[];
+        controlCreating: any[];
+        controlCreated?: any[];
+        saving?: any[];
+        prepareEIAction?: ((data: any) => Promise<any>)[];
+    };
+    inForm?: boolean;
+}
+export declare class InlineListExtender {
+    list: ListCtrl;
+    options: InlineListExtenderOptions;
+    editor: InlineEditor;
+    cellTransformer: any;
+    constructor(list: ListCtrl, options?: InlineListExtenderOptions);
+    private prepareObjectRules;
+    enabled(): boolean;
+    fieldColumnLinkViewSetup(): void;
+}
+export {};

package/types/inline/scripts/ListExtenderTypes.d.ts

@@ -0,0 +1,29 @@
+import { ListPageExtOptions } from "mdtScripts/views/list/schema/ListPageExtOptions.schema";
+import { ListPageOptions } from "mdtScripts/views/list/schema/ListPageOptions.schema";
+import { Query } from "mdtServices/api/Query";
+export interface InlineListExtenderPublicOptions {
+    /** Использовать открытие формы при добавлении вместо добавления строки */
+    useStandardAdd?: boolean;
+    /** Включить режим упрощенного редактирования */
+    easyInline?: boolean;
+    /** Включить режим автоматического сохранения изменений при редактировании */
+    autoCommit?: boolean;
+    /** Настройка опций для FK-полей в режиме easyInline */
+    controlSettings?: {
+        [fieldCode: string]: FKDropdownControlPublicOptions;
+    };
+}
+export interface FKDropdownControlPublicOptions {
+    /**
+     * Настройки списка
+     */
+    listOptions?: ListPageOptions;
+    /**
+     * Настройки расширений списка
+     */
+    listExtenders?: ListPageExtOptions;
+    /**
+     * Настройка запроса к данным
+     */
+    queryOptions?: Query;
+}

package/types/inline/scripts/autocommit/autocommit.d.ts

@@ -0,0 +1,6 @@
+import { Cell } from "../module";
+import { InlineEditor } from "../Editor";
+export declare class InlineAutoCommitHelper {
+    static applyAutoCommit(editor: InlineEditor, cell: Cell, value: any): Promise<any>;
+    static isAvailable(editor: InlineEditor, cell: Cell): boolean;
+}

package/types/inline/scripts/before.d.ts

@@ -0,0 +1,10 @@
+export declare const inline: {
+    isSameCells: (a: any, b: any) => boolean;
+    isSameTypeCells: (a: any, b: any) => boolean;
+    ListTransformer: any;
+    RowTransformer: any;
+    CellTransformer: any;
+    messages: any;
+    initMessages: any;
+    initUiBindings: any;
+};