mdt-client 1.0.26 → 1.0.29

package/types/_core/scripts/helpers/utils.d.ts

@@ -0,0 +1,146 @@
+/// <reference types="mithril" />
+import { IType } from "../Configuration";
+export declare const _: I_;
+export declare function T(tableCode: string): () => Table;
+import { Table } from "mdtScripts/common/Table";
+import { mClassNames as origMClassNames, classNames as origClassNames } from "./utils/classNames";
+export declare type MProp<T> = _mithril.MithrilPromiseProperty<T>;
+export interface I_FireOptions {
+    cancelable?: boolean;
+    clear?: boolean;
+}
+export interface I_ {
+    <T>(type: IType<T>): T;
+    instances: {
+        [name: string]: any;
+    };
+    register: <T>(type: IType<T>, constr?: any) => T;
+    getQueryString: (obj: any) => string;
+    events: any;
+    fire: (...args: any[]) => any;
+    prop: <T>(v?: T, onchange?: any) => _mithril.MithrilPromiseProperty<T> & {
+        onchange: (v?: T) => any;
+    };
+    reformatJSON: (value: string) => string;
+    reformatXML: (value: string) => string;
+    promise: () => _mithril.MithrilPromise<any>;
+    throttle: {
+        (...args: any[]): any;
+        $instance: any;
+    };
+    assert: (val: any, msg: any) => void;
+    deepEqual: (x: any, y: any, opts?: any) => boolean;
+    getProp: (obj: any, path: any) => any;
+    combine: <T>(o: T, x: T) => T;
+    forEach: (obj: any, fn: any) => void;
+    limit: (val: any, min: any, max: any) => number;
+    loadScript: (src: any, opts?: LoadResourceOptions) => any;
+    loadResource: (src: any, data: any, opts?: LoadResourceOptions) => any;
+    download: (src: string) => void;
+    title: (record: any) => any;
+    $resources: {};
+    guid: () => string;
+    fieldsFromObject: (obj: any) => any[];
+    addUnique: (array: any[], items: any[]) => any;
+    regexIso8601: RegExp;
+    warning: (msg: any) => void;
+    loadStyle: (src: any) => any;
+    fixParsedObject: (obj: any) => any;
+    lazyProp: (fn: any) => () => any;
+    instanceOf: (instance: {
+        constructor: Function;
+    }, type: any) => boolean;
+    text: (txt: string, args?: any, complex?: boolean) => any | any[];
+    map: (obj: any, fn: any) => any[];
+    toggleObjectClass: (obj: any, className: any, toggle: any) => void;
+    v: (prop: any, ...args: any[]) => any;
+    clone: <T = any>(obj: T, options?: any) => T;
+    values: (obj: any) => any[];
+    promiseEx: (promise: any) => _mithril.MithrilPromise<Object>;
+    storage: (k: any, v?: any, clean?: boolean) => any;
+    module: (fn: any, priority?: any) => _mithril.MithrilPromise<Object>;
+    /** @deprecated */
+    noop: (...items: any[]) => void;
+    setProp: (obj: any, path: any, val: any) => void;
+    storedProp: (key: any) => (v: any) => any;
+    add: (arr: any, fn: any, priority: any) => void;
+    keys: (obj: any, keyNames: any) => void;
+    toDebugJSON: (o: any, onlySimple: boolean) => string;
+    removeSpecial: (record: any, whiteList?: any) => any;
+    tristateCase: (value: boolean, ifTrue: any, ifFalse: any, ifNull: any) => any;
+    currentId: number;
+    getUniqueId: () => number;
+    pad2: (number: any, padValue?: any) => string;
+    timeSince: (Date: any) => any;
+    inRange: (min: number, num: number, max: number) => boolean;
+    isFunction: (fn: any) => fn is Function;
+    isNum: (arg: any) => boolean;
+    empty: () => string;
+    whiteSpace: () => string;
+    whiteSpaceDefintion: () => string;
+    abbr: (str: any, opts?: any) => string;
+    colorGen: (txt: string) => string;
+    errorText: (code: any, message: any, args: any) => string;
+    copyToClipboard: (text: string) => boolean;
+    parseTagAttrs: (tag: string) => any;
+    isDev(): boolean;
+    msToTime(duration: number, format?: boolean): string;
+    isPromisable(obj: any): boolean;
+}
+export declare function pad3(value: any, postfix: any, force?: boolean): string;
+export declare function getTimeValues(duration: number): {
+    seconds: number;
+    minutes: number;
+    hours: number;
+    days: number;
+};
+export declare function asyncObjectPropsPrepare(obj: any, shouldPrepare: (value: any, key: string) => boolean, prepareProp: (value: any, key: string) => _mithril.MithrilPromise<any>): _mithril.MithrilPromise<any>;
+interface LoadResourceOptions {
+    disableCache?: boolean;
+    onerror?: any;
+}
+export declare function download(src: string, showError?: boolean, destroyTimeout?: number): void;
+export declare function downloadURI(uri: any): void;
+export declare function isFunction(fn: any): fn is Function;
+export interface BrowserByUserAgentData {
+    name: string;
+    ver?: string;
+}
+export declare function browserByUserAgent(userAgent: string): BrowserByUserAgentData;
+export declare function osByUserAgent(userAgent: string): string;
+export declare function repeat(callback: any, count: number): any[];
+export declare function getTagContent(tagName: string, content: any): string;
+export declare function propsToHtmlAttrs(props: any, filteredKeys?: any[]): string;
+export declare function strToDomElement(source: string): ChildNode | NodeListOf<ChildNode>;
+export declare function objectToArray(obj: any): any[];
+export declare function isDateValid(date: Date): boolean;
+export declare const classNames: typeof origClassNames;
+export declare const mClassNames: typeof origMClassNames;
+export declare function romanize(num: number): string;
+export declare function getDaysArray(start: Date, end: Date): Date[];
+export declare type WeekData = Date[][];
+export declare function getWeeksData(start: Date, end: Date, lastWeekDayIndex?: number): WeekData;
+export declare function compareDates(date: Date, date2: Date): boolean;
+export declare function uniqArray(arr: any[]): any[];
+export declare function isValidDate(date: any): boolean;
+export declare function clearDocumentSelection(): void;
+export declare function flattenDeep(arr1: any): any;
+export declare function extractValue(object: any, path: any): any;
+export declare function literalEval(code: any, context?: {}): any;
+export declare function uploadDialog(): Promise<unknown>;
+export declare function subscribeOnce<T extends (...args: any) => any>(events: T[], callback: T): void;
+export declare function buttonSort(a: any, b: any): number;
+interface PromiseDeferred<T = unknown> {
+    promise: Promise<T>;
+    resolve: (value: T) => void;
+    reject: (reason: any) => void;
+}
+export declare function defer<T = unknown>(): PromiseDeferred<T>;
+export declare function isObject(obj: any): boolean;
+export declare function simpleClone<T>(o: T): T;
+export declare function strEndDot(v: string): string;
+export declare function isUndefined(obj: any): obj is undefined;
+export declare function isUndefinedOrNull(obj: any): obj is undefined | null;
+export declare function getTypeMessage(type: string): string;
+export declare function createArray<T = any>(length: any, callback: (idx: number) => T): T[];
+export {};

package/types/_core/scripts/helpers/view.d.ts

@@ -0,0 +1,8 @@
+/// <reference types="mithril" />
+import { MithrilControl } from "./types";
+export declare function getView(ctrl: any, check?: any): any;
+export declare let viewCounter: number;
+export declare const showedErrors: any[];
+export declare function initViewKey(res: any, ctrl: any): void;
+export declare function view(ctrl: any, ...args: any[]): _mithril.MithrilVirtualElement;
+export declare function hasView(ctrl: any): ctrl is MithrilControl;

package/types/_core/scripts/helpers/viewer.d.ts

@@ -0,0 +1,5 @@
+/// <reference types="mithril" />
+import { IType } from "../Configuration";
+declare type ViewFn<T> = _mithril.MithrilView<T> | (<T>(ctrl?: T, ...args: any[]) => any);
+export declare function viewer<T>(type: IType<T>, fn?: (ctrl: T, ...args: any[]) => any): ViewFn<T>;
+export {};

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

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

package/types/_core/scripts/helpers/zone/Zone.d.ts

@@ -0,0 +1,14 @@
+/// <reference types="mithril" />
+import { MithrilControl } from "../types";
+import { IZone } from "./IZone";
+export interface ZoneOptions {
+    onPush?(): void;
+}
+export declare class Zone implements IZone {
+    private options?;
+    private zone;
+    constructor(options?: ZoneOptions);
+    remove(content: MithrilControl): void;
+    push(content: MithrilControl): void;
+    render(): _mithril.MithrilVirtualElement[];
+}

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

@@ -0,0 +1,6 @@
+import { Zone, ZoneOptions } from "./Zone";
+export declare class Zones<T extends readonly string[]> {
+    private zones;
+    constructor(codes: T, options: ZoneOptions);
+    getZone(code: T[number]): Record<T[number], Zone>[T[number]];
+}

package/types/_core/scripts/messages.d.ts

@@ -0,0 +1,15 @@
+export declare const messages: {
+    unsavedWarning: string;
+    recordSaved: string;
+    recordsSaved: string;
+    recordDeleted: string;
+    recordsDeleted: string;
+    allChangesWillBeSaved: string;
+    formInvalid: string;
+    recordDeleting: string;
+    recordsDeleting: string;
+    recordCopying: string;
+    recordsCopying: string;
+    recordCopied: string;
+    recordsCopied: string;
+};

package/types/_core/scripts/security/PermissionLevel.d.ts

@@ -0,0 +1,32 @@
+import { MdtField } from "../common/MdtField";
+import { MdtObject } from "../common/MdtObject";
+import { Record } from "../common/Record";
+export declare enum PermissionLevel {
+    None = 0,
+    Read = 1,
+    Write = 2,
+    Delete = 4,
+    Add = 8,
+    Execute = 16,
+    Filter = 32,
+    All = 255
+}
+export interface PrincipalPermission extends Record {
+    ID_Permission?: number;
+    ID_Permission$?: Permission;
+    ID_Object?: number;
+    ID_Object$?: MdtObject;
+    ID_Field?: number;
+    ID_Field$?: MdtField;
+    LevelGrant?: PermissionLevel;
+    LevelDeny?: PermissionLevel;
+    Filter?: string;
+}
+export interface Permission extends Record {
+    id?: number;
+    Code: string;
+    LevelMask: PermissionLevel;
+    ID_Parent: number;
+    FlagObject: boolean;
+    FlagField: boolean;
+}

package/types/_core/scripts/security/User.d.ts

@@ -0,0 +1,15 @@
+import { Record } from "../common/Record";
+export interface User extends Record {
+    id: any;
+    permissions: any[];
+    fullName: string;
+    email: string;
+    identityName: string;
+    isAdmin: boolean;
+    isAnonymous: boolean;
+    roles: string[];
+    userGroups: any[];
+    languageId: number;
+    languageCode: "ru" | "en";
+    isImpersonated: boolean;
+}

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

@@ -0,0 +1,5 @@
+export declare class AppCommandManagerClass {
+    setupCommands(): void;
+    bindEvent(ctx: any): void;
+}
+export declare const AppCommandManager: AppCommandManagerClass;

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

@@ -0,0 +1,19 @@
+/// <reference types="mithril" />
+import { User } from "mdtScripts/security/User";
+import { Record } from "../common/Record";
+interface ChangePasswordModel extends Record {
+    userId?: number;
+    password?: string;
+    confirmPassword?: string;
+    oldPassword?: string;
+}
+declare class AuthService {
+    signOut(): any;
+    signInWindows(): any;
+    signInWithForms(login: string, password: string, rememberMe: boolean): any;
+    changePassword(data: ChangePasswordModel, reset: boolean): any;
+    user(): _mithril.MithrilPromise<User>;
+    impersonate(id?: number): any;
+}
+export declare const Auth: AuthService;
+export {};

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

@@ -0,0 +1,50 @@
+import { FormattedText } from "mdtScripts/helpers/formattedText";
+import { CommandEvent, Valued } from "mdtScripts/helpers/types";
+import { FormControlFacade } from "./customModules/facades/Form/FormControlFacade";
+import { ListControlFacade } from "./customModules/facades/List/ListControlFacade";
+export interface CommandGroup {
+    code: string;
+    title: string;
+    description?: string;
+    icon?: string;
+}
+export declare type Hotkey = string;
+export interface Command {
+    code: string;
+    title: string;
+    description?: Valued<FormattedText>;
+    icon?: Valued<string>;
+    hotkeys?: Hotkey[];
+    group?: CommandGroup;
+    command: <Context>(context: Context) => void;
+    enabled?: <Context>(context?: Context) => boolean;
+    visible?: () => boolean;
+}
+export declare type HotkeyCommands = {
+    [hotkey: string]: () => void;
+};
+export interface CommandManagerContext {
+    list?: ListControlFacade;
+    form?: FormControlFacade;
+}
+export declare class CommandManagerClass<Context> {
+    private groups;
+    private commands;
+    private hotkeyCommands;
+    private context;
+    addGroup(group: CommandGroup, commands?: Command[]): void;
+    addCommands(commands: Command[], groupCode?: string): void;
+    getCommand(code: string): Command;
+    execByEvent(event: CommandEvent): void;
+    execByCode(commandCode: string): void;
+    getCommandList(): Command[];
+    setContext(key: keyof Context, value: Context[keyof Context]): void;
+    removeContext(key: keyof Context): void;
+    private validateCommand;
+    private validateGroup;
+    private findGroup;
+    private pushCommands;
+    private execCommand;
+    private checkEnabled;
+}
+export declare const CommandManager: CommandManagerClass<CommandManagerContext>;

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

@@ -0,0 +1,4 @@
+export declare class CommandManagerCommands {
+    static openCommandPaletteCode: string;
+    static init(): void;
+}

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

@@ -0,0 +1,3 @@
+export declare class DebugManagerCommands {
+    static init(): void;
+}