@flarehr/apollo-super-selection 1.3.23524 → 1.3.23827

package/dist/lib/collection/components/super-selection-app/standard-choice/standard-choice-form.js

@@ -0,0 +1,155 @@
+import { Component, getAssetPath, h, Host, Prop, State } from '@stencil/core';
+import * as O from 'fp-ts/Option';
+import { assertExhaustive } from '../../../utils';
+import { EventTrackingService } from '../services/event-tracking.service';
+import navigationService from '../services/navigation.service';
+import { SuperSelectionAppRoutes } from '../services/super-selection-app.routes';
+import superSelectionAppService from '../services/super-selection-app.service';
+import standardChoiceFormState from './standard-choice-form.store';
+export class StandardChoiceFormInputDefaultFund {
+  constructor() {
+    this.standardChoiceFormSignature = '';
+    this.isSubmitDisabled = true;
+    this.eventTrackingService = EventTrackingService.Instance;
+    this.ignorePopState = () => window.history.pushState(null, '', null);
+  }
+  connectedCallback() {
+    this.ignorePopState();
+    window.addEventListener('popstate', this.ignorePopState);
+  }
+  disconnectedCallback() {
+    window.removeEventListener('popstate', this.ignorePopState);
+  }
+  render() {
+    return (h(Host, null,
+      h("div", { class: "text-2xl sm:text-3xl font-bold text-center" }, "Confirm your super choice"),
+      h("div", { class: "sm:text-lg text-gray-600 max-w-800 mt-4 text-center leading-7 sm:leading-8" }, "Your authorisation is required to complete your super choice by signing the standard choice form, which informs your employer of your choice of fund."),
+      h("div", { class: "flex justify-center mt-8 sm:mt-12" },
+        h("div", { class: "max-w-560" },
+          h("div", { class: "p-4 sm:p-6 border shadow-sm rounded-lg flex flex-col sm:flex-row" },
+            this.renderLogo(),
+            h("div", { class: "flex justify-between w-full" },
+              h("div", null,
+                h("div", { class: "text-xs font-semibold text-gray-500 uppercase" }, "Nominated fund"),
+                h("div", { class: "text-sm mt-2" }, standardChoiceFormState.fundName)),
+              h("div", { class: "grid content-center ml-4" },
+                h("sss-button", { testid: "change-fund-button", size: "xs", variant: "secondary", promiseFn: async () => {
+                    await this.trackChangeRequestedAsync();
+                    navigationService.navigateInternally(this.history, SuperSelectionAppRoutes.ChoicePage);
+                  } }, "Change")))),
+          h("div", { class: "mt-4 p-4 sm:p-6 border shadow-sm rounded-lg" },
+            h("div", { class: "sm:text-lg font-bold" }, "Superannuation Standard Choice Form"),
+            h("div", { class: "bg-blue-50 border-l-4 border-blue-400 p-4 mt-3" },
+              h("div", { class: "flex" },
+                h("div", { class: "flex-shrink-0" },
+                  h("img", { class: "h-5 w-5", src: getAssetPath('assets/icon-information-circle.svg') })),
+                h("div", { class: "ml-2" },
+                  h("p", { class: "text-sm text-blue-800 leading-5" }, "Applying your full name in the text field below is the same as applying your written signature and is legally binding.")))),
+            h("form", { noValidate: true, onSubmit: (ev) => ev.preventDefault(), class: {
+                'mt-3': true,
+                'was-validated': this.formState === 'validated'
+              }, ref: (el) => (this.formElement = el), onInput: (_) => (this.isSubmitDisabled = !this.formElement.checkValidity()) },
+              h("label", { class: "text-sm font-medium text-gray-700" }, "Type your full name"),
+              h("input", { "data-testid": "standard-choice-form-signature-input", type: "text", autocomplete: "off", class: {
+                  'shadow-sm focus:ring-primary-focus focus:border-primary-focus w-full text-base sm:text-sm border-gray-300 rounded-md mt-1': true,
+                  'invalid:border-red-300 invalid:text-red-900 invalid:focus:ring-red-500 invalid:focus:border-red-500': this.formState === 'validated'
+                }, required: true, minlength: "2", name: "standardChoiceFormSignature", id: "standardChoiceFormSignature", value: this.standardChoiceFormSignature, onInput: (event) => (this.standardChoiceFormSignature = event.target.value) }),
+              h("div", { class: "invalid-feedback mt-2 text-sm text-red-600" }, "Type your full name"),
+              h("div", { class: "mt-6" },
+                h("sss-button", { testid: "confirm-and-continue-button", fillWidth: true, promiseFn: () => this.handleSubmitForm(), disabled: this.isSubmitDisabled }, "Confirm and continue"))))))));
+  }
+  // TODO: fetch external promoted fund logo
+  renderLogo() {
+    return;
+    // if (standardChoiceFormState.promotedFundId == undefined) return;
+    // const logoSource = getLogoSrcByFundId(standardChoiceFormState.promotedFundId);
+    // if (isSome(logoSource)) {
+    //   return (
+    //     <div class="pb-4 mb-4 border-b flex justify-center sm:pb-0 sm:mb-0 sm:border-b-0 sm:pr-8 sm:mr-8 sm:border-r sm:justify-start">
+    //       <img
+    //         class="h-16 max-w-140 sm:h-12 sm:max-w-[100px] object-contain"
+    //         alt={standardChoiceFormState.fundName}
+    //         src={logoSource.value}
+    //       />
+    //     </div>
+    //   );
+    // }
+  }
+  async trackChangeRequestedAsync() {
+    const common = {
+      promotedFundsShown: superSelectionAppService.promotedFunds,
+      defaultFundUsiSet: O.toUndefined(superSelectionAppService.defaultFundUsi)
+    };
+    switch (standardChoiceFormState.fundDetails.type) {
+      case 'default':
+        await this.eventTrackingService.TrackSuperFundDetailChangeRequestedAsync({
+          DefaultFund: Object.assign(Object.assign({}, standardChoiceFormState.fundDetails), common)
+        });
+        break;
+      case 'myOwnFund':
+        await this.eventTrackingService.TrackSuperFundDetailChangeRequestedAsync({
+          MyOwnFund: Object.assign(Object.assign({}, standardChoiceFormState.fundDetails), common)
+        });
+        break;
+      case 'smsf':
+        await this.eventTrackingService.TrackSuperFundDetailChangeRequestedAsync({
+          Smsf: Object.assign(Object.assign({}, standardChoiceFormState.fundDetails), common)
+        });
+        break;
+      case 'promoted':
+        await this.eventTrackingService.TrackSuperFundDetailChangeRequestedAsync({
+          PromotedFund: Object.assign(Object.assign({}, standardChoiceFormState.fundDetails), common)
+        });
+        break;
+      case 'promotedDefault':
+        await this.eventTrackingService.TrackSuperFundDetailChangeRequestedAsync({
+          PromotedDefaultFund: Object.assign(Object.assign({}, standardChoiceFormState.fundDetails), common)
+        });
+        break;
+      case 'promotedDefaultWithJoin':
+        await this.eventTrackingService.TrackSuperFundDetailChangeRequestedAsync({
+          PromotedDefaultFundWithJoin: Object.assign(Object.assign({}, standardChoiceFormState.fundDetails), common)
+        });
+        break;
+      case 'null':
+        throw 'standardChoiceFormState.fundDetails was not set';
+      default:
+        assertExhaustive(standardChoiceFormState.fundDetails);
+    }
+  }
+  async handleSubmitForm() {
+    this.formState = 'validated';
+    if (this.formElement.checkValidity()) {
+      await standardChoiceFormState.handleSubmitFn(this.standardChoiceFormSignature.trim());
+      superSelectionAppService.markSuperSelectionAsSubmitted();
+    }
+  }
+  static get is() { return "sss-standard-choice-form"; }
+  static get properties() { return {
+    "history": {
+      "type": "unknown",
+      "mutable": false,
+      "complexType": {
+        "original": "RouterHistory",
+        "resolved": "RouterHistory",
+        "references": {
+          "RouterHistory": {
+            "location": "import",
+            "path": "@stencil/router"
+          }
+        }
+      },
+      "required": false,
+      "optional": false,
+      "docs": {
+        "tags": [],
+        "text": ""
+      }
+    }
+  }; }
+  static get states() { return {
+    "standardChoiceFormSignature": {},
+    "formState": {},
+    "isSubmitDisabled": {}
+  }; }
+}

package/dist/lib/collection/components/super-selection-app/standard-choice/standard-choice-form.store.js

@@ -0,0 +1,11 @@
+import { createStore } from '@stencil/store';
+export const initial = {
+  handleSubmitFn: async function () {
+    return;
+  },
+  fundName: '',
+  fundDetails: { type: 'null' },
+  promotedFundId: undefined
+};
+const { state } = createStore(initial);
+export default state;

package/dist/lib/collection/components/super-selection-app/super-selection-app.css

@@ -0,0 +1,27 @@
+html {
+  scroll-behavior: smooth;
+}
+
+stencil-route {
+  display: flex;
+  flex: 1 1 auto;
+  justify-content: center;
+}
+stencil-route:empty {
+  display: none;
+}
+
+input + .invalid-feedback {
+  display: none;
+}
+
+select + .invalid-feedback {
+  display: none;
+}
+
+.was-validated input:invalid + .invalid-feedback {
+  display: block;
+}
+.was-validated select:invalid + .invalid-feedback {
+  display: block;
+}

package/dist/lib/collection/components/super-selection-app/super-selection-app.js

@@ -0,0 +1,291 @@
+import { Component, Event, getAssetPath, h, Host, Prop, State, Watch } from '@stencil/core';
+import { injectHistory } from '@stencil/router';
+import * as O from 'fp-ts/lib/Option';
+import { isNone, isSome } from 'fp-ts/lib/Option';
+import iframe from '../../utils/iframe';
+import existingFundService from './services/existing-super-choice-info.service';
+import navigationService from './services/navigation.service';
+import { SuperSelectionAppRoutes, superSelectionAppStencilRoutes } from './services/super-selection-app.routes';
+import superSelectionAppService from './services/super-selection-app.service';
+export class SuperSelectionApp {
+  constructor() {
+    this.isSelfHosted = false;
+    this.isAppInitialised = false;
+  }
+  async componentWillLoad() {
+    const jwt = O.fromNullable(this.accessToken);
+    if (O.isNone(jwt)) {
+      throw Error(`jwt property is missing.`);
+    }
+    superSelectionAppService.state.jwt = jwt;
+    const apiBaseUrl = O.fromNullable(this.backendUrl);
+    if (O.isNone(apiBaseUrl)) {
+      throw Error(`apiBaseUrl property is missing.`);
+    }
+    superSelectionAppService.state.apiBaseUrl = O.some(apiBaseUrl.value.replace(/\/$/, '') + '/');
+    const appBaseUrl = O.fromNullable(this.appBaseUrl);
+    if (O.isNone(appBaseUrl)) {
+      throw Error(`appBaseUrl property is missing.`);
+    }
+    superSelectionAppService.state.appBaseUrl = O.some(appBaseUrl.value.replace(/\/$/, ''));
+    superSelectionAppService.onChange('hasSuccessPageBeenAcknowledged', (_) => this.successPageAcknowledged.emit());
+    superSelectionAppService.onChange('hasSuperSelectionBeenSubmitted', (submitted) => {
+      if (!submitted)
+        return;
+      this.stepSubmitSuccess.emit();
+      superSelectionAppService.state.hasSuperSelectionBeenSubmitted = false;
+      if (this.isSelfHosted) {
+        navigationService.navigateInternally(this.history, SuperSelectionAppRoutes.Success);
+      }
+    });
+  }
+  async componentDidLoad() {
+    await superSelectionAppService.loadAppStateAsync();
+    const chosenFundOption = await existingFundService.GetExistingFundAsync();
+    this.isAppInitialised = true;
+    this.initialised.emit({
+      accountIdOrDefault: superSelectionAppService.accountIdOrDefault,
+      partnerIdOrDefault: superSelectionAppService.partnerIdOrDefault,
+      profileId: superSelectionAppService.profileId
+    });
+    iframe.appReady();
+    const ignoreExistingSelectionOption = O.fromNullable(this.ignoreExistingSelection);
+    const shouldIgnoreExistingDefinedBenefitsChoice = isSome(chosenFundOption) &&
+      chosenFundOption.value.type == 'Defined Benefits Fund' &&
+      (isNone(superSelectionAppService.isDefinedBenefitsEligible) ||
+        !superSelectionAppService.isDefinedBenefitsEligible.value);
+    const shouldIgnoreExistingChoice = (isSome(ignoreExistingSelectionOption) && ignoreExistingSelectionOption.value) ||
+      shouldIgnoreExistingDefinedBenefitsChoice;
+    if (isSome(superSelectionAppService.state.superChoicePrefill)) {
+      navigationService.navigateInternally(this.history, SuperSelectionAppRoutes.Prefill);
+    }
+    else if (isSome(chosenFundOption) &&
+      chosenFundOption.value.valid !== 'Inactive' &&
+      !shouldIgnoreExistingChoice) {
+      navigationService.navigateInternally(this.history, SuperSelectionAppRoutes.ExistingChoicePage);
+    }
+    else {
+      navigationService.navigateInternally(this.history, SuperSelectionAppRoutes.ChoicePage);
+    }
+  }
+  authTokenChanged(newValue) {
+    superSelectionAppService.state.jwt = O.fromNullable(newValue);
+  }
+  onRouteChange() {
+    window === null || window === void 0 ? void 0 : window.scroll(0, 0);
+  }
+  render() {
+    return (h(Host, null,
+      h("link", { rel: "stylesheet", href: getAssetPath('apollo-super-selection.css'), media: "all" }),
+      this.renderAppContent()));
+  }
+  routerBaseUrl() {
+    var _a;
+    return ((_a = this.appBaseUrl) === null || _a === void 0 ? void 0 : _a.replace(/\/$/, '')) + '/';
+  }
+  renderAppContent() {
+    return (h("stencil-router", { root: this.routerBaseUrl(), class: "font-inter" },
+      h("stencil-route-switch", { scrollTopOffset: 0 }, this.isAppInitialised ? (h("div", { class: "pt-28 -mt-12 pb-6" },
+        superSelectionAppStencilRoutes,
+        h("sss-footer-section", null))) : (h("div", { class: "flex justify-center py-20" },
+        h("sss-loading-indicator", null))))));
+  }
+  static get is() { return "super-selection-app"; }
+  static get encapsulation() { return "shadow"; }
+  static get originalStyleUrls() { return {
+    "$": ["super-selection-app.scss"]
+  }; }
+  static get styleUrls() { return {
+    "$": ["super-selection-app.css"]
+  }; }
+  static get assetsDirs() { return ["assets"]; }
+  static get properties() { return {
+    "ignoreExistingSelection": {
+      "type": "boolean",
+      "mutable": false,
+      "complexType": {
+        "original": "boolean",
+        "resolved": "boolean | undefined",
+        "references": {}
+      },
+      "required": false,
+      "optional": true,
+      "docs": {
+        "tags": [],
+        "text": ""
+      },
+      "attribute": "ignore-existing-selection",
+      "reflect": false
+    },
+    "accessToken": {
+      "type": "string",
+      "mutable": false,
+      "complexType": {
+        "original": "string",
+        "resolved": "string",
+        "references": {}
+      },
+      "required": false,
+      "optional": false,
+      "docs": {
+        "tags": [],
+        "text": ""
+      },
+      "attribute": "access-token",
+      "reflect": false
+    },
+    "backendUrl": {
+      "type": "string",
+      "mutable": false,
+      "complexType": {
+        "original": "string",
+        "resolved": "string | undefined",
+        "references": {}
+      },
+      "required": false,
+      "optional": true,
+      "docs": {
+        "tags": [],
+        "text": ""
+      },
+      "attribute": "backend-url",
+      "reflect": false
+    },
+    "appBaseUrl": {
+      "type": "string",
+      "mutable": false,
+      "complexType": {
+        "original": "string",
+        "resolved": "string | undefined",
+        "references": {}
+      },
+      "required": false,
+      "optional": true,
+      "docs": {
+        "tags": [],
+        "text": ""
+      },
+      "attribute": "app-base-url",
+      "reflect": false
+    },
+    "history": {
+      "type": "unknown",
+      "mutable": false,
+      "complexType": {
+        "original": "RouterHistory",
+        "resolved": "RouterHistory",
+        "references": {
+          "RouterHistory": {
+            "location": "import",
+            "path": "@stencil/router"
+          }
+        }
+      },
+      "required": false,
+      "optional": false,
+      "docs": {
+        "tags": [],
+        "text": ""
+      }
+    },
+    "location": {
+      "type": "unknown",
+      "mutable": false,
+      "complexType": {
+        "original": "LocationSegments",
+        "resolved": "LocationSegments | undefined",
+        "references": {
+          "LocationSegments": {
+            "location": "import",
+            "path": "@stencil/router"
+          }
+        }
+      },
+      "required": false,
+      "optional": true,
+      "docs": {
+        "tags": [],
+        "text": ""
+      }
+    },
+    "isSelfHosted": {
+      "type": "boolean",
+      "mutable": false,
+      "complexType": {
+        "original": "boolean",
+        "resolved": "boolean",
+        "references": {}
+      },
+      "required": false,
+      "optional": false,
+      "docs": {
+        "tags": [],
+        "text": ""
+      },
+      "attribute": "is-self-hosted",
+      "reflect": false,
+      "defaultValue": "false"
+    }
+  }; }
+  static get states() { return {
+    "isAppInitialised": {}
+  }; }
+  static get events() { return [{
+      "method": "stepSubmitSuccess",
+      "name": "step-completion",
+      "bubbles": true,
+      "cancelable": true,
+      "composed": true,
+      "docs": {
+        "tags": [],
+        "text": ""
+      },
+      "complexType": {
+        "original": "void",
+        "resolved": "void",
+        "references": {}
+      }
+    }, {
+      "method": "successPageAcknowledged",
+      "name": "successPageAcknowledged",
+      "bubbles": true,
+      "cancelable": true,
+      "composed": false,
+      "docs": {
+        "tags": [],
+        "text": ""
+      },
+      "complexType": {
+        "original": "void",
+        "resolved": "void",
+        "references": {}
+      }
+    }, {
+      "method": "initialised",
+      "name": "initialised",
+      "bubbles": true,
+      "cancelable": true,
+      "composed": true,
+      "docs": {
+        "tags": [],
+        "text": ""
+      },
+      "complexType": {
+        "original": "InitialisedWith",
+        "resolved": "{ accountIdOrDefault: string; partnerIdOrDefault: string; profileId: string; }",
+        "references": {
+          "InitialisedWith": {
+            "location": "local"
+          }
+        }
+      }
+    }]; }
+  static get watchers() { return [{
+      "propName": "accessToken",
+      "methodName": "authTokenChanged"
+    }, {
+      "propName": "location",
+      "methodName": "onRouteChange"
+    }]; }
+}
+injectHistory(SuperSelectionApp);

package/dist/lib/collection/components/super-smsf/super-smsf-types.js

@@ -0,0 +1 @@
+export const LoadWaitingTimeout = 30000;

package/dist/lib/collection/components/super-smsf/super-smsf.form.js

@@ -0,0 +1 @@
+export {};

package/dist/lib/collection/components/super-smsf/super-smsf.js

@@ -0,0 +1,166 @@
+import { Component, h, Host, Prop, State } from '@stencil/core';
+import { injectHistory } from '@stencil/router';
+import { isSome, toUndefined } from 'fp-ts/lib/Option';
+import customFundChoiceApi from '../super-selection-app/funds/custom-fund/api/custom-fund-choice.api';
+import customFundState from '../super-selection-app/funds/custom-fund/custom-fund.store';
+import { EventTrackingService } from '../super-selection-app/services/event-tracking.service';
+import navigationService from '../super-selection-app/services/navigation.service';
+import { SuperSelectionAppRoutes } from '../super-selection-app/services/super-selection-app.routes';
+import superSelectionAppService from '../super-selection-app/services/super-selection-app.service';
+import { LoadWaitingTimeout } from './super-smsf-types';
+var SuperSmsfComponentStatus;
+(function (SuperSmsfComponentStatus) {
+  SuperSmsfComponentStatus[SuperSmsfComponentStatus["NotLoaded"] = 1] = "NotLoaded";
+  SuperSmsfComponentStatus[SuperSmsfComponentStatus["Loaded"] = 2] = "Loaded";
+})(SuperSmsfComponentStatus || (SuperSmsfComponentStatus = {}));
+let superSmsfComponentStatus = SuperSmsfComponentStatus.NotLoaded;
+export class SuperSmsfHost {
+  constructor() {
+    this.eventTrackingService = EventTrackingService.Instance;
+    this.subscribeToSuperSmsfEvents = () => {
+      for (const eventName in this.smsfEventHandlers) {
+        document.addEventListener(eventName, this.smsfEventHandlers[eventName]);
+      }
+    };
+    this.unSubscribeFromSuperSmsfEvents = () => {
+      for (const eventName in this.smsfEventHandlers) {
+        document.removeEventListener(eventName, this.smsfEventHandlers[eventName]);
+      }
+    };
+    this.smsfLoaded = async (event) => {
+      if (event.detail.sender === 'super-smsf') {
+        superSmsfComponentStatus = SuperSmsfComponentStatus.Loaded;
+        clearTimeout(this.loadingTimeoutRef);
+        await this.eventTrackingService.TrackSmsfSuperFundDetailViewedAsync({
+          promotedFundsShown: superSelectionAppService.promotedFunds,
+          defaultFundUsiSet: toUndefined(superSelectionAppService.defaultFundUsi)
+        });
+      }
+      return Promise.resolve();
+    };
+    this.smsfCompleted = async (event) => {
+      if (event.detail.sender === 'super-smsf') {
+        this.updateCustomFundStateStore(event.detail);
+        if (superSelectionAppService.isSmsfCustomStepEnabled &&
+          superSelectionAppService.isUsingSuperCampaign) {
+          navigationService.navigateInternally(this.history, SuperSelectionAppRoutes.SmsfEngagementStep);
+          return;
+        }
+        navigationService.navigateInternallyToStandardChoice({
+          history: this.history,
+          fundName: 'Self-managed super fund',
+          fundDetails: {
+            type: 'smsf',
+            fundName: event.detail.fundName,
+            fundEsa: event.detail.fundEsa
+          },
+          handleSubmitFn: async (standardChoiceFormSignature) => {
+            const requestDto = Object.assign({ smsfChoice: {
+                abn: event.detail.fundAbn,
+                fundName: event.detail.fundName,
+                fundAddress: {
+                  addressLine1: event.detail.fundAddressLine1,
+                  addressLine2: event.detail.fundAddressLine2,
+                  city: event.detail.fundCity,
+                  state: event.detail.fundState,
+                  postcode: event.detail.fundPostcode
+                },
+                bsb: event.detail.bankBsb,
+                bankAccountName: event.detail.bankAccountName,
+                bankAccountNumber: event.detail.bankAccountNumber,
+                electronicServiceAddress: event.detail.fundEsa,
+                memberFirstName: event.detail.memberFirstName,
+                memberFamilyName: event.detail.memberLastName
+              }, standardChoiceFormSignature }, superSelectionAppService.promotedFundsConfig);
+            await customFundChoiceApi.submitSelfManagedFundChoiceAsync(requestDto);
+          }
+        });
+      }
+    };
+    this.smsfCancelled = async (event) => {
+      if (event.detail.sender === 'super-smsf') {
+        navigationService.navigateInternally(this.history, SuperSelectionAppRoutes.ChoicePage);
+      }
+    };
+    this.smsfEventHandlers = {
+      'smsf-loaded': this.smsfLoaded.bind(this),
+      'smsf-completed': this.smsfCompleted.bind(this),
+      'smsf-cancelled': this.smsfCancelled.bind(this)
+    };
+  }
+  async componentWillLoad() {
+    if (isSome(superSelectionAppService.backendUrl) && isSome(superSelectionAppService.state.jwt)) {
+      this.backendUrl = superSelectionAppService.backendUrl.value;
+      this.accessToken = superSelectionAppService.state.jwt.value;
+      if (superSmsfComponentStatus === SuperSmsfComponentStatus.NotLoaded) {
+        this.loadingTimeoutRef = setTimeout(this.smsfLoadingTimeoutTriggered.bind(this), LoadWaitingTimeout);
+      }
+      this.subscribeToSuperSmsfEvents();
+    }
+    else {
+      throw Error(`SuperSmsfHost pre-requisites not met.`);
+    }
+  }
+  disconnectedCallback() {
+    clearTimeout(this.loadingTimeoutRef);
+    this.unSubscribeFromSuperSmsfEvents();
+  }
+  render() {
+    return (h(Host, null,
+      h("sss-header-section", null),
+      h("div", { class: "flex justify-center mt-11" },
+        h("sss-custom-fund", null,
+          h("div", null,
+            h("apollo-super-smsf", { "backend-url": this.backendUrl, "access-token": this.accessToken }))))));
+  }
+  updateCustomFundStateStore(details) {
+    customFundState.selfManagedFundForm = {
+      fundAbn: details.fundAbn,
+      fundName: details.fundName,
+      addressLine1: details.fundAddressLine1,
+      addressLine2: details.fundAddressLine2,
+      city: details.fundCity,
+      state: details.fundState,
+      postcode: details.fundPostcode,
+      bsb: details.bankBsb,
+      bankAccountName: details.bankAccountName,
+      bankAccountNumber: details.bankAccountNumber,
+      fundEsa: details.fundEsa,
+      memberFirstName: details.memberFirstName,
+      memberFamilyName: details.memberLastName
+    };
+  }
+  async smsfLoadingTimeoutTriggered() {
+    if (superSmsfComponentStatus !== SuperSmsfComponentStatus.Loaded) {
+      throw Error(`SMSF component failed to load.`);
+    }
+  }
+  static get is() { return "sss-super-smsf-host"; }
+  static get properties() { return {
+    "history": {
+      "type": "unknown",
+      "mutable": false,
+      "complexType": {
+        "original": "RouterHistory",
+        "resolved": "RouterHistory",
+        "references": {
+          "RouterHistory": {
+            "location": "import",
+            "path": "@stencil/router"
+          }
+        }
+      },
+      "required": false,
+      "optional": false,
+      "docs": {
+        "tags": [],
+        "text": ""
+      }
+    }
+  }; }
+  static get states() { return {
+    "backendUrl": {},
+    "accessToken": {}
+  }; }
+}
+injectHistory(SuperSmsfHost);

package/dist/lib/collection/global/init-host.js

@@ -0,0 +1,25 @@
+import appConfigurationService from '../components/app-host/services/app-configuration.service';
+import appParametersService from '../components/app-host/services/app-parameters.service';
+import appInsights from '../components/app-host/services/appinsights.service';
+import sessionQuery from '../components/app-host/services/authentication.query';
+import authenticationService from '../components/app-host/services/authentication.service';
+import hostInteropService from '../components/app-host/services/interop/host-interop.service';
+import { Environment } from '../utils';
+import { addSlashToUrl } from '../utils';
+export default async function () {
+  if (Environment !== 'prod') {
+    // main.dev.ts does the bootstrapping in this case.
+    return;
+  }
+  appParametersService.init(window.location.search);
+  await appConfigurationService.loadConfigurationAsync();
+  appInsights.init();
+  addSlashToUrl();
+  const doAuthFlow = sessionQuery.isUnauthorized ||
+    authenticationService.authorizationCodeIsPresent(window.location.search);
+  if (!doAuthFlow) {
+    return;
+  }
+  hostInteropService.init(window.location.search);
+  authenticationService.initFromRoute(window.location.search);
+}