@genesislcap/foundation-auth 14.71.1-auth-mf.2 → 14.71.1-auth-mf.4

package/dist/esm/machine/machine.js

@@ -1,13 +1,13 @@
 import { __awaiter, __decorate, __param } from "tslib";
 import { Connect, CredentialManager, MessageBuilder } from '@genesislcap/foundation-comms';
-import { AbstractMachine, createErrorStateNode, FetchMachine, isDoneInvokeEvent, isErrorEvent, MappingError, setError, } from '@genesislcap/foundation-state-machine';
+import { AbstractMachine, createErrorStateNode, FetchMachine, isDoneInvokeEvent, isErrorEvent, isUnauthorizedError, MappingError, setError, } from '@genesislcap/foundation-state-machine';
 import { UUID } from '@genesislcap/foundation-utils';
 import { DI } from '@microsoft/fast-foundation';
-import { and, assign, createMachine, fromPromise, not, sendTo } from 'xstate';
+import { and, assign, createMachine, fromPromise, not, or, sendTo } from 'xstate';
 import { User } from '../entity';
-import { LOGIN_DETAILS_URL, LOGIN_REFRESH_URL, LOGIN_URL, LOGOUT_URL, SOCKET_URL } from '../env';
+import { LOGIN_DETAILS_URL, LOGIN_URL, LOGOUT_URL, SOCKET_URL } from '../env';
 import { AuthConfig } from '../main/config';
-import { isLoginAckEntity, isLoginNackEntity, isLogoutAckEntity, isLogoutNackEntity, LoginMapper, LogoutMapper, } from '../mapper';
+import { isLoginAckEntity, isLoginDetailsAckEntity, isLoginNackEntity, isLogoutAckEntity, isLogoutNackEntity, LoginMapper, LogoutMapper, } from '../mapper';
 import { logger } from '../utils';
 import { isAuthError } from './errors';
 import { defaultAuthMachineContext } from './types';
@@ -30,8 +30,18 @@ let DefaultAuthMachine = class DefaultAuthMachine extends AbstractMachine {
         this.machine = createMachine({
             id: 'authMachine',
             context: ({ input }) => (Object.assign({}, input)),
-            initial: 'authCheck',
+            initial: 'idle',
             states: {
+                /**
+                 * Idle, waiting for event
+                 */
+                idle: {
+                    tags: ['idle'],
+                    on: Object.assign({}, this.addLoginEvents()),
+                },
+                /**
+                 * Check authentication status
+                 */
                 authCheck: {
                     tags: ['authCheck', 'pending'],
                     meta: {
@@ -47,125 +57,109 @@ let DefaultAuthMachine = class DefaultAuthMachine extends AbstractMachine {
                         },
                     ],
                 },
-                loggingIn: {
-                    tags: ['loggingIn', 'pending'],
+                /**
+                 * Attempt silent login via cookies (this returns the same user information as login when authorised)
+                 */
+                loginDetails: {
+                    tags: ['loginDetails', 'pending'],
                     meta: {
-                        content: 'Logging in, please wait.',
+                        content: 'Getting login details, please wait.',
                     },
                     invoke: {
-                        id: 'loginViaFetch',
+                        id: 'loginDetailsFetcher',
                         src: fetchMachine.machine,
                         onDone: {
                             actions: ['setAuthDTO'],
                             target: 'mapAuthEntity',
                         },
-                        onError: 'error.login',
-                        onSnapshot: {
-                            actions: ({ event }) => {
-                                console.log(event.data);
+                        onError: [
+                            {
+                                guard: 'isUnauthorizedError',
+                                target: 'loggedOut',
                             },
-                        },
+                            {
+                                target: 'error.loginDetails',
+                            },
+                        ],
                     },
                     entry: [
                         'setLoginMapper',
-                        sendTo('loginViaFetch', ({ context }) => {
-                            const { credentials } = context;
-                            const message = this.messageBuilder.createLoginMessage(credentials);
-                            return {
-                                type: 'fetch',
-                                params: {
-                                    url: LOGIN_URL,
-                                    requestInit: {
-                                        method: 'POST',
-                                        body: JSON.stringify(message),
-                                        headers: this.messageBuilder.createHTTPHeadersFromMessage(message),
-                                        credentials: 'include',
-                                    },
-                                },
-                            };
-                        }),
+                        sendTo('loginDetailsFetcher', this.createFetchMachineEvent(LOGIN_DETAILS_URL)),
                     ],
                 },
-                refreshing: {
-                    tags: ['refreshing', 'pending'],
+                /**
+                 * Login with user credentials or tokens
+                 */
+                loggingIn: {
+                    tags: ['loggingIn', 'pending'],
                     meta: {
-                        content: 'Refreshing, please wait.',
+                        content: 'Logging in, please wait.',
                     },
                     invoke: {
-                        id: 'refreshViaFetch',
+                        id: 'loginFetcher',
                         src: fetchMachine.machine,
                         onDone: {
                             actions: ['setAuthDTO'],
                             target: 'mapAuthEntity',
                         },
-                        onError: 'error.refresh',
+                        onError: 'error.login',
                     },
                     entry: [
                         'setLoginMapper',
-                        sendTo('refreshViaFetch', ({ context }) => {
-                            const message = {
-                                SOURCE_REF: this.uuid.createId(),
-                                // SESSION_AUTH_TOKEN: this.session.getSessionStorageItem('authToken'),
-                                // MESSAGE_TYPE: EventMessageType.EVENT_LOGIN_AUTH,
-                                // DETAILS: {
-                                //   REFRESH_AUTH_TOKEN: this.session.getSessionStorageItem('refreshToken'),
-                                // },
-                            };
-                            return {
-                                type: 'fetch',
-                                params: {
-                                    url: LOGIN_REFRESH_URL,
-                                    requestInit: {
-                                        method: 'POST',
-                                        body: JSON.stringify(message),
-                                        headers: this.messageBuilder.createHTTPHeadersFromMessage(message),
-                                        credentials: 'include',
-                                    },
-                                },
-                            };
-                        }),
+                        sendTo('loginFetcher', ({ context }) => this.createFetchMachineEvent(LOGIN_URL, this.messageBuilder.createLoginMessage(context.credentials))),
                     ],
                 },
-                loginDetails: {
-                    tags: ['loginDetails', 'pending'],
+                loggedIn: {
+                    tags: ['loggedIn'],
                     meta: {
-                        content: 'Getting login details, please wait.',
+                        content: 'Logged in.',
+                    },
+                    entry: ['storeCredentials', 'loggedInCallback', 'routeToRedirectUrl'],
+                    on: {
+                        logout: {
+                            target: '#authMachine.loggingOut',
+                        },
+                    },
+                },
+                /**
+                 * Logout
+                 */
+                loggingOut: {
+                    tags: ['loggingOut', 'pending'],
+                    meta: {
+                        content: 'Logging out, please wait.',
                     },
                     invoke: {
-                        id: 'loginDetailsViaFetch',
+                        id: 'logoutFetcher',
                         src: fetchMachine.machine,
                         onDone: {
                             actions: ['setAuthDTO'],
                             target: 'mapAuthEntity',
                         },
-                        onError: 'error.loginDetails',
+                        onError: 'error.logout',
                     },
                     entry: [
-                        'setLoginMapper',
-                        sendTo('loginDetailsViaFetch', ({ context }) => {
-                            const message = {
-                                SOURCE_REF: this.uuid.createId(),
-                                // SESSION_AUTH_TOKEN: this.session.getSessionStorageItem('authToken'),
-                                // MESSAGE_TYPE: EventMessageType.EVENT_LOGIN_AUTH,
-                                // DETAILS: {
-                                //   REFRESH_AUTH_TOKEN: this.session.getSessionStorageItem('refreshToken'),
-                                // },
-                            };
-                            return {
-                                type: 'fetch',
-                                params: {
-                                    url: LOGIN_DETAILS_URL,
-                                    requestInit: {
-                                        method: 'POST',
-                                        body: JSON.stringify(message),
-                                        headers: this.messageBuilder.createHTTPHeadersFromMessage(message),
-                                        credentials: 'include',
-                                    },
-                                },
-                            };
-                        }),
+                        'setLogoutMapper',
+                        sendTo('logoutFetcher', this.createFetchMachineEvent(LOGOUT_URL)),
                     ],
                 },
+                loggedOut: {
+                    tags: ['loggedOut'],
+                    meta: {
+                        content: 'Logged out.',
+                    },
+                    entry: [
+                        'unsetUser',
+                        'trackUserPath',
+                        'preventSilentAccess',
+                        'loggedOutCallback',
+                        'routeToRootUrl',
+                    ],
+                    on: Object.assign({}, this.addLoginEvents()),
+                },
+                /**
+                 * Map the server responses to entities
+                 */
                 mapAuthEntity: {
                     tags: ['mapAuthEntity', 'pending'],
                     meta: {
@@ -184,6 +178,24 @@ let DefaultAuthMachine = class DefaultAuthMachine extends AbstractMachine {
                         onError: '#authMachine.error.mapping',
                     },
                 },
+                /**
+                 * Check entity types and drive next step
+                 */
+                loginNackCheck: {
+                    tags: ['loginNackCheck', 'pending'],
+                    meta: {
+                        content: 'Login nack, check details, please wait.',
+                    },
+                    always: [
+                        {
+                            guard: 'isMFARequired',
+                            target: '#authMachine.error.mfaRequired',
+                        },
+                        {
+                            target: '#authMachine.error.login',
+                        },
+                    ],
+                },
                 entityCheck: {
                     tags: ['entityCheck', 'pending'],
                     meta: {
@@ -191,7 +203,7 @@ let DefaultAuthMachine = class DefaultAuthMachine extends AbstractMachine {
                     },
                     always: [
                         {
-                            guard: 'isLoginAckEntity',
+                            guard: or(['isLoginAckEntity', 'isLoginDetailsAckEntity']),
                             actions: ['setUser'],
                             target: '#authMachine.authCheck',
                         },
@@ -213,21 +225,9 @@ let DefaultAuthMachine = class DefaultAuthMachine extends AbstractMachine {
                         },
                     ],
                 },
-                loginNackCheck: {
-                    tags: ['loginNackCheck', 'pending'],
-                    meta: {
-                        content: 'Login nack, check details, please wait.',
-                    },
-                    always: [
-                        {
-                            guard: 'isMFARequired',
-                            target: '#authMachine.error.mfaRequired',
-                        },
-                        {
-                            target: '#authMachine.error.login',
-                        },
-                    ],
-                },
+                /**
+                 * Testing states (most will go)
+                 */
                 connectionCheck: {
                     tags: ['connectionCheck', 'pending'],
                     meta: {
@@ -255,48 +255,6 @@ let DefaultAuthMachine = class DefaultAuthMachine extends AbstractMachine {
                         content: 'Disconnected (NEEDS TO MOVE OUT).',
                     },
                 },
-                loggedIn: {
-                    tags: ['loggedIn'],
-                    meta: {
-                        content: 'Logged in.',
-                    },
-                    entry: ['storeCredentials', 'loggedInCallback', 'routeToRedirectUrl'],
-                },
-                loggingOut: {
-                    tags: ['loggingOut', 'pending'],
-                    meta: {
-                        content: 'Logging out, please wait.',
-                    },
-                    invoke: {
-                        id: 'logoutViaFetch',
-                        src: fetchMachine.machine,
-                        onDone: {
-                            actions: ['setAuthDTO'],
-                            target: 'mapAuthEntity',
-                        },
-                        onError: 'error.logout',
-                    },
-                    entry: [
-                        'setLogoutMapper',
-                        sendTo('logoutViaFetch', ({ context }) => {
-                            const headers = {
-                                'Content-type': 'application/json; charset=UTF-8',
-                                SOURCE_REF: this.uuid.createId(),
-                            };
-                            return {
-                                type: 'fetch',
-                                params: {
-                                    url: LOGOUT_URL,
-                                    requestInit: {
-                                        method: 'POST',
-                                        headers,
-                                        credentials: 'include',
-                                    },
-                                },
-                            };
-                        }),
-                    ],
-                },
                 openSocketTest: {
                     tags: ['openSocketTest', 'pending'],
                     meta: {
@@ -341,46 +299,26 @@ let DefaultAuthMachine = class DefaultAuthMachine extends AbstractMachine {
                     //   }
                     // }
                 },
-                loggedOut: {
-                    tags: ['loggedOut'],
-                    meta: {
-                        content: 'Logged out.',
-                    },
-                    /**
-                     * clear up data points...
-                     */
-                    entry: ['trackUserPath', 'preventSilentAccess', 'loggedOutCallback', 'routeToRootUrl'],
-                },
+                /**
+                 * Error states
+                 */
                 error: {
                     initial: 'unknown',
                     entry: ['setError', 'errorCallback'],
                     states: {
                         unknown: createErrorStateNode('unknown', 'Unknown error.'),
                         login: createErrorStateNode('login', 'Login error.'),
-                        refresh: createErrorStateNode('refresh', 'Refresh error.'),
                         loginDetails: createErrorStateNode('login-details', 'Getting login details error.'),
                         mfaRequired: createErrorStateNode('mfa-required', 'MFA required error.'),
                         logout: createErrorStateNode('logout', 'Logout error.'),
                         mapping: createErrorStateNode('mapping', 'Mapping error.'),
                         connect: createErrorStateNode('connect', 'Connection error.'),
                         disconnect: createErrorStateNode('disconnect', 'Disconnection error.'),
+                        auth: createErrorStateNode('Auth', 'Auth error.'),
                     },
                 },
             },
             on: {
-                login: {
-                    actions: ['resetContext', 'setCredentials'],
-                    target: '#authMachine.loggingIn',
-                },
-                refresh: {
-                    target: '#authMachine.refreshing',
-                },
-                ['login-details']: {
-                    target: '#authMachine.loginDetails',
-                },
-                logout: {
-                    target: '#authMachine.loggingOut',
-                },
                 openSocket: {
                     target: '#authMachine.openSocketTest',
                 },
@@ -411,7 +349,6 @@ let DefaultAuthMachine = class DefaultAuthMachine extends AbstractMachine {
                         throw new MappingError(dto); // < what about stack?
                     }
                 })),
-                // socket: fromObservable(() => {})
                 connect: fromPromise(({ input }) => __awaiter(this, void 0, void 0, function* () { return this.connect.connect(SOCKET_URL); })),
                 disconnect: fromPromise(({ input }) => __awaiter(this, void 0, void 0, function* () { return this.connect.disconnect(); })),
             },
@@ -465,7 +402,8 @@ let DefaultAuthMachine = class DefaultAuthMachine extends AbstractMachine {
                     yield this.credentialManager.preventSilentAccess();
                 }),
                 storeCredentials: ({ context }) => {
-                    if (context.credentials.type === 'BASIC') {
+                    var _a;
+                    if (((_a = context.credentials) === null || _a === void 0 ? void 0 : _a.type) === 'BASIC') {
                         this.credentialManager.storeCredentials({
                             id: context.credentials.username,
                             name: context.credentials.username,
@@ -506,9 +444,11 @@ let DefaultAuthMachine = class DefaultAuthMachine extends AbstractMachine {
             },
             guards: {
                 isAuthError: ({ event }) => (isErrorEvent(event) ? isAuthError(event.data) : false),
+                isUnauthorizedError: ({ event }) => isErrorEvent(event) ? isUnauthorizedError(event.data) : false,
                 isAuthenticated: ({ context }) => { var _a; return (_a = context.user) === null || _a === void 0 ? void 0 : _a.isAuthenticated(); },
                 isBanned: ({ context }) => { var _a; return (_a = context.user) === null || _a === void 0 ? void 0 : _a.isBanned(); },
                 isLoginAckEntity: ({ event }) => isDoneInvokeEvent(event) ? isLoginAckEntity(event.output) : false,
+                isLoginDetailsAckEntity: ({ event }) => isDoneInvokeEvent(event) ? isLoginDetailsAckEntity(event.output) : false,
                 isLoginNackEntity: ({ event }) => isDoneInvokeEvent(event) ? isLoginNackEntity(event.output) : false,
                 isMFARequired: ({ event }) => isDoneInvokeEvent(event)
                     ? isLoginNackEntity(event.output) && event.output.isMFARequired
@@ -531,6 +471,32 @@ let DefaultAuthMachine = class DefaultAuthMachine extends AbstractMachine {
     getFromContainer() {
         return this.container.get(AuthMachine);
     }
+    createFetchMachineEvent(url, msg = {}) {
+        const message = Object.assign({ SOURCE_REF: this.uuid.createId() }, msg);
+        return {
+            type: 'fetch',
+            params: {
+                url,
+                requestInit: {
+                    method: 'POST',
+                    body: JSON.stringify(message),
+                    headers: this.messageBuilder.createHTTPHeadersFromMessage(message),
+                    credentials: 'include',
+                },
+            },
+        };
+    }
+    addLoginEvents() {
+        return {
+            login: {
+                actions: ['resetContext', 'setCredentials'],
+                target: '#authMachine.loggingIn',
+            },
+            ['login-details']: {
+                target: '#authMachine.loginDetails',
+            },
+        };
+    }
 };
 DefaultAuthMachine = __decorate([
     __param(0, User),

package/dist/esm/main/main.js

@@ -1,5 +1,5 @@
 import { __awaiter, __decorate } from "tslib";
-import { ConnectConfig, defaultConnectConfig, Session } from '@genesislcap/foundation-comms';
+import { ConnectConfig, CredentialManager, defaultConnectConfig, Session, } from '@genesislcap/foundation-comms';
 import { EventEmitter } from '@genesislcap/foundation-events';
 import { customElement, FASTElement, observable } from '@microsoft/fast-element';
 import { Container, inject, Registration } from '@microsoft/fast-foundation';
@@ -7,6 +7,7 @@ import { DefaultRouteRecognizer } from '@microsoft/fast-router';
 import * as Components from '../components';
 import { MainRouterConfig } from '../routes';
 import { AuthStore } from '../store';
+import { logger } from '../utils';
 import { definition, standaloneDefinition } from './main.definition';
 /**
  * @public
@@ -32,8 +33,8 @@ let Auth = class Auth extends EventEmitter(FASTElement) {
             _super.connectedCallback.call(this);
             this.addEventListeners();
             yield this.registerCommonComponents();
-            this.checkForSSOToken();
             this.readyStore();
+            this.actionQueryParams();
         });
     }
     /**
@@ -44,7 +45,7 @@ let Auth = class Auth extends EventEmitter(FASTElement) {
         this.removeEventListeners();
     }
     /**
-     * Used to forward the user onto a logged-in session during an SSO journey
+     * Used to forward the user onto a logged-in session during an SSO and MFA journeys
      *
      * @remarks
      *
@@ -65,7 +66,7 @@ let Auth = class Auth extends EventEmitter(FASTElement) {
      *
      * @internal
      */
-    checkForSSOToken() {
+    actionQueryParams() {
         const queryParams = new URLSearchParams(window.location.search);
         const ssoToken = queryParams.get('SSO_TOKEN');
         if (ssoToken) {
@@ -75,9 +76,32 @@ let Auth = class Auth extends EventEmitter(FASTElement) {
                 window.close();
             }
             else {
-                this.session.setSessionStorageItem('ssoToken', ssoToken);
+                const ssoCredentials = this.cm.createSSOCredentials({
+                    ssoToken,
+                });
+                if (this.cm.validateSSOCredentials(ssoCredentials)) {
+                    logger.debug(`Attempting to login with SSO.`);
+                    this.loginWithCredentials(ssoCredentials);
+                    return;
+                }
             }
         }
+        const mfaToken = queryParams.get('MFA_CODE');
+        if (mfaToken) {
+            const mfaCredentials = this.cm.createMFACredentials({
+                /**
+                 * I think `token` is better as it's system gen vs code a user entered
+                 * TODO: Get server guys to update query param to MFA_TOKEN
+                 */
+                mfaToken,
+            });
+            if (this.cm.validateMFACredentials(mfaCredentials)) {
+                logger.debug(`Attempting to login with mfa credentials.`);
+                this.loginWithCredentials(mfaCredentials);
+                return;
+            }
+        }
+        this.loginWithCookies();
     }
     /**
      * Called from the connectedCallback
@@ -94,7 +118,7 @@ let Auth = class Auth extends EventEmitter(FASTElement) {
              *
              * await new Promise(resolve => setTimeout(resolve, 3000));
              */
-            this.ready = true;
+            this.ready = true; // < machine not pending?
         });
     }
     /**
@@ -127,10 +151,22 @@ let Auth = class Auth extends EventEmitter(FASTElement) {
         this.$emit('store-connected', this);
         this.$emit('store-ready', true);
     }
+    loginWithCredentials(credentials) {
+        this.$emit('auth-login', credentials);
+    }
+    loginWithCookies() {
+        this.$emit('auth-login-details');
+    }
+    logout() {
+        this.$emit('auth-logout');
+    }
 };
 __decorate([
     AuthStore
 ], Auth.prototype, "store", void 0);
+__decorate([
+    CredentialManager
+], Auth.prototype, "cm", void 0);
 __decorate([
     inject(MainRouterConfig)
 ], Auth.prototype, "config", void 0);

package/dist/esm/mapper/loginMapper.js

@@ -10,6 +10,14 @@ import { fromDTOAck, fromDTONack, fromDTOStringArray, hasDTOErrorWarningCode } f
 export function isLoginAckDTO(dto) {
     return (dto === null || dto === void 0 ? void 0 : dto.MESSAGE_TYPE) === 'EVENT_LOGIN_AUTH_ACK';
 }
+/**
+ * isLoginDetailsAckDTO.
+ * @param dto - Potential DTO.
+ * @public
+ */
+export function isLoginDetailsAckDTO(dto) {
+    return (dto === null || dto === void 0 ? void 0 : dto.MESSAGE_TYPE) === 'EVENT_LOGIN_DETAILS_ACK';
+}
 /**
  * isLoginNackDTO.
  * @param dto - Potential DTO.
@@ -26,6 +34,14 @@ export function isLoginNackDTO(dto) {
 export function isLoginAckEntity(entity) {
     return (entity === null || entity === void 0 ? void 0 : entity.messageType) === 'EVENT_LOGIN_AUTH_ACK';
 }
+/**
+ * isLoginDetailsAckEntity.
+ * @param entity - Potential entity.
+ * @public
+ */
+export function isLoginDetailsAckEntity(entity) {
+    return (entity === null || entity === void 0 ? void 0 : entity.messageType) === 'EVENT_LOGIN_DETAILS_ACK';
+}
 /**
  * isLoginNackEntity.
  * @param entity - Potential entity.
@@ -45,7 +61,7 @@ export class DefaultLoginMapper {
          */
         this.toEntity = (dto) => __awaiter(this, void 0, void 0, function* () {
             try {
-                if (isLoginAckDTO(dto)) {
+                if (isLoginAckDTO(dto) || isLoginDetailsAckDTO(dto)) {
                     const { DETAILS } = dto;
                     return Object.assign(Object.assign({}, fromDTOAck(dto)), { sessionAuthToken: dto.SESSION_AUTH_TOKEN, refreshAuthToken: dto.REFRESH_AUTH_TOKEN, sessionId: dto.SESSION_ID, userName: dto.USER_NAME, updateQueue: dto.UPDATE_QUEUE, zeroMqProxyModeEnabled: dto.ZERO_MQ_PROXY_MODE_ENABLED, zeroMqProxyInboundPort: dto.ZERO_MQ_PROXY_INBOUND_PORT, zeroMqProxyOutboundPort: dto.ZERO_MQ_PROXY_OUTBOUND_PORT, userKVs: dto.USER, details: DETAILS
                             ? {

package/dist/esm/routes/base.js

@@ -1,7 +1,6 @@
 import { __awaiter, __decorate } from "tslib";
 import { Auth, Connect, CredentialManager, MessageBuilder, Session, } from '@genesislcap/foundation-comms';
 import { createInputEmitter, createSelectEmitter, EventEmitter, targetValue, } from '@genesislcap/foundation-events';
-import { sync } from '@genesislcap/foundation-utils';
 import { SecondaryRapidColorHEX } from '@genesislcap/foundation-zero';
 import { attr, css, customElement, FASTElement, html, observable, when, } from '@microsoft/fast-element';
 import { Container } from '@microsoft/fast-foundation';
@@ -76,6 +75,9 @@ export class BaseRoute extends ConfigHostElement {
         // this.email = this.config.fields.email?.value;
         // this.password = this.config.fields.password?.value;
     }
+    enter(phase) {
+        this.navigationPhase = phase;
+    }
     onSubmit() {
         return __awaiter(this, void 0, void 0, function* () {
             this.isSubmitting = true;
@@ -188,35 +190,6 @@ __decorate([
 __decorate([
     observable
 ], BaseRoute.prototype, "isSubmitting", void 0);
-/**
- * @internal
- * @privateRemarks
- * Potential optimisation ahead of workflow / statemachine based smart forms integration, but needs tagFor.
- * Feels a bit at odds with the declarative nature we're aiming for, but will await review.
- */
-export const configurableTextField = (name, type, autofocus = false, autocomplete = '', className = '', labelOverride = '', testIdOverride = '', required = true) => {
-    // Just pass the FieldConfig instead of name?
-    const [fieldName, valueKey] = Array.isArray(name) ? name : [name, name];
-    return html `
-    ${when((x) => x.config.fields[fieldName], html `
-        <zero-text-field
-          type="${type}"
-          name="${fieldName}"
-          id="${fieldName}"
-          :value="${sync((x) => x[valueKey])}"
-          ?autofocus="${() => autofocus}"
-          ?required="${() => required}"
-          ${autocomplete ? `autocomplete="${autocomplete}"` : ''}
-          data-test-id="${testIdOverride !== null && testIdOverride !== void 0 ? testIdOverride : fieldName}"
-          class="${className}"
-        >
-          <span class="form-title">
-            ${(x) => labelOverride !== null && labelOverride !== void 0 ? labelOverride : x.config.fields[fieldName].label}
-          </span>
-        </zero-text-field>
-      `)}
-  `;
-};
 /**
  * @internal
  */

package/dist/esm/routes/config.js

@@ -128,8 +128,6 @@ let MainRouterConfig = class MainRouterConfig extends RouterConfiguration {
                 }
                 /**
                  * If allowAutoAuth and session is valid try to connect+auto-login
-                 *
-                 * todo send login refresh? should we do that from the login route?
                  */
                 // if (this.authConfig.autoAuth && (await auth.reAuthFromSession())) {
                 //   return;