sprof 0.1.0 → 0.1.1

package/dist/core/auth/Auth.d.ts

@@ -0,0 +1,275 @@
+declare class Auth<UserT> {
+    static instance: unknown | undefined;
+    private form;
+    private status;
+    private modal;
+    constructor();
+    get Form(): {
+        Block: (fn: () => Promise<void>) => Promise<void>;
+        readonly IsBlock: boolean;
+        GetValues: () => {
+            [k: string]: string;
+        };
+        Validate: () => string[];
+        GetFields: () => import('./fields/AuthField').default[];
+        GetMethods: () => import('.').AuthMethods[];
+        Chunk: () => import('.').AuthChunks;
+        readonly Settings: {
+            allowRestore: boolean;
+            login: {
+                methods: import('.').AuthMethods[];
+                title: string;
+                action: string;
+                buttons: ({
+                    id: string;
+                    text: string;
+                    isSubmit: boolean;
+                    chunk: import('.').AuthChunks;
+                    isLink: boolean;
+                    GetChunk: () => import('.').AuthChunks;
+                    type?: import('../types/Statuses').default | undefined;
+                    condition?: boolean | undefined;
+                    action?: (((next?: import('vue-router').NavigationGuardNext | undefined) => Promise<void>) | (() => Promise<void>) | (() => void)) | undefined;
+                    disabled: boolean;
+                } | {
+                    id: string;
+                    text: string;
+                    isSubmit: boolean;
+                    chunk: import('.').AuthChunks;
+                    isLink: boolean;
+                    GetChunk: () => import('.').AuthChunks;
+                    type?: import('../types/Statuses').default | undefined;
+                    condition?: boolean | undefined;
+                    action?: (((next?: import('vue-router').NavigationGuardNext | undefined) => Promise<void>) | (() => Promise<void>) | (() => void)) | undefined;
+                    disabled: boolean;
+                } | {
+                    id: string;
+                    text: string;
+                    isSubmit: boolean;
+                    chunk: import('.').AuthChunks;
+                    isLink: boolean;
+                    GetChunk: () => import('.').AuthChunks;
+                    type?: import('../types/Statuses').default | undefined;
+                    condition?: boolean | undefined;
+                    action?: (((next?: import('vue-router').NavigationGuardNext | undefined) => Promise<void>) | (() => Promise<void>) | (() => void)) | undefined;
+                    disabled: boolean;
+                })[];
+                fields: ({
+                    id: import('.').AuthFieldsIds;
+                    label: string;
+                    name: string;
+                    placeholder: string;
+                    validator?: {
+                        errors: string[];
+                        validate: (value?: string | number | undefined) => string[];
+                    } | undefined;
+                    method: import('.').AuthMethods;
+                    readonly IsPassword: boolean;
+                    value: string;
+                    Validate: () => string[];
+                    Reset: () => void;
+                } | {
+                    label: string;
+                    validator?: {
+                        errors: string[];
+                        validate: (value?: string | number | undefined) => string[];
+                    } | undefined;
+                    name: string;
+                    placeholder: string;
+                    id: import('.').AuthFieldsIds;
+                    method?: import('.').AuthMethods | undefined;
+                    readonly IsPassword: boolean;
+                    value: string;
+                    Validate: () => string[];
+                    Reset: () => void;
+                })[];
+                errorMessage: string;
+                successMessage: string;
+            };
+            register: {
+                methods: never[];
+                title: string;
+                action: string;
+                buttons: ({
+                    id: string;
+                    text: string;
+                    isSubmit: boolean;
+                    chunk: import('.').AuthChunks;
+                    isLink: boolean;
+                    GetChunk: () => import('.').AuthChunks;
+                    type?: import('../types/Statuses').default | undefined;
+                    condition?: boolean | undefined;
+                    action?: (((next?: import('vue-router').NavigationGuardNext | undefined) => Promise<void>) | (() => Promise<void>) | (() => void)) | undefined;
+                    disabled: boolean;
+                } | {
+                    id: string;
+                    text: string;
+                    isSubmit: boolean;
+                    chunk: import('.').AuthChunks;
+                    isLink: boolean;
+                    GetChunk: () => import('.').AuthChunks;
+                    type?: import('../types/Statuses').default | undefined;
+                    condition?: boolean | undefined;
+                    action?: (((next?: import('vue-router').NavigationGuardNext | undefined) => Promise<void>) | (() => Promise<void>) | (() => void)) | undefined;
+                    disabled: boolean;
+                } | {
+                    id: string;
+                    text: string;
+                    isSubmit: boolean;
+                    chunk: import('.').AuthChunks;
+                    isLink: boolean;
+                    GetChunk: () => import('.').AuthChunks;
+                    type?: import('../types/Statuses').default | undefined;
+                    condition?: boolean | undefined;
+                    action?: (((next?: import('vue-router').NavigationGuardNext | undefined) => Promise<void>) | (() => Promise<void>) | (() => void)) | undefined;
+                    disabled: boolean;
+                })[];
+                fields: ({
+                    id: import('.').AuthFieldsIds;
+                    label: string;
+                    name: string;
+                    placeholder: string;
+                    validator?: {
+                        errors: string[];
+                        validate: (value?: string | number | undefined) => string[];
+                    } | undefined;
+                    method: import('.').AuthMethods;
+                    readonly IsPassword: boolean;
+                    value: string;
+                    Validate: () => string[];
+                    Reset: () => void;
+                } | {
+                    label: string;
+                    validator?: {
+                        errors: string[];
+                        validate: (value?: string | number | undefined) => string[];
+                    } | undefined;
+                    name: string;
+                    placeholder: string;
+                    id: import('.').AuthFieldsIds;
+                    method?: import('.').AuthMethods | undefined;
+                    readonly IsPassword: boolean;
+                    value: string;
+                    Validate: () => string[];
+                    Reset: () => void;
+                } | {
+                    label: string;
+                    id: import('.').AuthFieldsIds;
+                    method?: import('.').AuthMethods | undefined;
+                    name: string;
+                    readonly IsPassword: boolean;
+                    value: string;
+                    placeholder: string;
+                    validator?: {
+                        errors: string[];
+                        validate: (value?: string | number | undefined) => string[];
+                    } | undefined;
+                    Validate: () => string[];
+                    Reset: () => void;
+                })[];
+                errorMessage: string;
+                successMessage: string;
+            };
+            restore: {
+                title: string;
+                methods: never[];
+                action: string;
+                successMessage: string;
+                errorMessage: string;
+                buttons: {
+                    id: string;
+                    text: string;
+                    isSubmit: boolean;
+                    chunk: import('.').AuthChunks;
+                    isLink: boolean;
+                    GetChunk: () => import('.').AuthChunks;
+                    type?: import('../types/Statuses').default | undefined;
+                    condition?: boolean | undefined;
+                    action?: (((next?: import('vue-router').NavigationGuardNext | undefined) => Promise<void>) | (() => Promise<void>) | (() => void)) | undefined;
+                    disabled: boolean;
+                }[];
+                fields: {
+                    id: import('.').AuthFieldsIds;
+                    label: string;
+                    name: string;
+                    placeholder: string;
+                    validator?: {
+                        errors: string[];
+                        validate: (value?: string | number | undefined) => string[];
+                    } | undefined;
+                    method: import('.').AuthMethods;
+                    readonly IsPassword: boolean;
+                    value: string;
+                    Validate: () => string[];
+                    Reset: () => void;
+                }[];
+            };
+            refresh: {
+                methods: never[];
+                title: string;
+                action: string;
+                successMessage: string;
+                errorMessage: string;
+                buttons: {
+                    id: string;
+                    text: string;
+                    isSubmit: boolean;
+                    chunk: import('.').AuthChunks;
+                    isLink: boolean;
+                    GetChunk: () => import('.').AuthChunks;
+                    type?: import('../types/Statuses').default | undefined;
+                    condition?: boolean | undefined;
+                    action?: (((next?: import('vue-router').NavigationGuardNext | undefined) => Promise<void>) | (() => Promise<void>) | (() => void)) | undefined;
+                    disabled: boolean;
+                }[];
+                fields: {
+                    label: string;
+                    validator?: {
+                        errors: string[];
+                        validate: (value?: string | number | undefined) => string[];
+                    } | undefined;
+                    name: string;
+                    placeholder: string;
+                    id: import('.').AuthFieldsIds;
+                    method?: import('.').AuthMethods | undefined;
+                    readonly IsPassword: boolean;
+                    value: string;
+                    Validate: () => string[];
+                    Reset: () => void;
+                }[];
+            };
+        };
+        readonly IsLogin: boolean;
+        readonly IsRegister: boolean;
+        readonly IsRestore: boolean;
+        readonly IsRefresh: boolean;
+        SetChunk: (chunk: import('.').AuthChunks) => void;
+        GetTitle: () => string;
+        GetButtons: () => import('./buttons/AuthButton').default[];
+        GetSuccessMessage: () => string;
+        GetErrorMessage: () => string;
+        GetAction: () => string;
+        ResetFields: () => void;
+        Reset: () => void;
+        GetField: (id: import('.').AuthFieldsIds) => import('./fields/AuthField').default | undefined;
+    };
+    get Status(): {
+        DeprecateLogout: () => void;
+        AllowLogout: () => void;
+        readonly IsAuth: boolean;
+        readonly User: import('vue').UnwrapRef<UserT> | undefined;
+        SetUserConstructor: (c: import('../helpers/Classes').Constructable<import('../interfaces/IWithId').default>) => void;
+        SetUser: (u: UserT) => void;
+        SetState: (authInfo: import('../types/AuthInfo').AuthInfo) => void;
+        Logout: () => void;
+        Actualize: () => void;
+    };
+    get Modal(): {
+        readonly Closable: boolean;
+        readonly Visible: boolean;
+        Close: () => void;
+        Open: (closable?: boolean | undefined) => void;
+    };
+}
+declare const _default: Auth<unknown>;
+export default _default;

package/dist/core/auth/AuthData.d.ts

@@ -0,0 +1,5 @@
+export default class AuthData {
+    email?: string;
+    login?: string;
+    password?: string;
+}

package/dist/core/auth/AuthForm.d.ts

@@ -0,0 +1,73 @@
+import { default as AuthButton } from './buttons/AuthButton';
+import { default as AuthField } from './fields/AuthField';
+import { default as AuthChunks } from './types/AuthChunks';
+import { default as AuthMethods } from './types/AuthMethods';
+import { default as AuthFieldsIds } from './types/AuthFieldsIds';
+export default class AuthForm {
+    private block;
+    private settings;
+    private chunk;
+    private selectedMethod;
+    Block(fn: () => Promise<void>): Promise<void>;
+    get IsBlock(): boolean;
+    GetValues(): {
+        [k: string]: string;
+    };
+    Validate(): string[];
+    GetFields(): AuthField[];
+    GetMethods(): AuthMethods[];
+    Chunk(): AuthChunks;
+    get Settings(): {
+        allowRestore: boolean;
+        login: {
+            methods: AuthMethods[];
+            title: string;
+            action: string;
+            buttons: (import('.').AuthButtonLogin | import('.').AuthButtonRegister | import('.').AuthButtonRestore)[];
+            fields: (import('./fields/EmailField').EmailField | import('./fields/PasswordField').PasswordField)[];
+            errorMessage: string;
+            successMessage: string;
+        };
+        register: {
+            methods: never[];
+            title: string;
+            action: string;
+            buttons: (import('.').AuthButtonLogin | import('.').AuthButtonRegister | import('.').AuthButtonRestore)[];
+            fields: (import('./fields/EmailField').EmailField | import('./fields/PasswordField').PasswordField | import('./fields/PasswordRepeatField').PasswordRepeatField)[];
+            errorMessage: string;
+            successMessage: string;
+        };
+        restore: {
+            title: string;
+            methods: never[];
+            action: string;
+            successMessage: string;
+            errorMessage: string;
+            buttons: import('.').AuthButtonRestore[];
+            fields: import('./fields/EmailField').EmailField[];
+        };
+        refresh: {
+            methods: never[];
+            title: string;
+            action: string;
+            successMessage: string;
+            errorMessage: string;
+            buttons: import('.').AuthButtonRefresh[];
+            fields: import('./fields/PasswordField').PasswordField[];
+        };
+    };
+    private GetCurSet;
+    get IsLogin(): boolean;
+    get IsRegister(): boolean;
+    get IsRestore(): boolean;
+    get IsRefresh(): boolean;
+    SetChunk(chunk: AuthChunks): void;
+    GetTitle(): string;
+    GetButtons(): AuthButton[];
+    GetSuccessMessage(): string;
+    GetErrorMessage(): string;
+    GetAction(): string;
+    ResetFields(): void;
+    Reset(): void;
+    GetField(id: AuthFieldsIds): AuthField | undefined;
+}

package/dist/core/auth/AuthModal.d.ts

@@ -0,0 +1,8 @@
+export default class AuthModal {
+    private visible;
+    private closable;
+    get Closable(): boolean;
+    get Visible(): boolean;
+    Close(): void;
+    Open(closable?: boolean): void;
+}

package/dist/core/auth/AuthStatus.d.ts

@@ -0,0 +1,18 @@
+import { Constructable } from '../helpers/Classes';
+import { default as IWithId } from '../interfaces/IWithId';
+import { AuthInfo } from '../types/AuthInfo';
+export default class AuthStatus<UserT> {
+    private isAuth;
+    private user;
+    private tokens;
+    private preventLogout;
+    DeprecateLogout(): void;
+    AllowLogout(): void;
+    get IsAuth(): boolean;
+    get User(): UserT | undefined;
+    SetUserConstructor(c: Constructable<IWithId>): void;
+    SetUser(u: UserT): void;
+    SetState(authInfo: AuthInfo): void;
+    Logout(): void;
+    Actualize(): void;
+}

package/dist/core/auth/AuthTokens.d.ts

@@ -0,0 +1,10 @@
+import { default as ITokens } from '../interfaces/ITokens';
+export default class AuthTokens {
+    set(tokenObj: ITokens): void;
+    getAccessToken(): string | undefined;
+    getRefreshToken(): string | undefined;
+    setAccessToken(token?: string): void;
+    setRefreshToken(token?: string): void;
+    reset(): void;
+    actualize(): void;
+}

package/dist/core/auth/AuthUser.d.ts

@@ -0,0 +1,16 @@
+import { Constructable } from '../helpers/Classes';
+import { default as IWithId } from '../interfaces/IWithId';
+interface IWithUser<UserT> {
+    user?: UserT;
+}
+export default class AuthUser<UserT> {
+    private user;
+    userConstructor?: Constructable<IWithId>;
+    AssignTo(item: IWithUser<UserT>): void;
+    setUserConstructor(userConstructor: Constructable<IWithId>): void;
+    get(): UserT | undefined;
+    set(user: UserT): void;
+    reset(): void;
+    actualize(): void;
+}
+export {};

package/dist/core/auth/buttons/AuthButton.d.ts

@@ -0,0 +1,11 @@
+import { default as AuthChunks } from '../types/AuthChunks';
+import { default as Button } from '../../ui/Btn';
+export default class AuthButton extends Button {
+    id: string;
+    chunk: AuthChunks;
+    text: string;
+    isSubmit: boolean;
+    isLink: boolean;
+    GetChunk(): AuthChunks;
+    constructor();
+}

package/dist/core/auth/buttons/AuthButtonLogin.d.ts

@@ -0,0 +1,8 @@
+import { default as AuthChunks } from '../types/AuthChunks';
+import { default as AuthButton } from './AuthButton';
+export default class AuthButtonLogin extends AuthButton {
+    id: string;
+    text: string;
+    isSubmit: boolean;
+    chunk: AuthChunks;
+}

package/dist/core/auth/buttons/AuthButtonRefresh.d.ts

@@ -0,0 +1,8 @@
+import { default as AuthChunks } from '../types/AuthChunks';
+import { default as AuthButton } from './AuthButton';
+export default class AuthButtonRefresh extends AuthButton {
+    id: string;
+    text: string;
+    isSubmit: boolean;
+    chunk: AuthChunks;
+}

package/dist/core/auth/buttons/AuthButtonRegister.d.ts

@@ -0,0 +1,8 @@
+import { default as AuthChunks } from '../types/AuthChunks';
+import { default as AuthButton } from './AuthButton';
+export default class AuthButtonLogin extends AuthButton {
+    id: string;
+    text: string;
+    isSubmit: boolean;
+    chunk: AuthChunks;
+}

package/dist/core/auth/buttons/AuthButtonRestore.d.ts

@@ -0,0 +1,8 @@
+import { default as AuthChunks } from '../types/AuthChunks';
+import { default as AuthButton } from './AuthButton';
+export default class AuthButtonRestore extends AuthButton {
+    id: string;
+    text: string;
+    isSubmit: boolean;
+    chunk: AuthChunks;
+}

package/dist/core/auth/fields/AuthField.d.ts

@@ -0,0 +1,8 @@
+import { default as AuthMethods } from '../types/AuthMethods';
+import { default as Input } from '../../ui/Input';
+export default class AuthField extends Input {
+    method?: AuthMethods;
+    id: string;
+    name: string;
+    get IsPassword(): boolean;
+}

package/dist/core/auth/fields/EmailField.d.ts

@@ -0,0 +1,14 @@
+import { default as AuthField } from './AuthField';
+import { default as AuthMethods } from '../types/AuthMethods';
+import { default as IValidator } from '../../interfaces/IValidator';
+import { default as AuthFieldsIds } from '../types/AuthFieldsIds';
+export declare class EmailField extends AuthField {
+    id: AuthFieldsIds;
+    label: string;
+    name: string;
+    placeholder: string;
+    validator?: IValidator;
+    method: AuthMethods;
+}
+declare const _default: EmailField;
+export default _default;

package/dist/core/auth/fields/LoginField.d.ts

@@ -0,0 +1,10 @@
+import { default as AuthField } from './AuthField';
+import { default as AuthMethods } from '../types/AuthMethods';
+import { default as IValidator } from '../../interfaces/IValidator';
+export default class Login extends AuthField {
+    label: string;
+    name: string;
+    validator?: IValidator;
+    method: AuthMethods;
+    id: string;
+}

package/dist/core/auth/fields/PasswordField.d.ts

@@ -0,0 +1,12 @@
+import { default as AuthField } from './AuthField';
+import { default as IValidator } from '../../interfaces/IValidator';
+import { default as AuthFieldsIds } from '../types/AuthFieldsIds';
+export declare class PasswordField extends AuthField {
+    label: string;
+    validator?: IValidator;
+    name: string;
+    placeholder: string;
+    id: AuthFieldsIds;
+}
+declare const _default: PasswordField;
+export default _default;

package/dist/core/auth/fields/PasswordRepeatField.d.ts

@@ -0,0 +1,8 @@
+import { default as AuthField } from './AuthField';
+import { default as AuthFieldsIds } from '../types/AuthFieldsIds';
+export declare class PasswordRepeatField extends AuthField {
+    label: string;
+    id: AuthFieldsIds;
+}
+declare const _default: PasswordRepeatField;
+export default _default;

package/dist/core/auth/index.d.ts

@@ -0,0 +1,15 @@
+import { default as Auth } from './Auth';
+import { default as AuthButtonLogin } from './buttons/AuthButtonLogin';
+import { default as AuthButtonRefresh } from './buttons/AuthButtonRefresh';
+import { default as AuthButtonRegister } from './buttons/AuthButtonRegister';
+import { default as AuthButtonRestore } from './buttons/AuthButtonRestore';
+import { default as EmailField } from './fields/EmailField';
+import { default as LoginField } from './fields/LoginField';
+import { default as PasswordField } from './fields/PasswordField';
+import { default as PasswordRepeatField } from './fields/PasswordRepeatField';
+import { default as AuthFormSettings } from './settings/AuthFormSettings';
+import { default as AuthChunks } from './types/AuthChunks';
+import { default as AuthFieldsIds } from './types/AuthFieldsIds';
+import { default as AuthFormSettingsType } from './types/AuthFormSettingsType';
+import { default as AuthMethods } from './types/AuthMethods';
+export { Auth, AuthButtonLogin, AuthButtonRefresh, AuthButtonRegister, AuthButtonRestore, AuthChunks, AuthFieldsIds, AuthFormSettings, AuthFormSettingsType, AuthMethods, EmailField, LoginField, PasswordField, PasswordRepeatField, };

package/dist/core/auth/settings/AuthFormSettings.d.ts

@@ -0,0 +1,45 @@
+import { default as AuthButtonLogin } from '../buttons/AuthButtonLogin';
+import { default as AuthButtonRefresh } from '../buttons/AuthButtonRefresh';
+import { default as AuthButtonRegister } from '../buttons/AuthButtonRegister';
+import { default as AuthButtonRestore } from '../buttons/AuthButtonRestore';
+import { default as AuthMethods } from '../types/AuthMethods';
+declare const AuthFormSettings: {
+    allowRestore: boolean;
+    login: {
+        methods: AuthMethods[];
+        title: string;
+        action: string;
+        buttons: (AuthButtonLogin | AuthButtonRegister | AuthButtonRestore)[];
+        fields: (import('../fields/EmailField').EmailField | import('../fields/PasswordField').PasswordField)[];
+        errorMessage: string;
+        successMessage: string;
+    };
+    register: {
+        methods: never[];
+        title: string;
+        action: string;
+        buttons: (AuthButtonLogin | AuthButtonRegister | AuthButtonRestore)[];
+        fields: (import('../fields/EmailField').EmailField | import('../fields/PasswordField').PasswordField | import('../fields/PasswordRepeatField').PasswordRepeatField)[];
+        errorMessage: string;
+        successMessage: string;
+    };
+    restore: {
+        title: string;
+        methods: never[];
+        action: string;
+        successMessage: string;
+        errorMessage: string;
+        buttons: AuthButtonRestore[];
+        fields: import('../fields/EmailField').EmailField[];
+    };
+    refresh: {
+        methods: never[];
+        title: string;
+        action: string;
+        successMessage: string;
+        errorMessage: string;
+        buttons: AuthButtonRefresh[];
+        fields: import('../fields/PasswordField').PasswordField[];
+    };
+};
+export default AuthFormSettings;

package/dist/core/auth/types/AuthChunks.d.ts

@@ -0,0 +1,7 @@
+declare enum AuthChunks {
+    Login = "login",
+    Register = "register",
+    Restore = "restore",
+    Refresh = "refresh"
+}
+export default AuthChunks;

package/dist/core/auth/types/AuthFieldsIds.d.ts

@@ -0,0 +1,6 @@
+declare enum AuthFieldsIds {
+    Email = "field-auth-email",
+    Password = "field-auth-password",
+    PasswordRepeat = "field-auth-password-repeat"
+}
+export default AuthFieldsIds;

package/dist/core/auth/types/AuthFormSettingsType.d.ts

@@ -0,0 +1,13 @@
+import { default as AuthButton } from '../buttons/AuthButton';
+import { default as AuthField } from '../fields/AuthField';
+import { default as AuthMethods } from './AuthMethods';
+type AuthPartSettings = {
+    title: string;
+    action: string;
+    fields: AuthField[];
+    methods: AuthMethods[];
+    buttons: AuthButton[];
+    errorMessage: string;
+    successMessage: string;
+};
+export default AuthPartSettings;

package/dist/core/auth/types/AuthMethods.d.ts

@@ -0,0 +1,8 @@
+declare enum AuthMethods {
+    Login = "login",
+    Email = "email",
+    Phone = "phone",
+    VK = "vk",
+    ESIA = "esia"
+}
+export default AuthMethods;

package/dist/core/classes/CallbackRequest.d.ts

@@ -0,0 +1,7 @@
+export default class CallbackRequest {
+    id?: string;
+    name: string;
+    description: string;
+    phone: string;
+    constructor(i?: CallbackRequest);
+}

package/dist/core/classes/Chat.d.ts

@@ -0,0 +1,7 @@
+import { default as ChatMessage } from './ChatMessage';
+export default class Chat {
+    id?: string;
+    chatMessages: ChatMessage[];
+    constructor(i?: Chat);
+    addChatMessages(message: ChatMessage): void;
+}

package/dist/core/classes/ChatMessage.d.ts

@@ -0,0 +1,20 @@
+export declare enum ChateMessageTypes {
+    Ping = "ping",
+    Enter = "enter",
+    Exit = "exit",
+    Message = "message",
+    Write = "write",
+    Empty = ""
+}
+export default class ChatMessage {
+    id?: string;
+    message: string;
+    userName?: string;
+    createdOn: Date;
+    chatId?: string;
+    type: ChateMessageTypes;
+    constructor(i?: ChatMessage);
+    static Create(chatId: string, userId: string | undefined, messageText: string, userName: string | undefined): ChatMessage;
+    static CreatePingMessage(): ChatMessage;
+    isMessage(): boolean;
+}