mdt-client 1.0.26 → 1.0.29

package/types/_core/scripts/services/SortingManager.d.ts

@@ -0,0 +1,13 @@
+export declare class SortingManager {
+    list: any[];
+    private events;
+    constructor(list?: any[]);
+    add(path: string, asc?: boolean): void;
+    get(path: string): any;
+    remove(path: string): void;
+    set(list: any): void;
+    clear(): void;
+    static getPath(sorting: any): any;
+    static has(sortingList: any, sorting: any): any;
+    static add(sortingList: any, sorting: any): void;
+}

package/types/_core/scripts/services/TableRefresher/TableRefresher.d.ts

@@ -0,0 +1,15 @@
+import { Table } from "mdtScripts/common/Table";
+import { SchemaManager } from "../SchemaManager";
+export interface RefreshableTableComponent {
+    getTable(): Table;
+    refreshTable(table: Table): void;
+}
+export declare class TableRefresherImpl {
+    private components;
+    private schema;
+    init(schema: SchemaManager): void;
+    addComponent(component: RefreshableTableComponent): void;
+    removeComponent(component: RefreshableTableComponent): void;
+    private updateComponentTable;
+}
+export declare const TableRefresher: TableRefresherImpl;

package/types/_core/scripts/services/TableRefresher/TableRefresherFormAdapter.d.ts

@@ -0,0 +1,9 @@
+import { Table } from "mdtScripts/common/Table";
+import { FormCtrl } from "mdtScripts/views/form/form";
+import { RefreshableTableComponent } from "./TableRefresher";
+export declare class TableRefresherFormAdapter implements RefreshableTableComponent {
+    private form;
+    constructor(form: FormCtrl);
+    getTable(): Table;
+    refreshTable(table: Table): void;
+}

package/types/_core/scripts/services/TableRefresher/TableRefresherListAdapter.d.ts

@@ -0,0 +1,9 @@
+import { Table } from "mdtScripts/common/Table";
+import { ListCtrl } from "mdtScripts/views/list/ListCtrl";
+import { RefreshableTableComponent } from "./TableRefresher";
+export declare class TableRefresherListAdapter implements RefreshableTableComponent {
+    private list;
+    constructor(list: ListCtrl);
+    getTable(): Table;
+    refreshTable(table: Table): void;
+}

package/types/_core/scripts/services/Validator.d.ts

@@ -0,0 +1,10 @@
+import { Field } from "../common/Field";
+import { Table } from "../common/Table";
+import { FieldType } from "./SchemaManager";
+import { FormStateError } from "../views/form/FormState";
+export declare class Validator {
+    static validateBySuperType(value: any, type: FieldType): "Value must be a number" | "Value must be a date" | "No value" | "Incorrect time format";
+    record(record: any, table: Table): any[];
+    msg(message: any, field: Field, showErrorMessage?: any): FormStateError[];
+    field(field: Field, value: any, onupdate?: any, record?: {}): FormStateError[];
+}

package/types/_core/scripts/services/api/ApiAccessor.d.ts

@@ -0,0 +1,11 @@
+/// <reference types="mithril" />
+import { ApiRequestOptions } from "./ApiRequestOptions";
+export interface IApiAccessor {
+    request<T>(url: string, data?: any, options?: ApiRequestOptions): _mithril.MithrilPromise<T>;
+}
+export declare class ApiAccessor implements IApiAccessor {
+    apiUrl: string;
+    static getApiUrl(): string;
+    url(url: string, params?: unknown): string;
+    request<T>(url: string, data?: any, options?: ApiRequestOptions): _mithril.MithrilPromise<T>;
+}

package/types/_core/scripts/services/api/ApiRequestOptions.d.ts

@@ -0,0 +1,27 @@
+export interface ApiRequest {
+    abort?: () => void;
+}
+export interface ApiRequestOptions {
+    req?: (x?: any) => ApiRequest;
+    onerror?: (e: any) => boolean | void;
+    onRequestError?: () => void;
+    camel?: boolean;
+    multi?: boolean;
+    method?: string;
+    xhrConfig?(xhr: XMLHttpRequest): void;
+    background?: boolean;
+    ignoreUnwrapError?: boolean;
+    withCredentials?: boolean;
+    url?: string;
+    user?: string;
+    password?: string;
+    data?: any;
+    unwrapSuccess?(data: any): any;
+    unwrapError?(data: any, options?: any): any;
+    serialize?(dataToSerialize: any): string;
+    deserialize?(dataToDeserialize: string): any;
+    extract?(xhr: XMLHttpRequest, options: ApiRequestOptions): string;
+    type?(data: Object): void;
+    config?(xhr: XMLHttpRequest, options?: ApiRequestOptions): XMLHttpRequest;
+    dataType?: string;
+}

package/types/_core/scripts/services/api/ApiUrlHelper.d.ts

@@ -0,0 +1,18 @@
+import { Table } from "../../common/Table";
+import { Query } from "./Query";
+export declare class ApiUrlHelper {
+    static query2Str(query: Query): any;
+    static prepareQueryParams(...params: any[]): string;
+    static negationFilterAliases: {
+        notStartsWith: string;
+        notContains: string;
+        notEndsWith: string;
+    };
+    static filter2Str(f: any, table?: Table, parent?: any): string;
+    private static prepareOp;
+    private static arg2Str;
+    static prepareValue(arg: any): string;
+    private static value2Str;
+    private static filterQuery2Str;
+    private static sort2Str;
+}

package/types/_core/scripts/services/api/BaseQuery.d.ts

@@ -0,0 +1,15 @@
+import { IFilter } from "../IFilter";
+import { QuerySorting } from "./Query";
+export interface BaseQuery {
+    /** Названия выбранных полей */
+    select?: string[];
+    /** Количество записей */
+    top?: number;
+    /** Фильтр запроса */
+    filter?: IFilter;
+    /** Количество пропускаемых с начала записей */
+    skip?: number;
+    /** Сортировка записей */
+    sorting?: QuerySorting[];
+    count?: boolean;
+}

package/types/_core/scripts/services/api/IRequestResult.d.ts

@@ -0,0 +1,68 @@
+/// <reference types="mithril" />
+import { RecordId } from "mdtScripts/common/Record";
+import { UiType } from "mdtScripts/helpers/IUi";
+import { Button } from "mdtScripts/helpers/ui/el";
+import { FormCtrl } from "mdtScripts/views/form/form";
+import { ApiRequestOptions } from "./ApiRequestOptions";
+export interface RequestResultV2<T> {
+    payload: T;
+    $debug: unknown;
+}
+export interface ExecutedRequestArgs<T = unknown> {
+    data: T;
+    params: ExecutedRequestParams;
+    run: () => unknown;
+    deferred: _mithril.MithrilDeferred<unknown>;
+    url: string;
+    options: ApiRequestOptions;
+}
+export declare type ExecutedRequestParams = ExecutedRequestBaseParams & ExecutedRequestDestroyParams;
+export interface ExecutedRequestBaseParams {
+    table?: string;
+    tableName?: string;
+    FlagConfirm?: boolean;
+}
+export interface ExecutedRequestDestroyParams {
+    IdList?: RecordId[];
+}
+export interface ResponceMessage {
+    $: "msg";
+    title?: string;
+    type: "Error" | "Confirmation" | "Warning" | "Success" | "Fatal" | "Information";
+    actions?: ResponceMessageActionExtended[];
+    items?: ResponceMessageItem[];
+}
+export interface PreparedResponceMessage extends ResponceMessage {
+    items: (ResponceMessageItem | {
+        control: any;
+    })[];
+}
+export interface ResponceMessageAction {
+    $Type: UiType;
+    $Icon: string;
+    $Title: string;
+    $Code: string;
+    $Param: string;
+    $ParamValue: string;
+}
+export interface ResponceMessageActionExtended extends ResponceMessageAction {
+    $ParamObj?: number;
+    $form?: FormCtrl;
+    $buttonExtend?: Partial<Button>;
+}
+export declare type ResponceMessageItem = ResponceMessageTextItem | ResponceMessageRows | ResponceMessageRefs | {
+    [key: string]: any;
+};
+export interface ResponceMessageTextItem {
+    text: string;
+    severity: number;
+}
+export interface ResponceMessageRows<R = unknown> {
+    rows: R[];
+}
+export interface ResponceMessageRefs {
+    refs: {
+        $ID_Object: RecordId;
+        $ID_Record: RecordId;
+    }[];
+}

package/types/_core/scripts/services/api/Query.d.ts

@@ -0,0 +1,67 @@
+import { Table } from "../../common/Table";
+import { BaseQuery } from "./BaseQuery";
+export declare type QuerySorting = string | {
+    path: string;
+    asc?: boolean;
+};
+export interface Query extends BaseQuery {
+    options?: QueryOptions;
+    withCount?: boolean;
+    distinct?: boolean;
+    key?: any;
+    params?: any;
+    dependency?: {
+        table: string;
+        field: string;
+    };
+    aggregate?: boolean;
+    export?: string;
+    format?: string;
+    hierarchy?: any;
+    placeIn?: any;
+    date?: Date;
+    table?: Table;
+    children?: Query[];
+    parent?: Query;
+    groups?: GroupQuery;
+    disableDefaultSorting?: boolean;
+    pure?: boolean;
+    audit?: string;
+    workflow?: string;
+    tag?: string;
+    skippedRowsCount?: number;
+}
+export interface GroupQuery {
+    groups?: GroupItem[];
+    allParents?: boolean;
+    orphans?: boolean;
+    toggledValues?: any[];
+}
+export declare type GroupLabel = {
+    title?: string;
+    icon?: string;
+    color?: string;
+    textColor?: string;
+};
+export interface GroupItem {
+    fieldPath: string;
+    collapsed?: boolean;
+    label?: GroupLabel | false;
+    toggledValues?: any[];
+    withEmpty?: boolean;
+    sortDesc?: boolean;
+    select?: string[];
+    sorting?: {
+        path: string;
+        asc?: boolean;
+    }[];
+}
+export interface QueryOptions {
+    root?: boolean;
+    reset?: boolean;
+    firstQuery?: boolean;
+    secondary?: boolean;
+    ext?: {
+        [ext: string]: any;
+    };
+}

package/types/_core/scripts/services/api/QueryResultHandler.d.ts

@@ -0,0 +1,27 @@
+import { FetchResult } from "mdtScripts/datasources/FetchResult";
+interface InitialFetchResponsePascale {
+    Rows: any[];
+    Count: number;
+    Items: any;
+}
+interface InitialFetchResponseCamel {
+    rows: any[];
+    count: number;
+    items: any;
+}
+export declare type InitialFetchResponse = Partial<InitialFetchResponseCamel & InitialFetchResponsePascale>;
+export interface HandledResult<R = any, I = any> extends FetchResult<R, I> {
+    groups?: any;
+}
+export interface ResultPropNames {
+    rowsName: "Rows" | "rows";
+    countName: "Count" | "count";
+    itemsName: ItemsPropNames;
+}
+declare type ItemsPropNames = "Items" | "items";
+export declare class QueryResultHandler {
+    createResult<R = any, I = any>(response: InitialFetchResponse, isCamel?: boolean): HandledResult<R, I>;
+    getPropsNames(isCamel: boolean): ResultPropNames;
+    private findGroups;
+}
+export {};

package/types/_core/scripts/services/browserSupport/block.d.ts

@@ -0,0 +1,11 @@
+/// <reference types="mithril" />
+import "./block.less";
+export declare class BrowserSupportBlock {
+    private service;
+    private showWindow;
+    constructor();
+    private getDownloadBtn;
+    private getCloseBtn;
+    private getRenderedTextContent;
+    $view: () => _mithril.MithrilVirtualElement;
+}

package/types/_core/scripts/services/browserSupport/service.d.ts

@@ -0,0 +1,35 @@
+export declare type IsSupported = "supported" | "unsupported" | "unknown";
+export interface BrowserSupportTextContent {
+    header: string;
+    description: string;
+}
+interface BrowserInfo {
+    name: string;
+    version: string;
+}
+export interface ShowFlagInfo {
+    flag: boolean;
+    date: Date | string;
+}
+export declare class BrowserSupportService {
+    isSupported(): IsSupported;
+    getTextContentCodes(isSupported: IsSupported): BrowserSupportTextContent;
+    getShowFlag(): boolean;
+    saveShowFlag(showFlag: boolean): void;
+    private getBrowserInfo;
+}
+export declare class BrowserSupportVersionService {
+    private static supported;
+    static isSupported(browserInfo: BrowserInfo): IsSupported;
+    private static isVersionSupported;
+}
+export declare class BrowserSupportStorage {
+    private static showParamName;
+    static getFlag(): boolean;
+    static saveFlag(showFlag: boolean): void;
+    private static clearFlag;
+    private static getPreparedInfoForStorage;
+    private static isLessThan24Hours;
+    private static getDiffInHours;
+}
+export {};

package/types/_core/scripts/services/commandsContext/FormCommandContextManager.d.ts

@@ -0,0 +1,5 @@
+export declare class FormCommandContextManager {
+    constructor();
+    private setCommandsContext;
+    private removeCommandsContext;
+}

package/types/_core/scripts/services/commandsContext/ListCommandContextManager.d.ts

@@ -0,0 +1,5 @@
+export declare class ListCommandContextManager {
+    constructor();
+    private setCommandsContext;
+    private removeCommandsContext;
+}

package/types/_core/scripts/services/customModules/customModulesManager.d.ts

@@ -0,0 +1,18 @@
+/// <reference types="mithril" />
+import { IMDTFacade } from "./facades/IMdtFacade";
+import { MDTFacade } from "./facades/mdtFacade";
+declare type ModuleCallback = (mdt: IMDTFacade) => void;
+export declare class CustomModuleManager {
+    private static modulesCallbacks;
+    private defer;
+    private scripts;
+    private modules;
+    MDT: MDTFacade;
+    constructor();
+    registerFacade(): void;
+    fetchModules(): void;
+    inited(): _mithril.MithrilPromise<unknown>;
+    static registerModule(callback: ModuleCallback): void;
+    private loadScripts;
+}
+export {};

package/types/_core/scripts/services/customModules/customModulesSettings.d.ts

@@ -0,0 +1,3 @@
+import { NavigationNode } from "mdtScripts/common/NavigationNode";
+export declare function getCustomModulesControl(): NavigationNode;
+export declare function getModulesFromStorage(): string[];

package/types/_core/scripts/services/customModules/facades/AuthFacade.d.ts

@@ -0,0 +1,7 @@
+import { MithrilControl } from "mdtScripts/helpers/types";
+import { IAuthFacade } from "./IAuthFacade";
+export declare class AuthFacade implements IAuthFacade {
+    disableFormsProvider(): void;
+    disableProvider(ctrl: any): void;
+    registerControl(control: MithrilControl): void;
+}

package/types/_core/scripts/services/customModules/facades/Form/FieldControlFacade.d.ts

@@ -0,0 +1,19 @@
+import { FieldCtrl } from "mdtScripts/views/form/field";
+import { FormCtrl } from "mdtScripts/views/form/form";
+import { FormLayoutColOptions } from "mdtScripts/views/form/Layout";
+import { ErrorInfo, FieldValue, IFieldControlFacade } from "./IFieldControlFacade";
+export declare class FieldControlFacade<T = FieldValue> implements IFieldControlFacade<T> {
+    content: FormCtrl;
+    hasReadonly: boolean;
+    protected options: FormLayoutColOptions;
+    protected fieldCtrl: FieldCtrl;
+    protected onUpdatedCallbacks: any[];
+    constructor(options: FormLayoutColOptions, fieldCtrl: FieldCtrl);
+    getValue(): any;
+    setValue(val: T): void;
+    isEditable(): boolean;
+    setErrors(errors: ErrorInfo[]): void;
+    clearErrors(errorKey?: string): void;
+    onUpdated(callback: (v: T) => void): () => void;
+    title(): any;
+}

package/types/_core/scripts/services/customModules/facades/Form/FieldControlManagerFacade.d.ts

@@ -0,0 +1,5 @@
+import { IFieldControlManagerFacade, RegisterArgs } from "./IFieldControlManagerFacade";
+export declare class FieldControlManagerFacade implements IFieldControlManagerFacade {
+    register<V>(args: RegisterArgs<V>): void;
+    private getAllTypes;
+}

package/types/_core/scripts/services/customModules/facades/Form/FormControlFacade.d.ts

@@ -0,0 +1,34 @@
+import { FormCtrl } from "mdtScripts/views/form/form";
+import { ObjectFacade } from "../schema/ObjectFacade";
+import { IFormControlFacade, IFormFieldOptionsConfig } from "./IFormControlFacade";
+import { ButtonFacade } from "./IFormFacade";
+export declare class FormControlFacade implements IFormControlFacade {
+    private formCtrl;
+    constructor(formCtrl: FormCtrl);
+    getFormCtrl(): FormCtrl<import("../../../../common/Record").Record>;
+    getViewControl(): any;
+    getObject(): ObjectFacade;
+    getCode(): string;
+    getContext(key: string): any;
+    setContext(key: string, value: any): void;
+    getRecordId(): any;
+    isNewRecord(): boolean;
+    value(field: string, value?: any, val$?: any, fireEvent?: boolean, setDirty?: boolean, updateData?: {}): any;
+    valueByPath(path: string): any;
+    addRecordInitDependence(dependence: () => Promise<unknown>): void;
+    onBound(callback: () => void): void;
+    onSave<T = {
+        [field: string]: any;
+    }>(callback: (record: T) => void): void;
+    onClose(callback: () => void): void;
+    onLayoutCreated(callback: () => void): void;
+    addCommand(command: ButtonFacade, isExtend?: boolean): void;
+    setFieldOptions(fieldsOptions: IFormFieldOptionsConfig): void;
+    setControlOptions(findControl: (item: any) => boolean, controlOptions: any): void;
+    setReadonly(readonly: boolean): void;
+    updateCommand(findCondition: () => boolean, command: Partial<ButtonFacade>): void;
+    reinit(): void;
+    save(): Promise<any>;
+    openDesigner(): void;
+    getZones(): import("../../../../views/form/formTypes").FormZones;
+}

package/types/_core/scripts/services/customModules/facades/Form/FormServiceFacade.d.ts

@@ -0,0 +1,20 @@
+import { FormLayoutColOptions } from "mdtScripts/views/form/Layout";
+import { RecordId } from "../utils/IApiFacade";
+import { FormControlFacade } from "./FormControlFacade";
+import { IFormControlFacade } from "./IFormControlFacade";
+import { IFormOptions, IFormServiceFacade } from "./IFormFacade";
+interface FormInitOptions {
+    code?: string;
+    rules?: {
+        [fieldCode: string]: FormLayoutColOptions;
+    };
+}
+export declare class FormServiceFacade implements IFormServiceFacade {
+    create(tableCode: string, id: RecordId, options?: any, extOptions?: any): FormControlFacade;
+    createCustom(options: IFormOptions): FormControlFacade;
+    onInit(callback: (form: IFormControlFacade) => void): void;
+    onCreate(callback: (form: IFormControlFacade) => void): void;
+    onCreated(callback: (form: IFormControlFacade) => void): void;
+    addFieldOptions(tableCode: string, options?: FormInitOptions): void;
+}
+export {};

package/types/_core/scripts/services/customModules/facades/Form/IFieldControlFacade.d.ts

@@ -0,0 +1,26 @@
+export declare type FieldValue = any;
+export interface ErrorInfo {
+    /** Текст ошибки */
+    message: string;
+    /** Код ошибки */
+    key?: string;
+}
+export interface IFieldControlFacadeContstructor<T = FieldValue> {
+    new (options: any, fieldCtrl: any): IFieldControlFacade<T>;
+}
+export interface IFieldControlFacade<T = FieldValue> {
+    /** Получить значение поля */
+    getValue: () => T;
+    /** Установить значение поля */
+    setValue: (val: T) => void;
+    /** Проверка, является ли поле редактируемым */
+    isEditable: () => boolean;
+    /** Установить ошибку валидации для поля */
+    setErrors: (errors: ErrorInfo[]) => void;
+    /** Очистить ошибки валидации */
+    clearErrors: (errorKey?: string) => void;
+    /** Подписаться на событие обновления значения поля */
+    onUpdated: (callback: (val: T) => void) => () => void;
+    /** Заголовок поля */
+    title: () => string;
+}

package/types/_core/scripts/services/customModules/facades/Form/IFieldControlManagerFacade.d.ts

@@ -0,0 +1,36 @@
+import { IFieldControlFacade } from "./IFieldControlFacade";
+export interface MountContext<V> {
+    /** Родительский DOM-элемент контрола */
+    el: HTMLElement;
+    /** Поле, к которому привязан контрол */
+    field: IFieldControlFacade<V>;
+    /** Опции контрола */
+    options: any;
+    /** Подписка на событие удаления контрола */
+    onUnmount: (onUnmountCallback?: (field: IFieldControlFacade) => void) => void;
+    /** Mithril класс контрола */
+    control: any;
+}
+export interface IMithrilCustomControl<V> {
+    new (options: any, field: IFieldControlFacade<V>): any;
+}
+export interface RegisterArgs<V> {
+    /** Наименование контрола */
+    title: string;
+    /** Код контрола */
+    code: string;
+    /** Mithril класс контрола */
+    control?: IMithrilCustomControl<V>;
+    /** Типы полей, для которых предназначен контрол */
+    types?: string | string[];
+    /** Используется ли контрол для полей с внешним ключом */
+    ref?: boolean;
+    /** Скрыть контрол из списка в конструкторе форм */
+    hidden?: boolean;
+    /** Подписка на событие рендера контрола */
+    onMount?: (params: MountContext<V>) => void;
+}
+export interface IFieldControlManagerFacade<V = any> {
+    /** Зарегистрировать новый контрол */
+    register: <T = V>(args: RegisterArgs<T>) => void;
+}

package/types/_core/scripts/services/customModules/facades/Form/IFormControlFacade.d.ts

@@ -0,0 +1,61 @@
+import { FormZones } from "mdtScripts/views/form/formTypes";
+import { IObjectFacade } from "../schema/IObjectFacade";
+import { RecordId } from "../utils/IApiFacade";
+import { ParentCtrl } from "../utils/IUiFacade";
+import { ButtonFacade } from "./IFormFacade";
+export declare type IFormFieldOptionsConfig = {
+    [fieldCode: string]: any;
+};
+export interface IFormControlFacadeContstructor {
+    new (formCtrl: any): IFormControlFacade;
+}
+export interface IFormControlFacade extends ParentCtrl {
+    /** Получить оригинальный контрол формы */
+    getFormCtrl(): any;
+    /** Получить объект, к которому приязана форма */
+    getObject(): IObjectFacade;
+    /** Получить код формы */
+    getCode(): string;
+    /** Получить контекстный параметр формы */
+    getContext(key: string): any;
+    /** Установить контекстный параметр формы */
+    setContext(key: string, value: any): void;
+    /** Получить ID записи */
+    getRecordId(): RecordId;
+    /** Проверка, что запись в форме новая */
+    isNewRecord(): boolean;
+    /** Получить или установить значение для поля формы */
+    value(field: string, val?: any, val$?: any, fireEvent?: boolean, setDirty?: boolean, updateData?: {}): any;
+    /** Получение значения по пути */
+    valueByPath(path: string): any;
+    /** Добавить зависимость для запроса записи*/
+    addRecordInitDependence(dependence: () => Promise<unknown>): void;
+    /** Подписаться на событие инициализации записи формы */
+    onBound(callback: () => void): void;
+    /** Подписаться на событие сохранения записи */
+    onSave<T = {
+        [field: string]: any;
+    }>(callback: (record: T) => void): void;
+    /** Подписаться на событие закрытия формы */
+    onClose(callback: () => void): void;
+    /** Подписаться на событие создания макета формы */
+    onLayoutCreated(callback: () => void): void;
+    /** Установить команду на форму */
+    addCommand(command: ButtonFacade, isExtended?: boolean): void;
+    /** Установить настройки для полей формы */
+    setFieldOptions(options: IFormFieldOptionsConfig): void;
+    /** Установить настройки для компонента формы */
+    setControlOptions(findControl: (col: any) => boolean, controlOptions: any): any;
+    /** Установить флаг доступности редактирования формы */
+    setReadonly(readonly: boolean): void;
+    /** Изменить свойства существующей кнопки */
+    updateCommand(findCondition: () => boolean, command: Partial<ButtonFacade>): void;
+    /** Повторно инициализировать форму */
+    reinit(): void;
+    /** Сохранить форму */
+    save(): void;
+    /** Открыть конструктор формы */
+    openDesigner(): void;
+    /** Получить зоны */
+    getZones(): FormZones;
+}