@flarehr/apollo-super-selection 1.3.54543 → 1.3.54544

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: #fdbd00;
+  --fl-color-primary-light: #fef3c7;
+  --fl-color-primary-dark: #d97706;
+  --fl-color-primary-disabled: #ffde7e;
+  --fl-color-primary-hover: #e4aa00;
+  --fl-color-primary-focus: #ca9700;
+  --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-campaign/super-campaign-types.js

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

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

@@ -0,0 +1,361 @@
+import { Component, h, Prop, State } from '@stencil/core';
+import { injectHistory } from '@stencil/router';
+import * as O from 'fp-ts/lib/Option';
+import { isSome } from 'fp-ts/lib/Option';
+import appInsightsService from '../app-host/services/appinsights.service';
+import { SuperCampaignErrorApi } from '../super-selection-app/api/super-campaign-errors-api';
+import { SuperFundDisclaimerViewedDetail } from '../super-selection-app/api/super-selection-events.model';
+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 { EventTrackingService } from '../super-selection-app/services/event-tracking.service';
+import miscService from '../super-selection-app/services/misc.service';
+import navigationService from '../super-selection-app/services/navigation.service';
+import { SuperCampaignComponentStatus } from '../super-selection-app/services/super-selection.store';
+import { SuperSelectionAppRoutes } from '../super-selection-app/services/super-selection-app.routes';
+import superSelectionAppService from '../super-selection-app/services/super-selection-app.service';
+import { LoadWaitingTimeout, Usi } from './super-campaign-types';
+export class SuperCampaignHost {
+  constructor() {
+    this.scriptImported = false;
+    this.getEnvironmentTag = () => {
+      const discriminator = window.location.hostname.toLowerCase().split('.')[0];
+      switch (discriminator) {
+        case 'autodev-partner':
+          return 'autodev';
+        case 'test-partner':
+          return 'test';
+        case 'partner':
+          return 'prod';
+        case 'sandbox-partner':
+          return 'sandbox';
+        default:
+          return 'autodev';
+      }
+    };
+    this.subscribeToSuperCampaignEvents = () => {
+      for (const eventName in this.superCampaignEventHandlers) {
+        document.addEventListener(eventName, this.superCampaignEventHandlers[eventName]);
+      }
+    };
+    this.unSubscribeFromSuperCampaignEvents = () => {
+      for (const eventName in this.superCampaignEventHandlers) {
+        document.removeEventListener(eventName, this.superCampaignEventHandlers[eventName]);
+      }
+    };
+    this.superCampaignLoaded = async (event) => {
+      if (event.detail.sender == 'super-campaign') {
+        superSelectionAppService.superCampaignComponentStatus = SuperCampaignComponentStatus.Loaded;
+        clearTimeout(this.loadingTimeoutRef);
+        await EventTrackingService.Instance.TrackSuperCampaignActivationSucceededAsync({});
+      }
+      return Promise.resolve();
+    };
+    this.superCampaignLoadFailed = async (event) => {
+      if (event.detail.sender == 'super-campaign') {
+        await this.activateFallbackMechanism({
+          type: 'SuperCampaignActivationFailed',
+          reason: event.detail.reason || 'Unknown'
+        });
+      }
+    };
+    this.superCampaignFailed = async (event) => {
+      if (event.detail.sender == 'super-campaign') {
+        await this.activateFallbackMechanism({
+          type: 'SuperCampaignOperationFailed',
+          reason: event.detail.reason || 'Unknown'
+        });
+      }
+    };
+    this.chooseAnotherFundRequested = async (event) => {
+      if (event.detail.sender == 'super-campaign') {
+        await navigationService.navigateInternally(this.history, SuperSelectionAppRoutes.MyOwnFund);
+      }
+    };
+    this.fundPanelShown = async (event) => {
+      if (event.detail.sender == 'super-campaign') {
+        superSelectionAppService.setSuperCampaignPromotedFundsShown(event.detail.shownFunds);
+        await superSelectionAppService.viewSuperFundPanelAsync();
+      }
+    };
+    this.fundTileClicked = async (event) => {
+      var _a, _b;
+      const eventDetails = event.detail;
+      if (eventDetails.sender == 'super-campaign') {
+        const promotedFundsShown = this.SuperCampaignState.PromotedFundIds;
+        const defaultFundUsiSet = O.toUndefined(superSelectionAppService.defaultFundUsi);
+        await Promise.all([
+          eventDetails.fundType == 'promoted-default'
+            ? await EventTrackingService.Instance.TrackPromotedDefaultSuperFundDetailViewedAsync({
+              fundUsi: (_a = eventDetails.fundUsi) !== null && _a !== void 0 ? _a : '',
+              fundName: eventDetails.fundName,
+              promotedFundId: eventDetails.fundId,
+              promotedFundsShown,
+              defaultFundUsiSet,
+              superCampaignEnabled: true
+            })
+            : await EventTrackingService.Instance.TrackPromotedSuperFundDetailViewedAsync({
+              fundUsi: (_b = eventDetails.fundUsi) !== null && _b !== void 0 ? _b : undefined,
+              fundName: eventDetails.fundName,
+              promotedFundId: eventDetails.fundId,
+              promotedFundsShown,
+              defaultFundUsiSet,
+              superCampaignEnabled: true
+            }),
+          miscService.trackClickPromotedTileAsync(eventDetails.fundType == 'promoted-default'
+            ? {
+              promotedDefault: {
+                fundId: eventDetails.fundId
+              }
+            }
+            : {
+              promoted: {
+                fundId: eventDetails.fundId
+              }
+            })
+        ]);
+      }
+    };
+    this.fundPdsViewed = async (event) => {
+      if (event.detail.sender == 'super-campaign') {
+        await EventTrackingService.Instance.TrackSuperFundPdsViewedAsync({
+          fundName: event.detail.fundName,
+          fundUsi: event.detail.fundUsi,
+          pageName: event.detail.pageName,
+          superCampaignEnabled: true
+        });
+      }
+    };
+    this.disclaimerViewed = async (event) => {
+      if (event.detail.sender == 'super-campaign') {
+        await EventTrackingService.Instance.TrackSuperFundDisclaimerViewedAsync(SuperFundDisclaimerViewedDetail.create(true));
+      }
+    };
+    this.disclaimerAccepted = async (event) => {
+      if (event.detail.sender == 'super-campaign') {
+        await EventTrackingService.Instance.TrackSuperFundDisclaimerAcceptedAsync({
+          superCampaignEnabled: true
+        });
+      }
+    };
+    this.promotedFundJoined = async (event) => {
+      if (event.detail.sender == 'super-campaign') {
+        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 }, this.PromotedFundsConfig));
+          }
+          else {
+            await promotedFundChoiceApi.submitChoiceAsync(Object.assign({ fundId: data.fundId, memberNumber: data.memberNumber, memberFirstName: data.memberFirstName, memberFamilyName: data.memberFamilyName, usi,
+              standardChoiceFormSignature,
+              defaultFundUsiSet }, 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) }, 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) }, 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.superCampaignEventHandlers = {
+      'choose-another-fund-requested': this.chooseAnotherFundRequested.bind(this),
+      'fund-panel-shown': this.fundPanelShown.bind(this),
+      'fund-tile-clicked': this.fundTileClicked.bind(this),
+      'fund-pds-viewed': this.fundPdsViewed.bind(this),
+      'disclaimer-viewed': this.disclaimerViewed.bind(this),
+      'disclaimer-accepted': this.disclaimerAccepted.bind(this),
+      'promoted-fund-joined': this.promotedFundJoined.bind(this),
+      'super-campaign-loaded': this.superCampaignLoaded.bind(this),
+      'super-campaign-load-failed': this.superCampaignLoadFailed.bind(this),
+      'super-campaign-failed': this.superCampaignFailed.bind(this)
+    };
+  }
+  async componentWillLoad() {
+    if (superSelectionAppService.state.superCampaignComponentStatus ===
+      SuperCampaignComponentStatus.NotWorking) {
+      navigationService.navigateInternally(this.history, SuperSelectionAppRoutes.MyOwnFund);
+      return;
+    }
+    let superCampaingScriptPath = undefined;
+    try {
+      if (isSome(superSelectionAppService.state.apiBaseUrl) &&
+        isSome(superSelectionAppService.state.jwt)) {
+        this.backendUrl = this.getBaseUrl(superSelectionAppService.state.apiBaseUrl.value);
+        this.accessToken = superSelectionAppService.state.jwt.value;
+        this.unSubscribeFromSuperCampaignEvents();
+        if (superSelectionAppService.state.superCampaignComponentStatus ===
+          SuperCampaignComponentStatus.NotLoaded) {
+          superCampaingScriptPath = this.createApolloSuperCampaignScriptUrl(this.getEnvironmentTag());
+          await import(superCampaingScriptPath);
+          this.loadingTimeoutRef = setTimeout(this.superCampaignLoadingTimeoutTriggered.bind(this), LoadWaitingTimeout);
+        }
+        this.subscribeToSuperCampaignEvents();
+        this.scriptImported = true;
+        superSelectionAppService.superCampaignIsInView = true;
+      }
+      else {
+        throw Error(`SuperCampaignHost pre-requisites not met.`);
+      }
+    }
+    catch (error) {
+      this.activateFallbackMechanism({
+        type: 'SuperCampaignActivationFailed',
+        reason: `Problem in loading SuperCampaing script from:${superCampaingScriptPath} Error: ${error}`
+      });
+    }
+  }
+  disconnectedCallback() {
+    clearTimeout(this.loadingTimeoutRef);
+    this.unSubscribeFromSuperCampaignEvents();
+    superSelectionAppService.superCampaignIsInView = false;
+  }
+  render() {
+    return (h("div", null, this.scriptImported ? (h("apollo-super-campaign", { "backend-url": this.backendUrl, "access-token": this.accessToken })) : null));
+  }
+  async activateFallbackMechanism(error) {
+    if (superSelectionAppService.superCampaignComponentStatus !==
+      SuperCampaignComponentStatus.NotWorking) {
+      superSelectionAppService.superCampaignComponentStatus =
+        SuperCampaignComponentStatus.NotWorking;
+      await SuperCampaignErrorApi.Instance.PostError(error);
+      await navigationService.navigateInternally(this.history, SuperSelectionAppRoutes.MyOwnFund);
+    }
+  }
+  async superCampaignLoadingTimeoutTriggered() {
+    if (superSelectionAppService.superCampaignComponentStatus !== SuperCampaignComponentStatus.Loaded) {
+      this.activateFallbackMechanism({
+        type: 'SuperCampaignActivationFailed',
+        reason: `Activation timeout was triggered after:${LoadWaitingTimeout / 1000} seconds`
+      });
+    }
+  }
+  createApolloSuperCampaignScriptUrl(envTag) {
+    return `https://npm-cdn.flarehr.com/@flarehr/apollo-super-campaign@${envTag}/dist/apollo-super-campaign.js`;
+  }
+  getBaseUrl(url) {
+    const parsedUrl = new URL(url);
+    return `${parsedUrl.protocol}//${parsedUrl.hostname}${parsedUrl.port.length > 0 ? `:${parsedUrl.port}` : ''}`;
+  }
+  get SuperCampaignState() {
+    if (superSelectionAppService.superCampaignState != undefined)
+      return superSelectionAppService.superCampaignState;
+    throw new Error('Super campaign state has not been initialized');
+  }
+  get PromotedFundsConfig() {
+    return superSelectionAppService.promotedFundsConfig;
+  }
+  static get is() { return "sss-super-campaign-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 {
+    "scriptImported": {},
+    "backendUrl": {},
+    "accessToken": {}
+  }; }
+}
+injectHistory(SuperCampaignHost);

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

@@ -0,0 +1,14 @@
+import wretch from 'wretch';
+import superSelectionAppService from '../services/super-selection-app.service';
+export function buildBackendApiClient() {
+  const jwt = superSelectionAppService.jwt;
+  const profileId = superSelectionAppService.profileId;
+  const accountId = superSelectionAppService.accountIdOrDefault;
+  const partnerId = superSelectionAppService.partnerIdOrDefault;
+  return wretch(superSelectionAppService.apiBaseUrl).headers({
+    Authorization: `Bearer ${jwt}`,
+    'X-PROFILE-ID': profileId,
+    'X-PARTNER-ID': partnerId,
+    'X-ACCOUNT-ID': accountId
+  });
+}

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

@@ -0,0 +1,9 @@
+import { buildBackendApiClient } from '../api/api-client';
+export class EventTrackingApi {
+  static get Instance() {
+    return this.instance || (this.instance = new this());
+  }
+  async PostAnalyticsEventAsync(event) {
+    return buildBackendApiClient().url('analytics-events').post(event).res();
+  }
+}

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

@@ -0,0 +1,9 @@
+import { buildBackendApiClient } from './api-client';
+export class SuperCampaignErrorApi {
+  static get Instance() {
+    return this.instance || (this.instance = new this());
+  }
+  async PostError(error) {
+    buildBackendApiClient().url('super-campaign/errors').post(error);
+  }
+}

package/dist/lib/collection/components/super-selection-app/api/super-campaign-errors.api.dtos.js

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

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

@@ -0,0 +1,16 @@
+import { isSome } from 'fp-ts/lib/Option';
+import superSelectionService from '../services/super-selection-app.service';
+export const SuperFundDisclaimerViewedDetail = {
+  create: (superCampaignEnabled) => {
+    let isDefinedBenefitsEligibleString = 'Not set';
+    if (isSome(superSelectionService.isDefinedBenefitsEligible)) {
+      isDefinedBenefitsEligibleString = superSelectionService.isDefinedBenefitsEligible.value
+        ? 'True'
+        : 'False';
+    }
+    return {
+      isDefinedBenefitsEligible: isDefinedBenefitsEligibleString,
+      superCampaignEnabled: superCampaignEnabled
+    };
+  }
+};