@genesislcap/foundation-auth 14.71.1-auth-mf.21 → 14.103.0-auth-mf.23

package/dist/esm/machine/errors.js

@@ -0,0 +1,40 @@
+import { APIError } from '@genesislcap/foundation-state-machine';
+/**
+ * NackError.
+ *
+ * @remarks
+ * If Required until http status codes are aligned on backend.
+ *
+ * @example
+ * ```ts
+ * NackError.fromEntity(event.output);
+ * ```
+ *
+ * @public
+ */
+export class NackError extends APIError {
+    constructor(status, data, message = 'API Error Occurred') {
+        super(status, data, message);
+        this.status = status;
+        this.data = data;
+    }
+    /**
+     * Construct a {@link NackError} from a {@link Nack}
+     * @param entity - The Nack.
+     */
+    static fromEntity(entity) {
+        if (!entity) {
+            return null;
+        }
+        /**
+         * Prioritize errors
+         */
+        if (entity.normalisedErrorStatusCode > 0) {
+            return new NackError(entity.normalisedErrorStatusCode, entity, entity.normalisedErrorText);
+        }
+        if (entity.normalisedWarningStatusCode > 0) {
+            return new NackError(entity.normalisedWarningStatusCode, entity, entity.normalisedWarningText);
+        }
+        return null;
+    }
+}

package/dist/esm/machine/guards.js

@@ -0,0 +1,11 @@
+import { isDoneInvokeEvent } from '@genesislcap/foundation-state-machine';
+import { isNackDTO, isNackEntity } from '../mapper';
+/**
+ * is200Nack.
+ * @privateRemarks
+ * Required until http status codes are aligned on backend.
+ * @public
+ */
+export const is200Nack = (event) => isDoneInvokeEvent(event)
+    ? isNackEntity(event.output) || isNackDTO(event.output)
+    : false;

package/dist/esm/machine/index.js

@@ -1,2 +1,4 @@
+export * from './actions';
+export * from './guards';
 export * from './machine';
 export * from './types';

package/dist/esm/machine/machine.js

@@ -1,5 +1,5 @@
 import { __awaiter, __decorate, __param } from "tslib";
-import { AbstractMachine, createErrorStateNode, FetchMachine, isDoneInvokeEvent, isErrorEvent, isEventWithParams, isUnauthorizedError, setError, } from '@genesislcap/foundation-state-machine';
+import { AbstractMachine, createErrorStateNode, FetchMachine, isDoneInvokeEvent, isErrorEvent, isEventWithParams, isUnauthorizedError, } from '@genesislcap/foundation-state-machine';
 import { UUID } from '@genesislcap/foundation-utils';
 import { DI } from '@microsoft/fast-foundation';
 import { and, assign, createMachine, fromPromise, not, or, raise, sendTo } from 'xstate';
@@ -11,6 +11,7 @@ import { AuthMessageMapper, createHTTPHeadersFromDTO, isLoginAckEntity, isLoginD
 import { AuthRouting } from '../routes/routing';
 import { User } from '../user';
 import { logger } from '../utils';
+import { setError } from './actions';
 import { defaultAuthMachineContext, isLoginParams, isQueryParams } from './types';
 /**
  * Default AuthMachine.
@@ -26,25 +27,28 @@ let DefaultAuthMachine = class DefaultAuthMachine extends AbstractMachine {
         this.messageMapper = messageMapper;
         this.config = config;
         this.routing = routing;
-        this.onIdleEvents = () => ({
-            login: {
-                actions: ['resetContext', 'setParams'],
-                target: '#authMachine.loggingIn',
-            },
-            ['forgot-password']: {
-                actions: ['resetContext', 'setParams'],
-                target: '#authMachine.forgotPassword',
-            },
-            ['change-password']: {
-                actions: ['resetContext', 'setParams'],
-                target: '#authMachine.changePassword',
-            },
-            ['reset-password']: {
-                actions: ['resetContext', 'setParams'],
-                target: '#authMachine.resetPassword',
-            },
-        });
-        this.onDoneDTO = () => ({
+        this.onIdleEvents = () => {
+            const actions = ['resetContext', 'setParams'];
+            return {
+                login: {
+                    actions,
+                    target: '#authMachine.loggingIn',
+                },
+                ['forgot-password']: {
+                    actions,
+                    target: '#authMachine.forgotPassword',
+                },
+                ['change-password']: {
+                    actions,
+                    target: '#authMachine.changePassword',
+                },
+                ['reset-password']: {
+                    actions,
+                    target: '#authMachine.resetPassword',
+                },
+            };
+        };
+        this.dtoTransition = () => ({
             actions: ['setDTO'],
             target: 'mapEntity',
         });
@@ -90,8 +94,9 @@ let DefaultAuthMachine = class DefaultAuthMachine extends AbstractMachine {
                         },
                         {
                             /**
-                             * Silent login (cookie based, only when on login screen)
+                             * Silent login (cookie based)
                              */
+                            guard: and([not('hasQueryParams'), not('hasLoginParams')]),
                             target: '#authMachine.silentLogin',
                         },
                     ],
@@ -114,7 +119,7 @@ let DefaultAuthMachine = class DefaultAuthMachine extends AbstractMachine {
                     invoke: {
                         id: 'loginDetailsFetcher',
                         src: fetchMachine.machine,
-                        onDone: this.onDoneDTO(),
+                        onDone: this.dtoTransition(),
                         onError: [
                             {
                                 guard: 'isUnauthorizedError',
@@ -138,7 +143,7 @@ let DefaultAuthMachine = class DefaultAuthMachine extends AbstractMachine {
                     invoke: {
                         id: 'loginFetcher',
                         src: fetchMachine.machine,
-                        onDone: this.onDoneDTO(),
+                        onDone: this.dtoTransition(),
                         onError: 'error.login',
                     },
                     entry: [
@@ -173,7 +178,7 @@ let DefaultAuthMachine = class DefaultAuthMachine extends AbstractMachine {
                     invoke: {
                         id: 'logoutFetcher',
                         src: fetchMachine.machine,
-                        onDone: this.onDoneDTO(),
+                        onDone: this.dtoTransition(),
                         onError: 'error.logout',
                     },
                     entry: [
@@ -226,7 +231,7 @@ let DefaultAuthMachine = class DefaultAuthMachine extends AbstractMachine {
                         src: fetchMachine.machine,
                         onDone: [
                             {
-                                guard: 'is200Nack',
+                                guard: 'is200NackDTO',
                                 target: 'error.changePassword',
                             },
                             {
@@ -329,9 +334,8 @@ let DefaultAuthMachine = class DefaultAuthMachine extends AbstractMachine {
                             target: '#authMachine.authCheck',
                         },
                         {
-                            guard: 'isLogoutAckEntity',
-                            actions: ['unsetUser'],
-                            target: '#authMachine.authCheck',
+                            guard: and(['isLoginNackEntity', 'hasIncorrectCredentials']),
+                            target: '#authMachine.feedback.incorrectCredentials',
                         },
                         {
                             guard: and(['isLoginNackEntity', 'isMFARequired']),
@@ -343,14 +347,15 @@ let DefaultAuthMachine = class DefaultAuthMachine extends AbstractMachine {
                             actions: 'storeBasicCredentials',
                             target: '#authMachine.feedback.passwordExpired',
                         },
-                        /**
-                         * Old login mf logic used to cross-check compid / organisation field to see if it might be a validation
-                         * error around that, but I'm not sure if it's still being used? TODO: Ask around.
-                         */
                         {
                             guard: 'isLoginNackEntity',
                             target: '#authMachine.error.login',
                         },
+                        {
+                            guard: 'isLogoutAckEntity',
+                            actions: ['unsetUser'],
+                            target: '#authMachine.authCheck',
+                        },
                         {
                             guard: 'isLogoutNackEntity',
                             target: '#authMachine.error.logout',
@@ -380,6 +385,7 @@ let DefaultAuthMachine = class DefaultAuthMachine extends AbstractMachine {
                 },
                 /**
                  * Feedback states. These are transient and revert back to idle after a short delay.
+                 * These can help improve UX in when the backend nack text is lacking clarity, as with incorrect credentials.
                  */
                 feedback: {
                     initial: 'none',
@@ -414,6 +420,15 @@ let DefaultAuthMachine = class DefaultAuthMachine extends AbstractMachine {
                                 feedbackDelay: '#authMachine.idle',
                             },
                         },
+                        incorrectCredentials: {
+                            tags: ['feedback', 'incorrectCredentials'],
+                            meta: {
+                                content: 'Incorrect credentials, please try again.',
+                            },
+                            after: {
+                                feedbackDelay: '#authMachine.idle',
+                            },
+                        },
                         mfaRequired: {
                             tags: ['feedback', 'mfaRequired'],
                             meta: {
@@ -452,7 +467,6 @@ let DefaultAuthMachine = class DefaultAuthMachine extends AbstractMachine {
                         resetPassword: createErrorStateNode('reset-password', 'Reset password error.'),
                         logout: createErrorStateNode('logout', 'Logout error.'),
                         mapping: createErrorStateNode('mapping', 'Mapping error.'),
-                        auth: createErrorStateNode('Auth', 'Auth error.'),
                     },
                     on: this.onIdleEvents(),
                 },
@@ -466,10 +480,6 @@ let DefaultAuthMachine = class DefaultAuthMachine extends AbstractMachine {
             },
         }, {
             actors: {
-                /**
-                 * TODO: Test reusing a single fetch machine here, not that it matters much
-                 */
-                fetcher: this.fetchMachine.machine,
                 mapper: fromPromise(({ input }) => __awaiter(this, void 0, void 0, function* () { return input.mapper(input.dto); })),
             },
             actions: {
@@ -540,33 +550,9 @@ let DefaultAuthMachine = class DefaultAuthMachine extends AbstractMachine {
                 postLoginRedirect: this.config.postLoginRedirect,
                 postLogoutRedirect: this.config.postLogoutRedirect,
                 resetPasswordRedirect: () => this.routing.navigateTo('reset-password?expired'),
-                /**
-                 * loggedInCallback.
-                 * @remarks
-                 * Can be overridden by the caller. Alternatively callers can observe machine.context.
-                 * @public
-                 */
-                loggedInCallback: () => {
-                    logger.debug('AuthMachine.loggedInCallback invoked. Should be overwritten in most cases.');
-                },
-                /**
-                 * loggedOutCallback.
-                 * @remarks
-                 * Can be overridden by the caller. Alternatively callers can observe machine.context.
-                 * @public
-                 */
-                loggedOutCallback: () => {
-                    logger.debug('AuthMachine.loggedOutCallback invoked. Should be overwritten in most cases.');
-                },
-                /**
-                 * errorCallback.
-                 * @remarks
-                 * Can be overridden by the caller. Alternatively callers can observe machine.context.
-                 * @public
-                 */
-                errorCallback: () => {
-                    logger.debug('AuthMachine.errorCallback invoked. Should be overwritten in most cases.');
-                },
+                loggedInCallback: () => logger.debug('AuthMachine.loggedInCallback invoked.'),
+                loggedOutCallback: () => logger.debug('AuthMachine.loggedOutCallback invoked.'),
+                errorCallback: () => logger.debug('AuthMachine.errorCallback invoked.'),
             },
             guards: {
                 hasParams: ({ context }) => context.params !== undefined,
@@ -581,6 +567,9 @@ let DefaultAuthMachine = class DefaultAuthMachine extends AbstractMachine {
                 isLoginAckEntity: ({ event }) => isDoneInvokeEvent(event) ? isLoginAckEntity(event.output) : false,
                 isLoginDetailsAckEntity: ({ event }) => isDoneInvokeEvent(event) ? isLoginDetailsAckEntity(event.output) : false,
                 isLoginNackEntity: ({ event }) => isDoneInvokeEvent(event) ? isLoginNackEntity(event.output) : false,
+                hasIncorrectCredentials: ({ event }) => isDoneInvokeEvent(event)
+                    ? isLoginNackEntity(event.output) && event.output.hasIncorrectCredentials
+                    : false,
                 isMFARequired: ({ event }) => isDoneInvokeEvent(event)
                     ? isLoginNackEntity(event.output) && event.output.isMFARequired
                     : false,
@@ -590,9 +579,9 @@ let DefaultAuthMachine = class DefaultAuthMachine extends AbstractMachine {
                 isLogoutAckEntity: ({ event }) => isDoneInvokeEvent(event) ? isLogoutAckEntity(event.output) : false,
                 isLogoutNackEntity: ({ event }) => isDoneInvokeEvent(event) ? isLogoutNackEntity(event.output) : false,
                 /**
-                 * Temp until server guys fix http status codes
+                 * Required until strict http status codes are enabled on the backend by default.
                  */
-                is200Nack: ({ event }) => {
+                is200NackDTO: ({ event }) => {
                     var _a, _b;
                     return isDoneInvokeEvent(event)
                         ? ((_b = (_a = event.output) === null || _a === void 0 ? void 0 : _a.response) === null || _b === void 0 ? void 0 : _b.ok) && isNackDTO(event.output.data)
@@ -627,6 +616,7 @@ let DefaultAuthMachine = class DefaultAuthMachine extends AbstractMachine {
     convertQueryParamsToLoginParams(params) {
         const ssoCredentials = params.SSO_TOKEN
             ? {
+                type: CredentialType.SSO,
                 ssoToken: params.SSO_TOKEN,
             }
             : undefined;
@@ -636,6 +626,7 @@ let DefaultAuthMachine = class DefaultAuthMachine extends AbstractMachine {
         }
         const mfaCredentials = params.MFA_CODE
             ? {
+                type: CredentialType.MFA,
                 mfaToken: params.MFA_CODE,
             }
             : undefined;

package/dist/esm/main/main.js

@@ -3,6 +3,7 @@ import { EventEmitter } from '@genesislcap/foundation-events';
 import { customElement, FASTElement } from '@microsoft/fast-element';
 import { Container, inject, Registration } from '@microsoft/fast-foundation';
 import { DefaultRouteRecognizer } from '@microsoft/fast-router';
+import { classNames } from '@microsoft/fast-web-utilities';
 import '../components/core-components';
 import { AuthRouterConfig } from '../routes/config';
 import { AuthStore } from '../store';
@@ -27,6 +28,7 @@ export class FoundationAuth extends EventEmitter(FASTElement) {
     connectedCallback() {
         this.registerDIDependencies();
         super.connectedCallback();
+        this.addBindings();
         this.addEventListeners();
         this.readyStore();
     }
@@ -35,6 +37,7 @@ export class FoundationAuth extends EventEmitter(FASTElement) {
      */
     disconnectedCallback() {
         super.disconnectedCallback();
+        this.removeBindings();
         this.removeEventListeners();
     }
     /**
@@ -43,6 +46,22 @@ export class FoundationAuth extends EventEmitter(FASTElement) {
     registerDIDependencies() {
         this.container.register(Registration.transient(DefaultRouteRecognizer, DefaultRouteRecognizer));
     }
+    /**
+     * @internal
+     */
+    addBindings() {
+        this.machineBinding = this.store.authMachine.binding((x) => x.snapshot.value, (value) => {
+            if (value === 'loggedOut') {
+                this.attemptAutofill();
+            }
+        });
+    }
+    /**
+     * @internal
+     */
+    removeBindings() {
+        this.machineBinding.disconnect();
+    }
     /**
      * @internal
      */
@@ -66,7 +85,23 @@ export class FoundationAuth extends EventEmitter(FASTElement) {
      * @internal
      */
     get isReady() {
-        return !this.store.isPending;
+        return (!this.store.authMachine.hasTag('initializing') &&
+            !this.store.authMachine.hasTag('silentLogin'));
+    }
+    /**
+     * @internal
+     */
+    get classNames() {
+        return classNames(['ready', this.isReady], ['not-ready', !this.isReady]);
+    }
+    /**
+     * @internal
+     */
+    attemptAutofill() {
+        const { autofilling, ssoToggled, username, password } = this.store.formEntry;
+        if (!autofilling && !ssoToggled && !username && !password) {
+            this.$emit('auth-autofill-form');
+        }
     }
 }
 __decorate([
@@ -111,6 +146,13 @@ __decorate([
  * @public
  */
 let ZeroAuth = class ZeroAuth extends FoundationAuth {
+    constructor() {
+        super(...arguments);
+        /**
+         * @internal
+         */
+        this.zeroReady = false;
+    }
     /**
      * @internal
      */
@@ -135,9 +177,11 @@ let ZeroAuth = class ZeroAuth extends FoundationAuth {
     }
     /**
      * @internal
+     * @privateRemarks
+     * The order of the check is important here, check super first.
      */
     get isReady() {
-        return this.zeroReady && super.isReady;
+        return super.isReady && this.zeroReady;
     }
 };
 ZeroAuth = __decorate([

package/dist/esm/main/main.styles.js

@@ -18,7 +18,9 @@ export const styles = css `
     height: 100%;
   }
 
-  :host([hidden]) {
+  :host([hidden]),
+  :host(.not-ready),
+  ${providerTag}.not-ready {
     display: none;
   }
 

package/dist/esm/main/main.template.js

@@ -4,7 +4,8 @@ import { providerTag, routerTag } from '../tags';
  * @public
  */
 export const template = html `
-  <${providerTag} data-test-id="auth-provider">
+  <${providerTag} data-test-id="auth-provider" class="${(x) => x.classNames}">
     <${routerTag} :config=${(x) => x.config} data-test-id="auth-router"></${routerTag}>
+    <slot></slot>
   </${providerTag}>
 `;

package/dist/esm/mapper/loginMapper.js

@@ -3,7 +3,7 @@ import { UUID } from '@genesislcap/foundation-utils';
 import { DI } from '@microsoft/fast-foundation';
 import { CredentialType } from '../credential';
 import { MESSAGE_TYPE } from '../dto';
-import { isLoginParams } from '../machine';
+import { isLoginParams } from '../machine/types';
 import { logger } from '../utils';
 import { MappingError } from './error';
 import { fromDTOAck, fromDTONack, fromDTOStringArray, hasDTOErrorWarningCode } from './utils';
@@ -82,7 +82,7 @@ export class DefaultLoginMapper {
                     return ack;
                 }
                 if (isLoginNackDTO(dto)) {
-                    const nack = Object.assign(Object.assign({}, fromDTONack(dto)), { refreshAuthToken: dto.REFRESH_AUTH_TOKEN, isMFARequired: hasDTOErrorWarningCode(dto, 'MFA_REQUIRED'), hasPasswordExpired: hasDTOErrorWarningCode(dto, 'PASSWORD_EXPIRED') });
+                    const nack = Object.assign(Object.assign({}, fromDTONack(dto)), { refreshAuthToken: dto.REFRESH_AUTH_TOKEN, hasIncorrectCredentials: hasDTOErrorWarningCode(dto, 'INCORRECT_CREDENTIALS'), maxTriesReached: hasDTOErrorWarningCode(dto, 'MAX_TRIES_REACHED'), isMFARequired: hasDTOErrorWarningCode(dto, 'MFA_REQUIRED'), hasPasswordExpired: hasDTOErrorWarningCode(dto, 'PASSWORD_EXPIRED') });
                     return nack;
                 }
                 throw new Error('No Entity mapping implementation for provided DTO');

package/dist/esm/mapper/passwordManagementMapper.js

@@ -2,7 +2,7 @@ import { __decorate } from "tslib";
 import { UUID } from '@genesislcap/foundation-utils';
 import { DI } from '@microsoft/fast-foundation';
 import { MESSAGE_TYPE } from '../dto';
-import { isChangePasswordParams, isForgotPasswordParams, isResetPasswordParams } from '../machine';
+import { isChangePasswordParams, isForgotPasswordParams, isResetPasswordParams, } from '../machine/types';
 import { logger } from '../utils';
 import { MappingError } from './error';
 /**

package/dist/esm/mapper/utils.js

@@ -1,12 +1,11 @@
-import { MESSAGE_TYPE } from '../dto';
 /**
  * @public
  */
 export const fromDTOStringArray = (arr) => Array.isArray(arr) ? arr.map((v) => (v !== null && v !== void 0 ? v : '').toLowerCase()) : [];
 /**
- * @public
+ * @internal
  */
-export const fromDTONackErrorWarningArray = (arr) => Array.isArray(arr)
+const fromDTONackErrorWarningArray = (arr) => Array.isArray(arr)
     ? arr.map((v) => ({
         type: v['@type'],
         code: v.CODE,
@@ -16,9 +15,36 @@ export const fromDTONackErrorWarningArray = (arr) => Array.isArray(arr)
     : [];
 /**
  * includesErrorWarningCode
- * @public
+ * @internal
+ */
+const includesErrorWarningCode = (arr, code) => Array.isArray(arr) ? arr.some((e) => e.CODE === code || e.STATUS_CODE === code) : false;
+/**
+ * getNormalisedStatusCode
+ * @param arr - A NackErrorWarning array.
+ * @returns The highest status code.
+ * @internal
+ */
+const getNormalisedStatusCode = (arr) => {
+    if (!Array.isArray(arr) || arr.length === 0) {
+        return;
+    }
+    const codes = arr.map((msg) => {
+        try {
+            return parseInt(msg.statusCode);
+        }
+        catch (e) {
+            return 0;
+        }
+    });
+    return codes.sort().pop();
+};
+/**
+ * getNormalisedText
+ * @param arr - A NackErrorWarning array.
+ * @returns A combined text string.
+ * @internal
  */
-export const includesErrorWarningCode = (arr, code) => Array.isArray(arr) ? arr.some((e) => e.CODE === code || e.STATUS_CODE === code) : false;
+export const getNormalisedText = (arr) => Array.isArray(arr) && arr.length ? arr.map((msg) => msg.text).join(' ') : undefined;
 /**
  * hasDTOErrorWarningCode
  * @remarks
@@ -46,19 +72,49 @@ export const fromDTOAck = (dto) => ({
  * @param dto - NACK.
  * @public
  */
-export const fromDTONack = (dto) => ({
-    messageType: dto.MESSAGE_TYPE,
-    sourceRef: dto.SOURCE_REF,
-    error: fromDTONackErrorWarningArray(dto.ERROR),
-    warning: fromDTONackErrorWarningArray(dto.WARNING),
-});
+export const fromDTONack = (dto) => {
+    const error = fromDTONackErrorWarningArray(dto.ERROR);
+    const warning = fromDTONackErrorWarningArray(dto.WARNING);
+    return {
+        messageType: dto.MESSAGE_TYPE,
+        sourceRef: dto.SOURCE_REF,
+        error,
+        warning,
+        normalisedErrorStatusCode: getNormalisedStatusCode(error),
+        normalisedWarningStatusCode: getNormalisedStatusCode(warning),
+        normalisedErrorText: getNormalisedText(error),
+        normalisedWarningText: getNormalisedText(warning),
+    };
+};
+/**
+ * fromIDPDTO
+ * @param dto - IDP.
+ * @public
+ */
+export const fromIDPDTO = (dto) => {
+    return {
+        id: dto.ID,
+        type: dto.TYPE,
+        description: dto.DESCRIPTION,
+    };
+};
 /**
- * isDTONack.
+ * isNackDTO.
  * @param dto - Potential NACK.
  * @public
  */
 export function isNackDTO(dto) {
-    return (dto === null || dto === void 0 ? void 0 : dto.MESSAGE_TYPE) === MESSAGE_TYPE.EVENT_NACK;
+    var _a;
+    return (_a = dto === null || dto === void 0 ? void 0 : dto.MESSAGE_TYPE) === null || _a === void 0 ? void 0 : _a.endsWith('_NACK');
+}
+/**
+ * isNackEntity.
+ * @param entity - Potential Nack.
+ * @public
+ */
+export function isNackEntity(entity) {
+    var _a;
+    return (_a = entity === null || entity === void 0 ? void 0 : entity.messageType) === null || _a === void 0 ? void 0 : _a.endsWith('_NACK');
 }
 /**
  * createHTTPHeadersFromDTO.

package/dist/esm/routes/base.js

@@ -45,12 +45,6 @@ export class BaseRoute extends ConfigHostElement {
         super(...arguments);
         this.onBack = () => this.routing.navigateTo('/');
     }
-    attemptAutofill() {
-        const { autofilling, ssoToggled, username, password } = this.store.formEntry;
-        if (!autofilling && !ssoToggled && !username && !password) {
-            this.$emit('auth-autofill-form');
-        }
-    }
 }
 __decorate([
     AuthStore
@@ -313,13 +307,15 @@ export const showPasswordsCheckbox = () => html `
  */
 let MessageElement = class MessageElement extends FASTElement {
     get message() {
-        return this.store.authMachine.getMetaValuesByKey().join('/n');
+        const meta = this.store.metaMessages.join('/n');
+        const error = this.store.errorMessages.join('/n');
+        return !error ? meta : `${meta} ${error}.`;
     }
-    get nonError() {
-        return this.store.authMachine.errors.size === 0;
+    get hasError() {
+        return this.store.errorMessages.length > 0;
     }
     get classNames() {
-        return classNames('message', ['non-error', this.nonError]);
+        return classNames('message', ['has-error', this.hasError]);
     }
 };
 __decorate([
@@ -340,12 +336,12 @@ MessageElement = __decorate([
       text-align: center;
     }
     .message {
-      color: ${SecondaryRapidColorHEX.orange};
+      color: ${SecondaryRapidColorHEX.teal};
       margin-top: calc(var(--design-unit) * 3px);
       white-space: pre-line;
     }
-    .message.non-error {
-      color: ${SecondaryRapidColorHEX.teal};
+    .message.has-error {
+      color: ${SecondaryRapidColorHEX.orange};
     }
   `,
     })

package/dist/esm/routes/config.js

@@ -18,7 +18,7 @@ let AuthRouterConfig = class AuthRouterConfig extends RouterConfiguration {
         this.authConfig = authConfig;
     }
     configure() {
-        this.title = 'Login';
+        this.title = 'Auth';
         this.defaultLayout = defaultLayout;
         const routes = [
             {

package/dist/esm/routes/forgot-password/forgot-password.js

@@ -5,10 +5,6 @@ import { logger } from '../../utils';
 import { BaseRoute } from '../base';
 import { ForgotPasswordTemplate as template } from './forgot-password.template';
 let ForgotPassword = class ForgotPassword extends BaseRoute {
-    connectedCallback() {
-        super.connectedCallback();
-        this.attemptAutofill();
-    }
     onSubmit() {
         return __awaiter(this, void 0, void 0, function* () {
             logger.debug('forgot password submission');

package/dist/esm/routes/forgot-password/forgot-password.template.js

@@ -7,10 +7,10 @@ export const ForgotPasswordTemplate = html `
       <${cardTag} class="card-pd">
         <div class="column-content">
           <auth-logo></auth-logo>
-          <div class="heading2">Forgotten Password</div>
+          <div class="heading2" data-test-id="heading">Forgotten Password</div>
           <div class="heading3">Enter your account username</div>
         </div>
-        <form @submit=${(x) => x.onSubmit()}>
+        <form @submit=${(x) => x.onSubmit()} data-test-id="form">
           ${organisationField()} ${usernameField()}
           <div class="form-buttons">
             ${submitButton('Send Recovery Link')} ${backButton((x) => x.onBack())}

package/dist/esm/routes/index.js

@@ -1,4 +1,3 @@
 export * from './config';
-export * from './routing';
 export * from './types';
 export * from './utils';