@nu-art/user-account-frontend 0.401.9 → 0.500.6

package/_ats/account-editor/ATS_AccountEditor.d.ts

@@ -1,6 +1,7 @@
 import './ATS_AccountEditor.scss';
-import { AppToolsScreen, ComponentSync } from '@nu-art/thunderstorm-frontend/index';
 import { DB_Account } from '@nu-art/user-account-shared';
+import { ComponentSync } from '@nu-art/thunder-widgets';
+import { AppToolsScreen } from '@nu-art/thunder-ui-modules';
 type Props = {};
 type State = {
     selectedUser?: DB_Account;

package/_ats/account-editor/ATS_AccountEditor.js

@@ -1,9 +1,11 @@
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 import './ATS_AccountEditor.scss';
-import { _className, Button, ComponentSync, LL_H_C, LL_V_L, TS_PropRenderer } from '@nu-art/thunderstorm-frontend/index';
 import { Component_AccountEditor } from '../../account-editor/Component_AccountEditor.js';
 import { generateUUID } from '@nu-art/ts-common';
-import { ModuleFE_Account } from '../../_entity/account/index.js';
+import { ModuleFE_Account } from '../../_entity/account/ModuleFE_Account.js';
+import { ComponentSync, LL_H_C, TS_PropRenderer } from '@nu-art/thunder-widgets';
+import { Button, LL_V_L } from '@nu-art/thunder-widgets/v3';
+import { _className } from '@nu-art/thunder-core';
 export class ATS_AccountEditor extends ComponentSync {
     static screen = {
         name: 'Accounts Editor',
@@ -12,12 +14,10 @@ export class ATS_AccountEditor extends ComponentSync {
         group: 'Permissions',
         modulesToAwait: [ModuleFE_Account]
     };
-    // ######################### Life Cycle #########################
     deriveStateFromProps(nextProps, state) {
         state = this.state ? { ...this.state } : {};
         return state;
     }
-    // ######################### Logic #########################
     setSelectedAccount = (account) => {
         if (!account)
             this.setState({ isPreview: false, selectedUser: undefined });

package/_ats/account-editor/ATS_AccountEditor.scss

@@ -21,8 +21,8 @@
       overflow: auto;
 
       .users-list {
-          cursor: pointer;
-          padding: 10px;
+        cursor: pointer;
+        padding: 10px;
 
         .row {
           &.selected {

package/_ats_session-data/ATS_SessionData.d.ts

@@ -1,4 +1,6 @@
-import { AppToolsScreen, ComponentSync, OnStorageKeyChangedListener } from '@nu-art/thunderstorm-frontend/index';
+import { ComponentSync } from '@nu-art/thunder-widgets';
+import { AppToolsScreen } from '@nu-art/thunder-ui-modules';
+import { OnStorageKeyChangedListener } from '@nu-art/thunder-core';
 type ATS_SessionData_Props = {};
 type ATS_SessionData_State = {
     sessionId?: string;

package/_ats_session-data/ATS_SessionData.js

@@ -1,7 +1,7 @@
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 import { __stringify } from '@nu-art/ts-common';
-import { ModuleFE_Account } from '../_entity/account/index.js';
-import { ComponentSync, LL_V_L, TS_Input, TS_TextArea } from '@nu-art/thunderstorm-frontend/index';
+import { ModuleFE_Account } from '../_entity/account/ModuleFE_Account.js';
+import { ComponentSync, LL_V_L, TS_Input, TS_TextArea } from '@nu-art/thunder-widgets';
 export class ATS_SessionData extends ComponentSync {
     static screen = { name: `SessionData`, renderer: this, group: 'Permissions' };
     static defaultProps = {

package/_entity/account/ModuleFE_Account.d.ts

@@ -1,14 +1,14 @@
 import * as React from 'react';
-import { ModuleFE_BaseApi, ThunderDispatcher } from '@nu-art/thunderstorm-frontend/index';
-import { ApiDefCaller } from '@nu-art/thunderstorm-shared';
-import { ApiStruct_Account, ApiStruct_SAML, DB_Account, DBProto_Account, PasswordAssertionConfig, UI_Account } from '@nu-art/user-account-shared';
-import { ApiCallerEventType } from '@nu-art/thunderstorm-frontend/core/db-api-gen/types';
+import { ModuleFE_BaseApi } from '@nu-art/db-api-frontend';
+import { ApiCallerEventType } from '@nu-art/db-api-shared';
+import { API_SAML, API_UserAccount, DatabaseDef_Account, DB_Account, PasswordAssertionConfig, UI_Account } from '@nu-art/user-account-shared';
 import { OnSessionUpdated } from '../session/ModuleFE_Session.js';
+import { ThunderDispatcher } from '@nu-art/thunder-core';
 export interface OnLoginStatusUpdated {
     __onLoginStatusUpdated: () => void;
 }
 export interface OnAccountsUpdated {
-    __onAccountsUpdated: (...params: ApiCallerEventType<DBProto_Account>) => void;
+    __onAccountsUpdated: (...params: ApiCallerEventType<DB_Account>) => void;
 }
 export declare enum LoggedStatus {
     VALIDATING = 0,
@@ -17,15 +17,25 @@ export declare enum LoggedStatus {
     LOGGED_IN = 3
 }
 export declare const dispatch_onLoginStatusChanged: ThunderDispatcher<OnLoginStatusUpdated, "__onLoginStatusUpdated", [], void>;
-export declare const dispatch_onAccountsUpdated: ThunderDispatcher<OnAccountsUpdated, "__onAccountsUpdated", ApiCallerEventType<DBProto_Account>, void>;
-type ApiDefCaller_Account = ApiDefCaller<{
-    _v1: ApiStruct_Account['_v1'] & ApiStruct_SAML['_v1'];
-}>;
-declare class ModuleFE_Account_Class extends ModuleFE_BaseApi<DBProto_Account> implements ApiDefCaller_Account, OnLoginStatusUpdated, OnSessionUpdated {
-    readonly _v1: ApiDefCaller_Account['_v1'];
+export declare const dispatch_onAccountsUpdated: ThunderDispatcher<OnAccountsUpdated, "__onAccountsUpdated", ApiCallerEventType<DB_Account>, void>;
+declare class ModuleFE_Account_Class extends ModuleFE_BaseApi<DatabaseDef_Account> implements OnLoginStatusUpdated, OnSessionUpdated {
     private status;
     __onLoginStatusUpdated(): void;
     constructor();
+    refreshSession(_params?: API_UserAccount['refreshSession']['Params']): Promise<API_UserAccount['refreshSession']['Response']>;
+    registerAccount(body: API_UserAccount['registerAccount']['Body']): Promise<API_UserAccount['registerAccount']['Response']>;
+    createAccount(body: API_UserAccount['createAccount']['Body']): Promise<API_UserAccount['createAccount']['Response']>;
+    changePassword(body: API_UserAccount['changePassword']['Body']): Promise<API_UserAccount['changePassword']['Response']>;
+    login(body: API_UserAccount['login']['Body']): Promise<API_UserAccount['login']['Response']>;
+    logout(_params?: API_UserAccount['logout']['Params']): Promise<API_UserAccount['logout']['Response']>;
+    createToken(body: API_UserAccount['createToken']['Body']): Promise<API_UserAccount['createToken']['Response']>;
+    setPassword(body: API_UserAccount['setPassword']['Body']): Promise<API_UserAccount['setPassword']['Response']>;
+    getSessions(params: API_UserAccount['getSessions']['Params']): Promise<API_UserAccount['getSessions']['Response']>;
+    changeThumbnail(body: API_UserAccount['changeThumbnail']['Body']): Promise<API_UserAccount['changeThumbnail']['Response']>;
+    loginSaml(params: API_SAML['loginSaml']['Params']): Promise<API_SAML['loginSaml']['Response']>;
+    assertSAML(body: API_SAML['assertSAML']['Body']): Promise<API_SAML['assertSAML']['Response']>;
+    getPasswordAssertionConfig(_params?: API_UserAccount['getPasswordAssertionConfig']['Params']): Promise<API_UserAccount['getPasswordAssertionConfig']['Response']>;
+    deleteAccount(params: API_UserAccount['deleteAccount']['Params']): Promise<API_UserAccount['deleteAccount']['Response']>;
     protected init(): void;
     getAccounts(): UI_Account[];
     getLoggedStatus: () => LoggedStatus;
@@ -33,15 +43,16 @@ declare class ModuleFE_Account_Class extends ModuleFE_BaseApi<DBProto_Account> i
     __onSessionUpdated(): void;
     protected setLoggedStatus: (newStatus: LoggedStatus) => void;
     composeSAMLUrl: () => string;
-    logout: (url?: string) => Promise<string | undefined>;
+    performLogout: (url?: string) => Promise<string | undefined>;
     uploadAccountThumbnail: (e: React.MouseEvent, account: DB_Account) => void;
     private encodeFile;
-    getPasswordAssertionConfig: () => PasswordAssertionConfig | undefined;
+    passwordAssertionConfig: () => PasswordAssertionConfig | undefined;
     getCurrentlyLoggedAccount: () => import("@nu-art/user-account-shared").UI_SessionAccount;
     private onAccountCreated;
     private onThumbnailChanged;
     private onLoginCompletedSAML;
     private onPasswordAssertionConfig;
+    private onAccountDeleted;
 }
 export declare const ModuleFE_Account: ModuleFE_Account_Class;
 export {};

package/_entity/account/ModuleFE_Account.js

@@ -1,10 +1,46 @@
-import { apiWithBody, apiWithQuery, ModuleFE_BaseApi, ModuleFE_XHR, readFileContent, StorageKey, ThunderDispatcher } from '@nu-art/thunderstorm-frontend/index';
-import { HeaderKey_DeviceId, HeaderKey_TabId } from '@nu-art/thunderstorm-shared';
-import { dispatcher_onAuthRequired } from '@nu-art/thunderstorm-shared/no-auth-listener';
-import { ApiDef_Account, ApiDef_SAML, DBDef_Accounts, QueryParam_SessionId } from '@nu-art/user-account-shared';
+var __runInitializers = (this && this.__runInitializers) || function (thisArg, initializers, value) {
+    var useValue = arguments.length > 2;
+    for (var i = 0; i < initializers.length; i++) {
+        value = useValue ? initializers[i].call(thisArg, value) : initializers[i].call(thisArg);
+    }
+    return useValue ? value : void 0;
+};
+var __esDecorate = (this && this.__esDecorate) || function (ctor, descriptorIn, decorators, contextIn, initializers, extraInitializers) {
+    function accept(f) { if (f !== void 0 && typeof f !== "function") throw new TypeError("Function expected"); return f; }
+    var kind = contextIn.kind, key = kind === "getter" ? "get" : kind === "setter" ? "set" : "value";
+    var target = !descriptorIn && ctor ? contextIn["static"] ? ctor : ctor.prototype : null;
+    var descriptor = descriptorIn || (target ? Object.getOwnPropertyDescriptor(target, contextIn.name) : {});
+    var _, done = false;
+    for (var i = decorators.length - 1; i >= 0; i--) {
+        var context = {};
+        for (var p in contextIn) context[p] = p === "access" ? {} : contextIn[p];
+        for (var p in contextIn.access) context.access[p] = contextIn.access[p];
+        context.addInitializer = function (f) { if (done) throw new TypeError("Cannot add initializers after decoration has completed"); extraInitializers.push(accept(f || null)); };
+        var result = (0, decorators[i])(kind === "accessor" ? { get: descriptor.get, set: descriptor.set } : descriptor[key], context);
+        if (kind === "accessor") {
+            if (result === void 0) continue;
+            if (result === null || typeof result !== "object") throw new TypeError("Object expected");
+            if (_ = accept(result.get)) descriptor.get = _;
+            if (_ = accept(result.set)) descriptor.set = _;
+            if (_ = accept(result.init)) initializers.unshift(_);
+        }
+        else if (_ = accept(result)) {
+            if (kind === "field") initializers.unshift(_);
+            else descriptor[key] = _;
+        }
+    }
+    if (target) Object.defineProperty(target, contextIn.name, descriptor);
+    done = true;
+};
+import { buildConfigFromDBDef, ModuleFE_BaseApi } from '@nu-art/db-api-frontend';
+import { ApiCaller, HttpClient } from '@nu-art/http-client';
+import { CrudApiDef } from '@nu-art/db-api-shared';
+import { ApiDef_SAML, ApiDef_UserAccount, DBDef_Accounts, HeaderKey_DeviceId, HeaderKey_TabId, QueryParam_SessionId } from '@nu-art/user-account-shared';
 import { SessionKeyFE_Account, StorageKey_DeviceId, StorageKey_TabId } from './consts.js';
 import { asArray, cloneObj, composeUrl, Exception, generateHex, KB } from '@nu-art/ts-common';
 import { ModuleFE_Session } from '../session/ModuleFE_Session.js';
+import { readFileAs_ArrayBuffer, StorageKey, ThunderDispatcher } from '@nu-art/thunder-core';
+import { dispatcher_onAuthRequired } from '../session/no-auth-listener.js';
 export var LoggedStatus;
 (function (LoggedStatus) {
     LoggedStatus[LoggedStatus["VALIDATING"] = 0] = "VALIDATING";
@@ -15,142 +51,222 @@ export var LoggedStatus;
 export const dispatch_onLoginStatusChanged = new ThunderDispatcher('__onLoginStatusUpdated');
 export const dispatch_onAccountsUpdated = new ThunderDispatcher('__onAccountsUpdated');
 const StorageKey_PasswordAssertionConfig = new StorageKey('account__password-assertion-config', false);
-class ModuleFE_Account_Class extends ModuleFE_BaseApi {
-    _v1;
-    status = LoggedStatus.LOGGED_OUT;
-    __onLoginStatusUpdated() {
-        //Get the password assertion config if needed
-        if ([LoggedStatus.LOGGED_OUT, LoggedStatus.SESSION_TIMEOUT].includes(this.status))
-            this._v1.getPasswordAssertionConfig({}).executeSync();
-    }
-    constructor() {
-        super(DBDef_Accounts, dispatch_onAccountsUpdated);
-        // const login = apiWithBody(ApiDef_Account._v1.login, this.setLoginInfo);
-        this._v1 = {
-            refreshSession: apiWithQuery(ApiDef_Account._v1.refreshSession),
-            registerAccount: apiWithBody(ApiDef_Account._v1.registerAccount),
-            createAccount: apiWithBody(ApiDef_Account._v1.createAccount, this.onAccountCreated),
-            changePassword: apiWithBody(ApiDef_Account._v1.changePassword),
-            login: apiWithBody(ApiDef_Account._v1.login),
-            // login: (account: Account_Login['request']) => {
-            //
-            // 	toUpsert = this.cleanUp(toUpsert);
-            // 	this.validateInternal(toUpsert);
-            // 	return this.updatePending(toUpsert as DB_BaseObject, upsert(toUpsert), 'upsert');
-            // },
-            logout: apiWithQuery(ApiDef_Account._v1.logout),
-            createToken: apiWithBody(ApiDef_Account._v1.createToken),
-            setPassword: apiWithBody(ApiDef_Account._v1.setPassword),
-            getSessions: apiWithQuery(ApiDef_Account._v1.getSessions),
-            changeThumbnail: apiWithBody(ApiDef_Account._v1.changeThumbnail, this.onThumbnailChanged),
-            loginSaml: apiWithQuery(ApiDef_SAML._v1.loginSaml, this.onLoginCompletedSAML),
-            assertSAML: apiWithBody(ApiDef_SAML._v1.assertSAML),
-            getPasswordAssertionConfig: apiWithQuery(ApiDef_Account._v1.getPasswordAssertionConfig, this.onPasswordAssertionConfig),
-            deleteAccount: apiWithQuery(ApiDef_Account._v1.deleteAccount, async (response) => {
-                await this.onEntryDeleted(response.account);
-            }),
-        };
-    }
-    init() {
-        super.init();
-        let defaultTabId = StorageKey_TabId.get();
-        let defaultDeviceId = StorageKey_DeviceId.get();
-        if (!defaultDeviceId) {
-            defaultDeviceId = generateHex(32);
-            console.log(`Defining new device Id: ${defaultDeviceId}`);
-            StorageKey_DeviceId.set(defaultDeviceId);
-        }
-        if (!defaultTabId) {
-            defaultTabId = generateHex(32);
-            console.log(`Defining new tab Id: ${defaultTabId}`);
-            StorageKey_TabId.set(defaultTabId);
-        }
-        ModuleFE_XHR.addDefaultHeader(HeaderKey_DeviceId, () => defaultDeviceId);
-        ModuleFE_XHR.addDefaultHeader(HeaderKey_TabId, defaultTabId);
-    }
-    // ######################## Logic ########################
-    getAccounts() {
-        return this.cache.all().map(i => cloneObj(i));
-    }
-    getLoggedStatus = () => this.status;
-    isStatus = (status) => asArray(status).includes(this.status);
-    __onSessionUpdated() {
-        if (!ModuleFE_Session.hasSession())
-            return this.setLoggedStatus(LoggedStatus.LOGGED_OUT);
-        if (!ModuleFE_Session.isSessionValid())
-            return this.setLoggedStatus(LoggedStatus.SESSION_TIMEOUT);
-        return this.setLoggedStatus(LoggedStatus.LOGGED_IN);
-    }
-    setLoggedStatus = (newStatus) => {
-        if (this.status === newStatus)
-            return;
-        const pervStatus = this.status;
-        this.status = newStatus;
-        this.logInfo(`Login status changes: ${LoggedStatus[pervStatus]} => ${LoggedStatus[newStatus]}`);
-        dispatch_onLoginStatusChanged.dispatchUI();
-        dispatch_onLoginStatusChanged.dispatchModule();
-    };
-    composeSAMLUrl = () => {
-        const params = new URLSearchParams(window.location.search);
-        const paramsObj = {};
-        for (const [key, value] of params) {
-            paramsObj[key] = value;
-        }
-        return composeUrl(window.location.origin + window.location.pathname, {
-            ...paramsObj,
-            [QueryParam_SessionId]: QueryParam_SessionId.toUpperCase(),
-        });
-    };
-    logout = async (url) => {
-        await this._v1.logout({}).executeSync();
-        dispatcher_onAuthRequired.dispatchModule(undefined);
-        if (url)
-            return window.location.href = url;
-    };
-    uploadAccountThumbnail = (e, account) => {
-        const input = document.createElement('input');
-        input.type = 'file';
-        // input.accept = '.jpg,.jpeg,.png';
-        input.style.display = 'none';
-        input.addEventListener('change', async (e) => {
-            const file = input.files[0];
-            if (!file)
-                return;
-            try {
-                const hash = await this.encodeFile(file);
-                await this._v1.changeThumbnail({ accountId: account._id, hash }).executeSync();
+let ModuleFE_Account_Class = (() => {
+    let _classSuper = ModuleFE_BaseApi;
+    let _instanceExtraInitializers = [];
+    let _refreshSession_decorators;
+    let _registerAccount_decorators;
+    let _createAccount_decorators;
+    let _changePassword_decorators;
+    let _login_decorators;
+    let _logout_decorators;
+    let _createToken_decorators;
+    let _setPassword_decorators;
+    let _getSessions_decorators;
+    let _changeThumbnail_decorators;
+    let _loginSaml_decorators;
+    let _assertSAML_decorators;
+    let _getPasswordAssertionConfig_decorators;
+    let _deleteAccount_decorators;
+    return class ModuleFE_Account_Class extends _classSuper {
+        static {
+            const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
+            _refreshSession_decorators = [ApiCaller(ApiDef_UserAccount.refreshSession)];
+            _registerAccount_decorators = [ApiCaller(ApiDef_UserAccount.registerAccount)];
+            _createAccount_decorators = [ApiCaller(ApiDef_UserAccount.createAccount, { onComplete: (m, ctx) => m.onAccountCreated(ctx) })];
+            _changePassword_decorators = [ApiCaller(ApiDef_UserAccount.changePassword)];
+            _login_decorators = [ApiCaller(ApiDef_UserAccount.login)];
+            _logout_decorators = [ApiCaller(ApiDef_UserAccount.logout)];
+            _createToken_decorators = [ApiCaller(ApiDef_UserAccount.createToken)];
+            _setPassword_decorators = [ApiCaller(ApiDef_UserAccount.setPassword)];
+            _getSessions_decorators = [ApiCaller(ApiDef_UserAccount.getSessions)];
+            _changeThumbnail_decorators = [ApiCaller(ApiDef_UserAccount.changeThumbnail, { onComplete: (m, ctx) => m.onThumbnailChanged(ctx) })];
+            _loginSaml_decorators = [ApiCaller(ApiDef_SAML.loginSaml, { onComplete: (m, ctx) => m.onLoginCompletedSAML(ctx) })];
+            _assertSAML_decorators = [ApiCaller(ApiDef_SAML.assertSAML)];
+            _getPasswordAssertionConfig_decorators = [ApiCaller(ApiDef_UserAccount.getPasswordAssertionConfig, { onComplete: (m, ctx) => m.onPasswordAssertionConfig(ctx) })];
+            _deleteAccount_decorators = [ApiCaller(ApiDef_UserAccount.deleteAccount, { onComplete: (m, ctx) => m.onAccountDeleted(ctx) })];
+            __esDecorate(this, null, _refreshSession_decorators, { kind: "method", name: "refreshSession", static: false, private: false, access: { has: obj => "refreshSession" in obj, get: obj => obj.refreshSession }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(this, null, _registerAccount_decorators, { kind: "method", name: "registerAccount", static: false, private: false, access: { has: obj => "registerAccount" in obj, get: obj => obj.registerAccount }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(this, null, _createAccount_decorators, { kind: "method", name: "createAccount", static: false, private: false, access: { has: obj => "createAccount" in obj, get: obj => obj.createAccount }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(this, null, _changePassword_decorators, { kind: "method", name: "changePassword", static: false, private: false, access: { has: obj => "changePassword" in obj, get: obj => obj.changePassword }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(this, null, _login_decorators, { kind: "method", name: "login", static: false, private: false, access: { has: obj => "login" in obj, get: obj => obj.login }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(this, null, _logout_decorators, { kind: "method", name: "logout", static: false, private: false, access: { has: obj => "logout" in obj, get: obj => obj.logout }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(this, null, _createToken_decorators, { kind: "method", name: "createToken", static: false, private: false, access: { has: obj => "createToken" in obj, get: obj => obj.createToken }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(this, null, _setPassword_decorators, { kind: "method", name: "setPassword", static: false, private: false, access: { has: obj => "setPassword" in obj, get: obj => obj.setPassword }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(this, null, _getSessions_decorators, { kind: "method", name: "getSessions", static: false, private: false, access: { has: obj => "getSessions" in obj, get: obj => obj.getSessions }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(this, null, _changeThumbnail_decorators, { kind: "method", name: "changeThumbnail", static: false, private: false, access: { has: obj => "changeThumbnail" in obj, get: obj => obj.changeThumbnail }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(this, null, _loginSaml_decorators, { kind: "method", name: "loginSaml", static: false, private: false, access: { has: obj => "loginSaml" in obj, get: obj => obj.loginSaml }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(this, null, _assertSAML_decorators, { kind: "method", name: "assertSAML", static: false, private: false, access: { has: obj => "assertSAML" in obj, get: obj => obj.assertSAML }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(this, null, _getPasswordAssertionConfig_decorators, { kind: "method", name: "getPasswordAssertionConfig", static: false, private: false, access: { has: obj => "getPasswordAssertionConfig" in obj, get: obj => obj.getPasswordAssertionConfig }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(this, null, _deleteAccount_decorators, { kind: "method", name: "deleteAccount", static: false, private: false, access: { has: obj => "deleteAccount" in obj, get: obj => obj.deleteAccount }, metadata: _metadata }, null, _instanceExtraInitializers);
+            if (_metadata) Object.defineProperty(this, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+        }
+        status = (__runInitializers(this, _instanceExtraInitializers), LoggedStatus.LOGGED_OUT);
+        __onLoginStatusUpdated() {
+            if ([LoggedStatus.LOGGED_OUT, LoggedStatus.SESSION_TIMEOUT].includes(this.status))
+                void this.getPasswordAssertionConfig({});
+        }
+        constructor() {
+            super({
+                config: buildConfigFromDBDef(DBDef_Accounts),
+                crudApiDef: CrudApiDef(DBDef_Accounts.dbKey),
+                dispatcher: (...args) => dispatch_onAccountsUpdated.dispatchAll(...args)
+            });
+        }
+        async refreshSession(_params) {
+            return undefined;
+        }
+        async registerAccount(body) {
+            void body;
+            return undefined;
+        }
+        async createAccount(body) {
+            void body;
+            return undefined;
+        }
+        async changePassword(body) {
+            void body;
+            return undefined;
+        }
+        async login(body) {
+            void body;
+            return undefined;
+        }
+        async logout(_params) {
+            return undefined;
+        }
+        async createToken(body) {
+            void body;
+            return undefined;
+        }
+        async setPassword(body) {
+            void body;
+            return undefined;
+        }
+        async getSessions(params) {
+            void params;
+            return undefined;
+        }
+        async changeThumbnail(body) {
+            void body;
+            return undefined;
+        }
+        async loginSaml(params) {
+            void params;
+            return undefined;
+        }
+        async assertSAML(body) {
+            void body;
+            return undefined;
+        }
+        async getPasswordAssertionConfig(_params) {
+            return undefined;
+        }
+        async deleteAccount(params) {
+            void params;
+            return undefined;
+        }
+        init() {
+            super.init();
+            let defaultTabId = StorageKey_TabId.get();
+            let defaultDeviceId = StorageKey_DeviceId.get();
+            if (!defaultDeviceId) {
+                defaultDeviceId = generateHex(32);
+                console.log(`Defining new device Id: ${defaultDeviceId}`);
+                StorageKey_DeviceId.set(defaultDeviceId);
             }
-            catch (err) {
-                this.logError(err.message, err);
+            if (!defaultTabId) {
+                defaultTabId = generateHex(32);
+                console.log(`Defining new tab Id: ${defaultTabId}`);
+                StorageKey_TabId.set(defaultTabId);
             }
-        });
-        input.click();
-    };
-    encodeFile = async (file) => {
-        const arrayBuffer = await readFileContent(file);
-        if (arrayBuffer.byteLength > 200 * KB)
-            throw new Exception('File size exceeds 200KB');
-        const buffer = new Uint8Array(arrayBuffer);
-        return window.btoa(buffer.reduce((acc, byte) => acc + String.fromCharCode(byte), ''));
-    };
-    getPasswordAssertionConfig = () => StorageKey_PasswordAssertionConfig.get();
-    getCurrentlyLoggedAccount = () => {
-        return SessionKeyFE_Account.get();
-    };
-    // ######################## API Callbacks ########################
-    onAccountCreated = async (response) => {
-        await this.onEntriesUpdated([response]);
-    };
-    onThumbnailChanged = async (response) => {
-        await this.onEntryUpdated(response.account, response.account);
-    };
-    onLoginCompletedSAML = async (response) => {
-        if (!response.loginUrl)
-            return;
-        window.location.href = response.loginUrl;
-    };
-    onPasswordAssertionConfig = async (response) => {
-        StorageKey_PasswordAssertionConfig.set(response.config);
+            HttpClient.default.addDefaultHeader(HeaderKey_DeviceId, () => defaultDeviceId);
+            HttpClient.default.addDefaultHeader(HeaderKey_TabId, () => defaultTabId);
+        }
+        getAccounts() {
+            return this.cache.all().map(i => cloneObj(i));
+        }
+        getLoggedStatus = () => this.status;
+        isStatus = (status) => asArray(status).includes(this.status);
+        __onSessionUpdated() {
+            if (!ModuleFE_Session.hasSession())
+                return this.setLoggedStatus(LoggedStatus.LOGGED_OUT);
+            if (!ModuleFE_Session.isSessionValid())
+                return this.setLoggedStatus(LoggedStatus.SESSION_TIMEOUT);
+            return this.setLoggedStatus(LoggedStatus.LOGGED_IN);
+        }
+        setLoggedStatus = (newStatus) => {
+            if (this.status === newStatus)
+                return;
+            const pervStatus = this.status;
+            this.status = newStatus;
+            this.logInfo(`Login status changes: ${LoggedStatus[pervStatus]} => ${LoggedStatus[newStatus]}`);
+            dispatch_onLoginStatusChanged.dispatchAll();
+        };
+        composeSAMLUrl = () => {
+            const params = new URLSearchParams(window.location.search);
+            const paramsObj = {};
+            for (const [key, value] of params) {
+                paramsObj[key] = value;
+            }
+            return composeUrl(window.location.origin + window.location.pathname, {
+                ...paramsObj,
+                [QueryParam_SessionId]: QueryParam_SessionId.toUpperCase(),
+            });
+        };
+        performLogout = async (url) => {
+            await this.logout({});
+            dispatcher_onAuthRequired.dispatchModule();
+            if (url)
+                return window.location.href = url;
+        };
+        uploadAccountThumbnail = (e, account) => {
+            const input = document.createElement('input');
+            input.type = 'file';
+            // input.accept = '.jpg,.jpeg,.png';
+            input.style.display = 'none';
+            input.addEventListener('change', async (e) => {
+                const file = input.files[0];
+                if (!file)
+                    return;
+                try {
+                    const hash = await this.encodeFile(file);
+                    await this.changeThumbnail({ accountId: account._id, hash });
+                }
+                catch (err) {
+                    this.logError(err.message, err);
+                }
+            });
+            input.click();
+        };
+        encodeFile = async (file) => {
+            const arrayBuffer = await readFileAs_ArrayBuffer(file);
+            if (arrayBuffer.byteLength > 200 * KB)
+                throw new Exception('File size exceeds 200KB');
+            const buffer = new Uint8Array(arrayBuffer);
+            return window.btoa(buffer.reduce((acc, byte) => acc + String.fromCharCode(byte), ''));
+        };
+        passwordAssertionConfig = () => StorageKey_PasswordAssertionConfig.get();
+        getCurrentlyLoggedAccount = () => {
+            return SessionKeyFE_Account.get();
+        };
+        onAccountCreated = async (ctx) => {
+            await this.onEntriesUpdated([ctx.response]);
+        };
+        onThumbnailChanged = async (ctx) => {
+            await this.onEntryUpdated(ctx.response.account, ctx.response.account);
+        };
+        onLoginCompletedSAML = async (ctx) => {
+            if (!ctx.response.loginUrl)
+                return;
+            window.location.href = ctx.response.loginUrl;
+        };
+        onPasswordAssertionConfig = async (ctx) => {
+            StorageKey_PasswordAssertionConfig.set(ctx.response.config);
+        };
+        onAccountDeleted = async (ctx) => {
+            await this.onEntryDeleted(ctx.response.account);
+        };
     };
-}
+})();
 export const ModuleFE_Account = new ModuleFE_Account_Class();

package/_entity/account/consts.d.ts

@@ -1,7 +1,7 @@
-import { StorageKey } from '@nu-art/thunderstorm-frontend/index';
 import { _SessionKey_Account, DB_Account } from '@nu-art/user-account-shared';
 import { SessionKey_FE } from '../session/ModuleFE_Session.js';
 import { TypedKeyValue } from '@nu-art/ts-common';
+import { StorageKey } from '@nu-art/thunder-core';
 export declare const SessionKeyFE_Account: SessionKey_FE<_SessionKey_Account>;
 export declare const StorageKey_DeviceId: StorageKey<string>;
 export declare const StorageKey_TabId: StorageKey<string>;

package/_entity/account/consts.js

@@ -1,6 +1,6 @@
-import { StorageKey } from '@nu-art/thunderstorm-frontend/index';
-import { HeaderKey_DeviceId, HeaderKey_TabId } from '@nu-art/thunderstorm-shared/headers';
+import { HeaderKey_DeviceId, HeaderKey_TabId } from '@nu-art/user-account-shared';
 import { SessionKey_FE } from '../session/ModuleFE_Session.js';
+import { StorageKey } from '@nu-art/thunder-core';
 export const SessionKeyFE_Account = new SessionKey_FE('account');
 export const StorageKey_DeviceId = new StorageKey(`storage--${HeaderKey_DeviceId}`).withstandDeletion();
 export const StorageKey_TabId = new StorageKey(`storage--${HeaderKey_TabId}`, false).withstandDeletion();

package/_entity/session/ModuleFE_Session.d.ts

@@ -1,7 +1,6 @@
-import { OnStorageKeyChangedListener, StorageKey, ThunderDispatcher } from '@nu-art/thunderstorm-frontend/index';
+import { OnStorageKeyChangedListener, StorageKey, ThunderDispatcher } from '@nu-art/thunder-core';
 import { Module, ResolvableContent, TS_Object, TypedKeyValue } from '@nu-art/ts-common';
-import { BaseHttpRequest } from '@nu-art/thunderstorm-shared';
-import { OnAuthRequiredListener } from '@nu-art/thunderstorm-shared/no-auth-listener';
+import { OnAuthRequiredListener } from './no-auth-listener.js';
 export interface OnSessionUpdated {
     __onSessionUpdated: VoidFunction;
 }
@@ -23,7 +22,7 @@ declare class ModuleFE_Session_Class extends Module implements OnStorageKeyChang
     init(): void;
     setSessionKey(sessionKey: ResolvableContent<string>): void;
     __onStorageKeyEvent(event: StorageEvent): Promise<void>;
-    __onAuthRequiredListener(request: BaseHttpRequest<any>): void;
+    __onAuthRequiredListener(): void;
     private onSessionUpdated;
     hasSession(): boolean;
     isSessionValid(): Promise<boolean>;