@nu-art/user-account-frontend 0.400.5

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

@@ -0,0 +1,15 @@
+import './ATS_AccountEditor.scss';
+import { AppToolsScreen, ComponentSync } from '@nu-art/thunderstorm-frontend/index';
+import { DB_Account } from '@nu-art/user-account-shared';
+type Props = {};
+type State = {
+    selectedUser?: DB_Account;
+    isPreview?: boolean;
+};
+export declare class ATS_AccountEditor extends ComponentSync<Props, State> {
+    static screen: AppToolsScreen;
+    protected deriveStateFromProps(nextProps: {}, state: State): State;
+    private setSelectedAccount;
+    render(): import("react/jsx-runtime").JSX.Element;
+}
+export {};

package/_ats/account-editor/ATS_AccountEditor.js

@@ -0,0 +1,45 @@
+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';
+export class ATS_AccountEditor extends ComponentSync {
+    static screen = {
+        name: 'Accounts Editor',
+        key: 'user-account',
+        renderer: this,
+        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 });
+        else
+            this.setState({ isPreview: true, selectedUser: account });
+    };
+    render() {
+        return _jsxs(LL_H_C, { className: 'account-editor-form', children: [_jsx(Component_AccountList, { user: this.state.selectedUser, setSelectedAccount: this.setSelectedAccount }), _jsx(Component_AccountEditor, { isPreview: this.state.isPreview, user: this.state.selectedUser })] });
+    }
+}
+class Component_AccountList extends ComponentSync {
+    __onAccountsUpdated(...params) {
+        this.reDeriveState();
+    }
+    deriveStateFromProps(nextProps, state) {
+        state.list = ModuleFE_Account.cache.allMutable();
+        return state;
+    }
+    render() {
+        return _jsxs(LL_V_L, { className: 'form-container account-list', children: [_jsx(LL_H_C, { className: 'match_width', children: _jsx(TS_PropRenderer.Horizontal, { className: 'match_width', label: 'Accounts List', children: _jsx(Button, { variant: 'primary', onClick: async () => this.props.setSelectedAccount(), children: "Create Account" }) }) }), _jsx(LL_V_L, { className: 'match_width users-list', children: this.state.list.map(account => {
+                        const className = _className('match_width', 'row', this.props.user?._id === account._id && 'selected');
+                        return _jsx(TS_PropRenderer.Horizontal, { onClick: () => this.props.setSelectedAccount(account), className: className, label: account.email }, generateUUID());
+                    }) })] });
+    }
+}

package/_ats/account-editor/ATS_AccountEditor.scss

@@ -0,0 +1,127 @@
+@use '@nu-art/ts-styles' as styles;
+
+.account-editor-form {
+  width: 100%;
+  height: 100%;
+  padding: 15px 35px 35px 35px;
+  align-items: flex-start;
+  gap: 5%;
+
+
+  .form-container {
+    padding: 14px;
+    width: 650px;
+    background: white;
+    border-radius: 4px;
+    gap: 15px;
+
+    &.account-list {
+      width: 300px;
+      max-height: 100%;
+      overflow: auto;
+
+      .users-list {
+          cursor: pointer;
+          padding: 10px;
+
+        .row {
+          &.selected {
+            background: styles.dark-blue(7);
+          }
+
+          &:not(:last-child) {
+            border-bottom: 1px solid styles.gray(6);
+          }
+        }
+      }
+    }
+
+    .user-utils {
+      .icon--wrapper {
+        cursor: pointer;
+
+        @include styles.color-svg(var(--prop-renderer__label-color));
+      }
+    }
+
+    .ts-prop-renderer {
+      &.horizontal {
+        justify-content: space-between;
+      }
+    }
+
+    .inputs-row {
+      justify-content: space-between;
+      width: 100%;
+    }
+
+    .ts-input {
+      padding: 2px 10px 2px 10px;
+      border-radius: 4px;
+      background: none;
+      border: 1px solid #e3e9f2;
+
+      &::placeholder {
+        font-style: normal;
+      }
+    }
+
+    .ts-dropdown {
+      max-width: 300px;
+
+      .ts-dropdown__items-container {
+        margin: 0;
+      }
+
+      .ts-dropdown__header {
+        background: none;
+        border-radius: 4px;
+        border: 1px solid #e3e9f2;
+        padding: 2px 10px 2px 10px;
+        text-align: center;
+
+        .ts-dropdown__placeholder {
+          font-style: normal;
+          padding: 0;
+        }
+      }
+
+      .ts-dropdown__items-container {
+        border: none;
+      }
+
+
+      .ts-tree {
+        .ts-tree__children-container {
+          .ts-tree__node {
+            background: none;
+            padding: 4px;
+            cursor: pointer;
+            border: 1px solid #e3e9f2;
+
+            &:hover {
+              background: rgb(210, 219, 234);
+            }
+          }
+        }
+      }
+    }
+
+    .ts-busy-button {
+      background: white;
+      font-size: 12px;
+      border-radius: 5px;
+      color: inherit;
+      padding: 2px 10px 2px 10px;
+      height: 40px;
+      font-weight: 400;
+      border: 1px #e3e9f2 solid;
+      margin-inline: 0;
+
+      &:hover {
+        background: #6C87B0FF;
+        color: white;
+      }
+    }
+  }
+}

package/_ats_session-data/ATS_SessionData.d.ts

@@ -0,0 +1,18 @@
+import { AppToolsScreen, ComponentSync, OnStorageKeyChangedListener } from '@nu-art/thunderstorm-frontend/index';
+type ATS_SessionData_Props = {};
+type ATS_SessionData_State = {
+    sessionId?: string;
+};
+export declare class ATS_SessionData extends ComponentSync<ATS_SessionData_Props, ATS_SessionData_State> implements OnStorageKeyChangedListener {
+    static screen: AppToolsScreen;
+    static defaultProps: {
+        modules: never[];
+        pageTitle: () => string;
+    };
+    protected deriveStateFromProps(nextProps: ATS_SessionData_Props, state: ATS_SessionData_State): ATS_SessionData_State;
+    constructor(p: ATS_SessionData_Props);
+    __onStorageKeyEvent(event: StorageEvent): Promise<void>;
+    private getDecodedSessionId;
+    render(): import("react/jsx-runtime").JSX.Element;
+}
+export {};

package/_ats_session-data/ATS_SessionData.js

@@ -0,0 +1,40 @@
+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';
+export class ATS_SessionData extends ComponentSync {
+    static screen = { name: `SessionData`, renderer: this, group: 'Permissions' };
+    static defaultProps = {
+        modules: [],
+        pageTitle: () => this.screen.name
+    };
+    deriveStateFromProps(nextProps, state) {
+        state = this.state ?? {};
+        return state;
+    }
+    constructor(p) {
+        super(p);
+    }
+    async __onStorageKeyEvent(event) {
+        this.forceUpdate();
+    }
+    getDecodedSessionId() {
+        try {
+            if (this.state.sessionId && this.state.sessionId.length) { // @ts-ignore
+                return __stringify(ModuleFE_Account.decode(this.state.sessionId), true);
+            }
+            // @ts-ignore
+            return __stringify(ModuleFE_Account.sessionData, true);
+        }
+        catch (e) {
+            // @ts-ignore
+            return __stringify(ModuleFE_Account.sessionData, true);
+        }
+    }
+    render() {
+        const sessionDataAsJson = this.getDecodedSessionId();
+        return _jsxs(LL_V_L, { className: 'match_parent', children: [_jsx(TS_Input, { type: 'text', onBlur: (value) => {
+                        this.setState({ sessionId: value });
+                    } }), _jsx(TS_TextArea, { style: { fontFamily: 'monospace', fontSize: 15 }, type: "text", value: sessionDataAsJson, disabled: true })] });
+    }
+}

package/_entity/account/ModuleFE_Account.d.ts

@@ -0,0 +1,47 @@
+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 { OnSessionUpdated } from '../session/ModuleFE_Session.js';
+export interface OnLoginStatusUpdated {
+    __onLoginStatusUpdated: () => void;
+}
+export interface OnAccountsUpdated {
+    __onAccountsUpdated: (...params: ApiCallerEventType<DBProto_Account>) => void;
+}
+export declare enum LoggedStatus {
+    VALIDATING = 0,
+    LOGGED_OUT = 1,
+    SESSION_TIMEOUT = 2,
+    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'];
+    private status;
+    __onLoginStatusUpdated(): void;
+    constructor();
+    protected init(): void;
+    getAccounts(): UI_Account[];
+    getLoggedStatus: () => LoggedStatus;
+    isStatus: (status: LoggedStatus | LoggedStatus[]) => boolean;
+    __onSessionUpdated(): void;
+    protected setLoggedStatus: (newStatus: LoggedStatus) => void;
+    composeSAMLUrl: () => string;
+    logout: (url?: string) => Promise<string | undefined>;
+    uploadAccountThumbnail: (e: React.MouseEvent, account: DB_Account) => void;
+    private encodeFile;
+    getPasswordAssertionConfig: () => PasswordAssertionConfig | undefined;
+    getCurrentlyLoggedAccount: () => import("@nu-art/user-account-shared").UI_SessionAccount;
+    private onAccountCreated;
+    private onThumbnailChanged;
+    private onLoginCompletedSAML;
+    private onPasswordAssertionConfig;
+}
+export declare const ModuleFE_Account: ModuleFE_Account_Class;
+export {};

package/_entity/account/ModuleFE_Account.js

@@ -0,0 +1,153 @@
+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';
+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';
+export var LoggedStatus;
+(function (LoggedStatus) {
+    LoggedStatus[LoggedStatus["VALIDATING"] = 0] = "VALIDATING";
+    LoggedStatus[LoggedStatus["LOGGED_OUT"] = 1] = "LOGGED_OUT";
+    LoggedStatus[LoggedStatus["SESSION_TIMEOUT"] = 2] = "SESSION_TIMEOUT";
+    LoggedStatus[LoggedStatus["LOGGED_IN"] = 3] = "LOGGED_IN";
+})(LoggedStatus || (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)
+        };
+    }
+    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();
+            }
+            catch (err) {
+                this.logError(err.message, err);
+            }
+        });
+        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);
+    };
+}
+export const ModuleFE_Account = new ModuleFE_Account_Class();

package/_entity/account/consts.d.ts

@@ -0,0 +1,8 @@
+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';
+export declare const SessionKeyFE_Account: SessionKey_FE<_SessionKey_Account>;
+export declare const StorageKey_DeviceId: StorageKey<string>;
+export declare const StorageKey_TabId: StorageKey<string>;
+export declare const SessionKey_Account: SessionKey_FE<TypedKeyValue<"account", DB_Account>>;

package/_entity/account/consts.js

@@ -0,0 +1,7 @@
+import { StorageKey } from '@nu-art/thunderstorm-frontend/index';
+import { HeaderKey_DeviceId, HeaderKey_TabId } from '@nu-art/thunderstorm-shared/headers';
+import { SessionKey_FE } from '../session/ModuleFE_Session.js';
+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();
+export const SessionKey_Account = new SessionKey_FE('account');

package/_entity/account/index.d.ts

@@ -0,0 +1,3 @@
+export * from './ModuleFE_Account.js';
+export * from './module-pack.js';
+export * from './consts.js';

package/_entity/account/index.js

@@ -0,0 +1,3 @@
+export * from './ModuleFE_Account.js';
+export * from './module-pack.js';
+export * from './consts.js';

package/_entity/account/module-pack.d.ts

@@ -0,0 +1,2 @@
+import { Module } from '@nu-art/ts-common';
+export declare const ModulePackFE_AccountDB: Module[];

package/_entity/account/module-pack.js

@@ -0,0 +1,3 @@
+import { ModuleFE_Account } from './ModuleFE_Account.js';
+import { ModuleFE_Session } from '../session/ModuleFE_Session.js';
+export const ModulePackFE_AccountDB = [ModuleFE_Account, ModuleFE_Session];

package/_entity/session/ModuleFE_Session.d.ts

@@ -0,0 +1,33 @@
+import { OnStorageKeyChangedListener, StorageKey, ThunderDispatcher } from '@nu-art/thunderstorm-frontend/index';
+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';
+export interface OnSessionUpdated {
+    __onSessionUpdated: VoidFunction;
+}
+export declare const dispatch_onSessionUpdated: ThunderDispatcher<OnSessionUpdated, "__onSessionUpdated", [], void>;
+export declare const StorageKey_SessionTimeoutTimestamp: StorageKey<number>;
+export declare class SessionKey_FE<Binder extends TypedKeyValue<string | number | 'account', any>> {
+    private readonly key;
+    constructor(key: Binder['key']);
+    get(): Binder['value'];
+    get(defaultValue: Binder['value']): Binder['value'];
+}
+type SessionDecoder = (sessionAsString: string) => Promise<TS_Object>;
+export declare const sessionContentJWT: SessionDecoder;
+declare class ModuleFE_Session_Class extends Module implements OnStorageKeyChangedListener, OnAuthRequiredListener {
+    private sessionData;
+    sessionDecoder: SessionDecoder;
+    private sessionKey;
+    private StorageKey_SessionId;
+    init(): void;
+    setSessionKey(sessionKey: ResolvableContent<string>): void;
+    __onStorageKeyEvent(event: StorageEvent): Promise<void>;
+    __onAuthRequiredListener(request: BaseHttpRequest<any>): void;
+    private onSessionUpdated;
+    hasSession(): boolean;
+    isSessionValid(): Promise<boolean>;
+    getJWT: () => string | undefined;
+}
+export declare const ModuleFE_Session: ModuleFE_Session_Class;
+export {};

package/_entity/session/ModuleFE_Session.js

@@ -0,0 +1,95 @@
+import { getQueryParameter, ModuleFE_BrowserHistory, ModuleFE_XHR, StorageKey, ThunderDispatcher } from '@nu-art/thunderstorm-frontend/index';
+import { BadImplementationException, currentTimeMillis, exists, JwtTools, Module, resolveContent } from '@nu-art/ts-common';
+import { HeaderKey_Authorization, ResponseHeaderKey_JWTToken } from '@nu-art/thunderstorm-shared';
+import { QueryParam_SessionId } from '@nu-art/user-account-shared';
+export const dispatch_onSessionUpdated = new ThunderDispatcher('__onSessionUpdated');
+export const StorageKey_SessionTimeoutTimestamp = new StorageKey(`storage-accounts__session-timeout`);
+export class SessionKey_FE {
+    key;
+    constructor(key) {
+        this.key = key;
+    }
+    get(defaultValue) {
+        // @ts-ignore
+        const sessionData = ModuleFE_Session.sessionData;
+        // means that we don't have a session yet
+        if (!sessionData)
+            return;
+        if (!(this.key in sessionData) && !exists(defaultValue))
+            throw new BadImplementationException(`Couldn't find key "${this.key}" in session data`);
+        return sessionData[this.key] ?? defaultValue;
+    }
+}
+export const sessionContentJWT = async (sessionAsString) => {
+    return JwtTools.decode(sessionAsString);
+};
+class ModuleFE_Session_Class extends Module {
+    // @ts-ignore
+    sessionData;
+    sessionDecoder = sessionContentJWT;
+    sessionKey = 'session-jwt';
+    StorageKey_SessionId;
+    init() {
+        this.StorageKey_SessionId = new StorageKey(resolveContent(this.sessionKey));
+        this.StorageKey_SessionId.onChange(async (sessionAsString) => {
+            await this.onSessionUpdated(sessionAsString);
+        });
+        ModuleFE_XHR.addDefaultHeader(HeaderKey_Authorization, () => {
+            const sessionJWT = this.StorageKey_SessionId.get();
+            if (!sessionJWT)
+                return '';
+            return `Bearer ${sessionJWT}`;
+        });
+        ModuleFE_XHR.setDefaultOnComplete(async (__, _, request) => {
+            if (!request.getUrl().startsWith(ModuleFE_XHR.getOrigin()))
+                return;
+            const responseHeader = request.getResponseHeader(ResponseHeaderKey_JWTToken);
+            if (!responseHeader)
+                return;
+            const sessionId = typeof responseHeader === 'string' ? responseHeader : responseHeader[0];
+            this.StorageKey_SessionId.set(sessionId);
+        });
+        let sessionId = getQueryParameter(QueryParam_SessionId);
+        if (sessionId)
+            ModuleFE_BrowserHistory.removeQueryParam(QueryParam_SessionId);
+        else
+            sessionId = this.StorageKey_SessionId.get();
+        if (sessionId)
+            this.StorageKey_SessionId.set(sessionId);
+    }
+    setSessionKey(sessionKey) {
+        this.sessionKey = sessionKey;
+    }
+    async __onStorageKeyEvent(event) {
+        if (event.key !== this.StorageKey_SessionId.key)
+            return;
+        await this.onSessionUpdated(this.StorageKey_SessionId.get());
+    }
+    __onAuthRequiredListener(request) {
+        this.StorageKey_SessionId.delete();
+        StorageKey_SessionTimeoutTimestamp.set(currentTimeMillis());
+    }
+    async onSessionUpdated(sessionAsString) {
+        if (sessionAsString)
+            try {
+                this.sessionData = await this.sessionDecoder(sessionAsString);
+            }
+            catch (e) {
+                this.logError('Error decoding session data', e);
+            }
+        else
+            this.sessionData = {};
+        dispatch_onSessionUpdated.dispatchAll();
+    }
+    hasSession() {
+        return !!this.StorageKey_SessionId.get();
+    }
+    async isSessionValid() {
+        const sessionToken = this.StorageKey_SessionId.get();
+        if (!sessionToken)
+            return false;
+        return JwtTools.isJwtActive(sessionToken);
+    }
+    getJWT = () => this.StorageKey_SessionId.get();
+}
+export const ModuleFE_Session = new ModuleFE_Session_Class();

package/_entity.d.ts

@@ -0,0 +1,3 @@
+export * from './_entity/session/ModuleFE_Session.js';
+export * from './_entity/account/index.js';
+export * from './_entity/account/index.js';

package/_entity.js

@@ -0,0 +1,3 @@
+export * from './_entity/session/ModuleFE_Session.js';
+export * from './_entity/account/index.js';
+export * from './_entity/account/index.js';

package/account-editor/Component_AccountEditor.d.ts

@@ -0,0 +1,38 @@
+import { Account_CreateAccount, DB_Account } from '@nu-art/user-account-shared';
+import { ComponentSync } from '@nu-art/thunderstorm-frontend/index';
+import { UniqueId } from '@nu-art/ts-common';
+import './Component_AccountEditor.scss';
+type Props = {
+    isPreview?: boolean;
+    user?: DB_Account;
+    onComplete?: (_id: UniqueId) => void;
+};
+type SessionJWT = {
+    sessionData: string;
+    exp: number;
+    iat: number;
+    _id: string;
+    label?: string;
+    deviceId: string;
+    sessionIdJwt: string;
+};
+type State = Partial<Account_CreateAccount['request']> & {
+    isPreview: boolean;
+    tokenTTL: number;
+    tokenLabel: string;
+    user?: DB_Account;
+    sessions: SessionJWT[];
+};
+export declare class Component_AccountEditor extends ComponentSync<Props, State> {
+    protected deriveStateFromProps(nextProps: Props, state: State): State;
+    private addAccount;
+    private canCreate;
+    private renderDropdown;
+    private renderInputs;
+    private renderSubmitButton;
+    private renderGenToken;
+    private renderSessionGrid;
+    private renderDescription;
+    render(): import("react/jsx-runtime").JSX.Element;
+}
+export {};