@flarehr/apollo-super-selection 1.3.23524 → 1.3.23680

package/dist/lib/collection/components/app-host/services/interop/iframe-interop.service.js

@@ -0,0 +1,30 @@
+import * as O from 'fp-ts/lib/Option';
+import iframe from '../../../../utils/iframe';
+import interopQuery from '../interop.query';
+export class IFrameInteropService {
+  static completeSuperSelectionStep() {
+    const { successRedirectionUrl } = interopQuery.getIframeInteropMode();
+    if (O.isSome(successRedirectionUrl)) {
+      window.top.location.href = successRedirectionUrl.value;
+    }
+    else {
+      iframe.complete();
+    }
+  }
+  static initFromRoute(route) {
+    const redirectionUrlQueryParameter = 'success-redirection-url';
+    const urlParams = new URLSearchParams(route);
+    const redirectionUrl = O.fromNullable(urlParams.get(redirectionUrlQueryParameter));
+    const iframeMode = { successRedirectionUrl: O.none };
+    if (O.isSome(redirectionUrl)) {
+      try {
+        const validatedUrl = new URL(redirectionUrl.value);
+        iframeMode.successRedirectionUrl = O.some(validatedUrl.toString());
+      }
+      catch (error) {
+        throw Error(`"${redirectionUrl.value}" is not a valid URL`);
+      }
+    }
+    return iframeMode;
+  }
+}

package/dist/lib/collection/components/app-host/services/interop/react-native-interop.service.js

@@ -0,0 +1,20 @@
+import { ReactNativeInteropMode } from '../session.store';
+export class ReactNativeInteropService {
+  static init() {
+    const isMessagingAvailable = window['ReactNativeWebView'] !== undefined;
+    if (!isMessagingAvailable) {
+      throw Error('React Native WebView messaging is not enabled. Please, refer to https://github.com/react-native-webview/react-native-webview/blob/master/docs/Guide.md#the-windowreactnativewebviewpostmessage-method-and-onmessage-prop');
+    }
+    return new ReactNativeInteropMode();
+  }
+  static completeSuperSelectionStep() {
+    this.postRNMessage();
+  }
+  static postRNMessage() {
+    const message = {
+      stepStatus: 'completed'
+    };
+    ReactNativeInteropService.getRnInterop().postMessage(JSON.stringify(message));
+  }
+}
+ReactNativeInteropService.getRnInterop = () => window['ReactNativeWebView'];

package/dist/lib/collection/components/app-host/services/interop.query.js

@@ -0,0 +1,26 @@
+import { Query } from '@datorama/akita';
+import * as O from 'fp-ts/Option';
+import sessionStore from './session.store';
+export class InteropQuery extends Query {
+  constructor(store) {
+    super(store);
+    this.store = store;
+  }
+  isReactNativeInteropEnabled() {
+    return O.isSome(this.getValue().reactNativeInterop);
+  }
+  isIframeInteropEnabled() {
+    return O.isSome(this.getValue().iframeInterop);
+  }
+  getIframeInteropMode() {
+    const iframeInterop = this.getValue().iframeInterop;
+    if (O.isNone(iframeInterop)) {
+      throw Error('Failed to get iframe interop information: no data in store');
+    }
+    if (!this.isIframeInteropEnabled()) {
+      throw Error('Failed to get iframe interop information: iframe mode is disabled');
+    }
+    return iframeInterop.value;
+  }
+}
+export default new InteropQuery(sessionStore);

package/dist/lib/collection/components/app-host/services/session.store.js

@@ -0,0 +1,38 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+  else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+import { Store, StoreConfig } from '@datorama/akita';
+import * as O from 'fp-ts/Option';
+export var AuthenticationState;
+(function (AuthenticationState) {
+  AuthenticationState[AuthenticationState["Unauthorized"] = 0] = "Unauthorized";
+  AuthenticationState[AuthenticationState["Authenticated"] = 1] = "Authenticated";
+  AuthenticationState[AuthenticationState["Error"] = 2] = "Error";
+})(AuthenticationState || (AuthenticationState = {}));
+export class ReactNativeInteropMode {
+}
+export class IframeInteropMode {
+}
+export function createInitialState() {
+  return {
+    authenticationState: AuthenticationState.Unauthorized,
+    jwt: O.none,
+    reactNativeInterop: O.none,
+    iframeInterop: O.none,
+    appConfiguration: O.none,
+    ignoreExistingSelection: false
+  };
+}
+let SessionStore = class SessionStore extends Store {
+  constructor() {
+    super(createInitialState());
+  }
+};
+SessionStore = __decorate([
+  StoreConfig({ name: 'sss-session', resettable: true })
+], SessionStore);
+export { SessionStore };
+export default new SessionStore();

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

@@ -0,0 +1,24 @@
+html {
+  scroll-behavior: smooth;
+}
+
+.sss-app-container {
+  --fl-color-primary: #2E66F7;
+  --fl-color-primary-light: #EAF0FE;
+  --fl-color-primary-dark: #031495;
+  --fl-color-primary-disabled: #88ABFA;
+  --fl-color-primary-hover: #5786F8;
+  --fl-color-primary-focus: #1033C6;
+  --fl-color-primary-text: #3d3d3d;
+  --fl-color-secondary: #e5e5e5;
+  --fl-color-secondary-hover: #b3b3b3;
+  --fl-color-secondary-focus: #b3b3b3;
+}
+
+@media screen and (-webkit-min-device-pixel-ratio: 0) {
+  select,
+textarea,
+input {
+    font-size: 16px;
+  }
+}

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

@@ -0,0 +1,87 @@
+import { ResizeObserver as ResizeObserverPolyfill } from '@juggle/resize-observer';
+import { Component, getAssetPath, h, Host, State } from '@stencil/core';
+import { isNone, toUndefined } from 'fp-ts/lib/Option';
+import initHost from '../../global/init-host';
+import { assertExhaustive } from '../../utils';
+import iframe from '../../utils/iframe';
+import appInsights from '../app-host/services/appinsights.service';
+import appConfigurationQuery from './services/app-configuration.query';
+import appConfigurationService from './services/app-configuration.service';
+import appParametersQuery from './services/app-parameters.query';
+import sessionQuery from './services/authentication.query';
+import hostInteropService from './services/interop/host-interop.service';
+import { AuthenticationState } from './services/session.store';
+export class SuperSelectionAppHost {
+  async componentWillLoad() {
+    await initHost();
+    sessionQuery.sessionState$.subscribe((updatedState) => (this.sessionState = updatedState));
+    sessionQuery.jwt$.subscribe((newToken) => (this.jwt = newToken));
+    appConfigurationQuery.appConfiguration$.subscribe((updatedConfiguration) => (this.appConfiguration = updatedConfiguration));
+    appParametersQuery.ignoreExistingSelection$.subscribe((newValue) => (this.ignoreExistingSelection = newValue));
+  }
+  render() {
+    return (h(Host, null,
+      h("link", { rel: "stylesheet", href: getAssetPath('apollo-super-selection.css'), media: "all" }),
+      h("div", { ref: (el) => this.observeContentResize(el) }, isNone(this.appConfiguration) ? (h("sss-loading-page", { class: "font-inter" })) : (this.renderAppContent()))));
+  }
+  renderAppContent() {
+    return (h("stencil-router", { root: appConfigurationService.getAppRootUrl(), class: "sss-app-container" },
+      h("stencil-route-switch", { scrollTopOffset: 0 },
+        h("stencil-route", { url: "/", routeRender: this.renderProtectedRoute((props) => (h("super-selection-app", Object.assign({ accessToken: toUndefined(this.jwt), ignoreExistingSelection: this.ignoreExistingSelection, backendUrl: appConfigurationQuery.configuration.ApiBaseUrl, appBaseUrl: this.getAppBaseUrl(), onSuccessPageAcknowledged: this.handleSuccessPageAcknowledged, "onStep-completion": this.handleStepSubmitSuccess, onInitialised: this.handleAppInitialised, isSelfHosted: true }, props)))) }))));
+  }
+  getAppBaseUrl() {
+    const splits = window.location.pathname.split('app');
+    return splits[0] + 'app/';
+  }
+  handleSuccessPageAcknowledged() {
+    hostInteropService.completeSuperSelectionStep();
+  }
+  handleStepSubmitSuccess() {
+    iframe.submitSuccess();
+  }
+  handleAppInitialised(evt) {
+    appInsights.addCustomProperties({
+      'X-ACCOUNT-ID': evt.detail.accountIdOrDefault,
+      'X-PARTNER-ID': evt.detail.partnerIdOrDefault,
+      'X-PROFILE-ID': evt.detail.profileId
+    });
+    appInsights.getAppInsights().trackPageView();
+    const loadingPageContainer = document.getElementById('sss-external-loading-page-container');
+    if (loadingPageContainer) {
+      document.body.removeChild(loadingPageContainer);
+    }
+  }
+  observeContentResize(appContent) {
+    const ResizeObserver = window.ResizeObserver || ResizeObserverPolyfill;
+    new ResizeObserver(() => {
+      iframe.resize(appContent.offsetHeight, -1);
+    }).observe(appContent);
+  }
+  renderProtectedRoute(renderProtectedComponent) {
+    switch (this.sessionState) {
+      case AuthenticationState.Authenticated:
+        return renderProtectedComponent;
+      case AuthenticationState.Unauthorized:
+        return () => h("sss-loading-page", null);
+      case AuthenticationState.Error:
+        return () => h("h1", null, "Authentication Error");
+      default:
+        assertExhaustive(this.sessionState);
+        return () => h("h1", null, "Authentication Error");
+    }
+  }
+  static get is() { return "super-selection-app-host"; }
+  static get encapsulation() { return "shadow"; }
+  static get originalStyleUrls() { return {
+    "$": ["super-selection-app-host.scss"]
+  }; }
+  static get styleUrls() { return {
+    "$": ["super-selection-app-host.css"]
+  }; }
+  static get states() { return {
+    "sessionState": {},
+    "jwt": {},
+    "appConfiguration": {},
+    "ignoreExistingSelection": {}
+  }; }
+}

package/dist/lib/collection/components/external-loading-page/external-loading-page.js

@@ -0,0 +1,29 @@
+(function () {
+  var container = document.getElementById('sss-external-loading-page-container');
+
+  setTimeout(function () {
+    var loadingPage1 = document.getElementById('sss-external-loading-page-1');
+    if (container && loadingPage1) {
+      container.removeChild(loadingPage1);
+    }
+  }, 8000);
+
+  setTimeout(function () {
+    var loadingPage2 = document.getElementById('sss-external-loading-page-2');
+    if (container && loadingPage2) {
+      container.removeChild(loadingPage2);
+    }
+  }, 30000);
+
+  setTimeout(function () {
+    window.parent.postMessage(
+      {
+        type: 'contentResized',
+        height: container.offsetHeight,
+        width: -1,
+        sender: 'flare'
+      },
+      '*'
+    );
+  }, 0);
+})();

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

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

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

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

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

@@ -0,0 +1,139 @@
+import { Component, h, Host, Prop, State } from '@stencil/core';
+import { injectHistory } from '@stencil/router';
+import { fromNullable, 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-byof-types';
+var SuperByofComponentStatus;
+(function (SuperByofComponentStatus) {
+  SuperByofComponentStatus[SuperByofComponentStatus["NotLoaded"] = 1] = "NotLoaded";
+  SuperByofComponentStatus[SuperByofComponentStatus["Loaded"] = 2] = "Loaded";
+})(SuperByofComponentStatus || (SuperByofComponentStatus = {}));
+let superByofComponentStatus = SuperByofComponentStatus.NotLoaded;
+export class SuperByofHost {
+  constructor() {
+    this.eventTrackingService = EventTrackingService.Instance;
+    this.subscribeToSuperByofEvents = () => {
+      for (const eventName in this.byofEventHandlers) {
+        document.addEventListener(eventName, this.byofEventHandlers[eventName]);
+      }
+    };
+    this.unSubscribeFromSuperByofEvents = () => {
+      for (const eventName in this.byofEventHandlers) {
+        document.removeEventListener(eventName, this.byofEventHandlers[eventName]);
+      }
+    };
+    this.byofLoaded = async (event) => {
+      if (event.detail.sender === 'super-byof') {
+        superByofComponentStatus = SuperByofComponentStatus.Loaded;
+        clearTimeout(this.loadingTimeoutRef);
+        this.eventTrackingService.TrackMyOwnSuperFundDetailViewedAsync({
+          promotedFundsShown: superSelectionAppService.promotedFunds,
+          defaultFundUsiSet: toUndefined(superSelectionAppService.defaultFundUsi)
+        });
+      }
+      return Promise.resolve();
+    };
+    this.byofCompleted = async (event) => {
+      if (event.detail.sender === 'super-byof') {
+        customFundState.myOwnFundForm = {
+          fundUsi: fromNullable(event.detail.fundUsi),
+          fundName: fromNullable(event.detail.fundName),
+          memberNumber: fromNullable(event.detail.memberNumber),
+          memberFirstName: fromNullable(event.detail.memberFirstName),
+          memberFamilyName: fromNullable(event.detail.memberLastName)
+        };
+        if (superSelectionAppService.isBringYourOwnFundCustomStepEnabled &&
+          superSelectionAppService.isUsingSuperCampaign) {
+          navigationService.navigateInternally(this.history, SuperSelectionAppRoutes.MyOwnFundEngagementStep);
+          return;
+        }
+        navigationService.navigateInternallyToStandardChoice({
+          history: this.history,
+          fundName: event.detail.fundName,
+          fundDetails: {
+            type: 'myOwnFund',
+            fundName: event.detail.fundName,
+            fundUsi: event.detail.fundUsi,
+            memberNumber: event.detail.memberNumber
+          },
+          handleSubmitFn: async (standardChoiceFormSignature) => {
+            const customFundChoiceDto = Object.assign({ fundUsi: event.detail.fundUsi, memberNumber: event.detail.memberNumber, memberFirstName: event.detail.memberFirstName, memberFamilyName: event.detail.memberLastName, standardChoiceFormSignature }, superSelectionAppService.promotedFundsConfig);
+            await customFundChoiceApi.submitCustomFundChoiceAsync(customFundChoiceDto);
+          }
+        });
+      }
+    };
+    this.byofCancelled = async (event) => {
+      if (event.detail.sender === 'super-byof') {
+        await navigationService.navigateInternally(this.history, SuperSelectionAppRoutes.ChoicePage);
+      }
+    };
+    this.byofEventHandlers = {
+      'byof-loaded': this.byofLoaded.bind(this),
+      'byof-completed': this.byofCompleted.bind(this),
+      'byof-cancelled': this.byofCancelled.bind(this)
+    };
+  }
+  async componentWillLoad() {
+    if (isSome(superSelectionAppService.backendUrl) && isSome(superSelectionAppService.state.jwt)) {
+      this.backendUrl = superSelectionAppService.backendUrl.value;
+      this.accessToken = superSelectionAppService.state.jwt.value;
+      if (superByofComponentStatus === SuperByofComponentStatus.NotLoaded) {
+        this.loadingTimeoutRef = setTimeout(this.byofLoadingTimeoutTriggered.bind(this), LoadWaitingTimeout);
+      }
+      this.subscribeToSuperByofEvents();
+    }
+    else {
+      throw Error(`SuperByofHost pre-requisites not met.`);
+    }
+  }
+  disconnectedCallback() {
+    clearTimeout(this.loadingTimeoutRef);
+    this.unSubscribeFromSuperByofEvents();
+  }
+  render() {
+    return (h(Host, null,
+      h("sss-header-section", null),
+      h("div", { class: "flex justify-center mt-11" },
+        h("sss-custom-fund", null,
+          h("apollo-super-byof", { "backend-url": this.backendUrl, "access-token": this.accessToken })))));
+  }
+  async byofLoadingTimeoutTriggered() {
+    if (superByofComponentStatus !== SuperByofComponentStatus.Loaded) {
+      throw Error(`BYOF component failed to load.`);
+    }
+  }
+  static get is() { return "sss-super-byof-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(SuperByofHost);

package/dist/lib/collection/components/super-campaign/fund-tile-clicked.handler.js

@@ -0,0 +1,49 @@
+import * as O from 'fp-ts/lib/Option';
+import { EventTrackingService } from '../super-selection-app/services/event-tracking.service';
+import miscService from '../super-selection-app/services/misc.service';
+import superSelectionAppService from '../super-selection-app/services/super-selection-app.service';
+const getSuperCampaignState = () => {
+  if (superSelectionAppService.superCampaignState != undefined)
+    return superSelectionAppService.superCampaignState;
+  throw new Error('Super campaign state has not been initialized');
+};
+export const fundTileClicked = async ({ sender, placementId, fundId, fundUsi, fundName, fundType }) => {
+  if (sender === 'super-campaign' || sender === 'featured-funds') {
+    const promotedFundsShown = getSuperCampaignState().PromotedFundIds;
+    const defaultFundUsiSet = O.toUndefined(superSelectionAppService.defaultFundUsi);
+    await Promise.all([
+      fundType === 'promoted-default'
+        ? await EventTrackingService.Instance.TrackPromotedDefaultSuperFundDetailViewedAsync({
+          fundUsi: fundUsi !== null && fundUsi !== void 0 ? fundUsi : '',
+          fundName,
+          promotedFundId: fundId,
+          promotedFundsShown,
+          defaultFundUsiSet,
+          superCampaignEnabled: true,
+          placementId
+        })
+        : await EventTrackingService.Instance.TrackPromotedSuperFundDetailViewedAsync({
+          fundUsi: fundUsi !== null && fundUsi !== void 0 ? fundUsi : undefined,
+          fundName,
+          promotedFundId: fundId,
+          promotedFundsShown,
+          defaultFundUsiSet,
+          superCampaignEnabled: true,
+          placementId
+        }),
+      miscService.trackClickPromotedTileAsync(fundType === 'promoted-default'
+        ? {
+          promotedDefault: {
+            fundId,
+            placementId
+          }
+        }
+        : {
+          promoted: {
+            fundId,
+            placementId
+          }
+        })
+    ]);
+  }
+};

package/dist/lib/collection/components/super-campaign/promoted-fund-joined.handler.js

@@ -0,0 +1,121 @@
+import * as O from 'fp-ts/lib/Option';
+import appInsightsService from '../app-host/services/appinsights.service';
+import customFundChoiceApi from '../super-selection-app/funds/custom-fund/api/custom-fund-choice.api';
+import promotedFundChoiceApi from '../super-selection-app/funds/promoted-fund/api/promoted-fund-choice.api';
+import { slate } from '../super-selection-app/funds/slate-super/api/slate';
+import slateChoiceApi from '../super-selection-app/funds/slate-super/api/slate-choice.api';
+import navigationService from '../super-selection-app/services/navigation.service';
+import superSelectionAppService from '../super-selection-app/services/super-selection-app.service';
+import { Usi } from './super-campaign-types';
+export class PromotedFundJoinedEventHandler {
+  constructor(placementId, history) {
+    this.handle = async (event) => {
+      if (event.detail.sender === 'super-campaign' || event.detail.sender === 'featured-funds') {
+        const fundJoinInfo = event.detail.fundJoinInfo;
+        switch (fundJoinInfo.fundType) {
+          case 'Promoted':
+            this.handlePromotedFundJoined(fundJoinInfo);
+            break;
+          case 'DefinedBenefits':
+            await this.handleDefinedBenefitsJoined(fundJoinInfo);
+            break;
+          case 'PromotedDefault':
+            this.handlePromotedDefaultFundJoined(fundJoinInfo);
+            break;
+          case 'PromotedDefaultWithJoin':
+            this.handlePromotedDefaultFundWithJoinWasJoined(fundJoinInfo);
+            break;
+        }
+      }
+      return Promise.resolve();
+    };
+    this.stringIsNullOrEmtpty = (s) => {
+      return !(typeof s === 'string' && s.trim().length > 0);
+    };
+    this.handlePromotedFundJoined = (data) => {
+      if (this.stringIsNullOrEmtpty(data.memberNumber) || this.stringIsNullOrEmtpty(data.usi)) {
+        appInsightsService.trackErrorTrace('Super Campaign did not return (Promoted) memberNumber and/or usi');
+        return;
+      }
+      const usi = Usi.clean(data.usi);
+      const defaultFundUsiSet = O.toUndefined(superSelectionAppService.defaultFundUsi);
+      navigationService.navigateInternallyToStandardChoice({
+        history: this.history,
+        fundName: data.fundName,
+        promotedFundId: data.fundId,
+        fundDetails: {
+          type: 'promoted',
+          fundName: data.fundName,
+          fundUsi: usi,
+          memberNumber: data.memberNumber,
+          promotedFundId: data.fundId
+        },
+        handleSubmitFn: async (standardChoiceFormSignature) => {
+          if (data.fundId === slate.fundId) {
+            await slateChoiceApi.submitSlateChoiceAsync(Object.assign({ memberNumber: data.memberNumber, memberFirstName: data.memberFirstName, memberFamilyName: data.memberFamilyName, standardChoiceFormSignature,
+              defaultFundUsiSet, placementId: this.placementId }, this.PromotedFundsConfig));
+          }
+          else {
+            await promotedFundChoiceApi.submitChoiceAsync(Object.assign({ fundId: data.fundId, memberNumber: data.memberNumber, memberFirstName: data.memberFirstName, memberFamilyName: data.memberFamilyName, usi,
+              standardChoiceFormSignature,
+              defaultFundUsiSet, placementId: this.placementId }, this.PromotedFundsConfig));
+          }
+        }
+      });
+    };
+    this.handlePromotedDefaultFundJoined = (data) => {
+      if (this.stringIsNullOrEmtpty(data.usi)) {
+        appInsightsService.trackErrorTrace('Super Campaign did not return (PromotedDefault) usi');
+        return;
+      }
+      const usi = Usi.clean(data.usi);
+      navigationService.navigateInternallyToStandardChoice({
+        history: this.history,
+        fundName: data.fundName,
+        promotedFundId: data.fundId,
+        fundDetails: {
+          type: 'promotedDefault',
+          fundName: data.fundName,
+          fundUsi: usi,
+          promotedFundId: data.fundId
+        },
+        handleSubmitFn: (standardChoiceFormSignature) => promotedFundChoiceApi.submitDefaultChoiceAsync(Object.assign({ fundId: data.fundId, usi,
+          standardChoiceFormSignature, defaultFundUsiSet: O.toUndefined(superSelectionAppService.defaultFundUsi), placementId: this.placementId }, this.PromotedFundsConfig))
+      });
+    };
+    this.handlePromotedDefaultFundWithJoinWasJoined = (data) => {
+      if (this.stringIsNullOrEmtpty(data.memberNumber) || this.stringIsNullOrEmtpty(data.usi)) {
+        appInsightsService.trackErrorTrace('Super Campaign did not return (PromotedDefaultWithJoin) memberNumber and/or usi');
+        return;
+      }
+      const usi = Usi.clean(data.usi);
+      navigationService.navigateInternallyToStandardChoice({
+        history: this.history,
+        fundName: data.fundName,
+        promotedFundId: data.fundId,
+        fundDetails: {
+          type: 'promotedDefaultWithJoin',
+          fundName: data.fundName,
+          fundUsi: usi,
+          memberNumber: data.memberNumber,
+          promotedFundId: data.fundId
+        },
+        handleSubmitFn: (standardChoiceFormSignature) => promotedFundChoiceApi.submitDefaultChoiceWithJoinAsync(Object.assign({ fundId: data.fundId, memberNumber: data.memberNumber, memberFirstName: data.memberFirstName, memberFamilyName: data.memberFamilyName, usi,
+          standardChoiceFormSignature, defaultFundUsiSet: O.toUndefined(superSelectionAppService.defaultFundUsi), placementId: this.placementId }, this.PromotedFundsConfig))
+      });
+    };
+    this.handleDefinedBenefitsJoined = async (data) => {
+      if (this.stringIsNullOrEmtpty(data.memberNumber) || this.stringIsNullOrEmtpty(data.usi)) {
+        appInsightsService.trackErrorTrace('Super Campaign did not return (DefinedBenefits) memberNumber and/or usi');
+        return;
+      }
+      await customFundChoiceApi.submitDefinedBenefitsChoiceAsync(Object.assign({ fundUsi: Usi.clean(data.usi), fundId: data.fundId, memberNumber: data.memberNumber, memberElectContributionRatePreTax: data.memberElectContributionRatePreTax, memberElectContributionRatePostTax: data.memberElectContributionRatePostTax }, this.PromotedFundsConfig));
+      superSelectionAppService.markSuperSelectionAsSubmitted();
+    };
+    this.history = history;
+    this.placementId = placementId;
+  }
+  get PromotedFundsConfig() {
+    return superSelectionAppService.promotedFundsConfig;
+  }
+}

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

@@ -0,0 +1,6 @@
+export const Usi = {
+  clean: (usi) => {
+    return usi.replace(/ /g, '');
+  }
+};
+export const LoadWaitingTimeout = 30000;