@flarehr/apollo-super-selection 1.3.54543 → 1.3.54544

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/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);
+}

package/dist/lib/collection/global/main.dev.js

@@ -0,0 +1,29 @@
+import { akitaDevtools } from '@datorama/akita';
+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 { addSlashToUrl, Environment } from '../utils';
+import stencilRouterWorkaround from './stencil-router-workaround';
+export default async function () {
+  if (Environment !== 'dev') {
+    // main.ts does the bootstrapping in this case.
+    return;
+  }
+  stencilRouterWorkaround();
+  akitaDevtools();
+  appParametersService.init(window.location.search);
+  await appConfigurationService.loadConfigurationAsync();
+  appInsights.init();
+  appInsights.getAppInsights().addTelemetryInitializer(() => false);
+  addSlashToUrl();
+  const doAuthFlow = sessionQuery.isUnauthorized ||
+    authenticationService.authorizationCodeIsPresent(window.location.search);
+  if (!doAuthFlow) {
+    return;
+  }
+  hostInteropService.init(window.location.search);
+  authenticationService.initFromRoute(window.location.search);
+}

package/dist/lib/collection/global/main.js

@@ -0,0 +1,11 @@
+import { enableAkitaProdMode } from '@datorama/akita';
+import { Environment } from '../utils';
+import stencilRouterWorkaround from './stencil-router-workaround';
+export default async function () {
+  if (Environment !== 'prod') {
+    // main.dev.ts does the bootstrapping in this case.
+    return;
+  }
+  stencilRouterWorkaround();
+  enableAkitaProdMode();
+}

package/dist/lib/collection/global/stencil-router-workaround.js

@@ -0,0 +1,12 @@
+// Interim workaround for stencil router accessing session storage.
+// See https://github.com/ionic-team/stencil-router/pull/111/files.
+// In incognito mode, window.sessionStorage read access is denied from a third party iframe.
+// Stencil router checks for the presence of session storage, but does not handle a read access exception.
+export default function () {
+  if (window.location == window.parent.location) {
+    // Only apply this workaround when running in an embedded iframe.
+    return;
+  }
+  delete window.sessionStorage;
+  window.sessionStorage = {};
+}

package/dist/lib/collection/index.js

@@ -0,0 +1,2 @@
+export * from './components';
+import '@stencil/router';

package/dist/lib/collection/utils/config.js

@@ -0,0 +1,2 @@
+export const Environment = '$ENVIRONMENT';
+export const AppVersion = '$APP_VERSION';

package/dist/lib/collection/utils/gtm.js

@@ -0,0 +1,5 @@
+export function sendAnalyticsEvent(action, data) {
+  if (window['gtag']) {
+    window['gtag']('event', action, data);
+  }
+}

package/dist/lib/collection/utils/iframe.js

@@ -0,0 +1,33 @@
+function appReady() {
+  postMessage({
+    type: 'appReady'
+  });
+}
+function postMessage(message, origin) {
+  if (origin === undefined)
+    origin = '*';
+  message.sender = 'flare';
+  window.parent.postMessage(message, origin);
+}
+function resize(height, width) {
+  postMessage({
+    type: 'contentResized',
+    height,
+    width
+  });
+}
+function navigation(url) {
+  postMessage({
+    type: 'pageNavigated',
+    url
+  });
+}
+function complete() {
+  postMessage({ type: 'complete' });
+}
+function submitSuccess() {
+  postMessage({
+    type: 'submitSuccess'
+  });
+}
+export default { appReady, resize, navigation, complete, submitSuccess };

package/dist/lib/collection/utils/index.js

@@ -0,0 +1,11 @@
+export * from './config';
+export * from './lazy';
+export function addSlashToUrl() {
+  if (!window.location.pathname.endsWith('/')) {
+    const url = window.location.pathname + '/' + window.location.search + window.location.hash;
+    history.pushState(history.state, '', url);
+  }
+}
+export function assertExhaustive(_value) {
+  return;
+}

package/dist/lib/collection/utils/lazy.js

@@ -0,0 +1,29 @@
+import * as O from 'fp-ts/Option';
+export class Lazy {
+  constructor(factory) {
+    this.factory = factory;
+    this._value = O.none;
+  }
+  get value() {
+    if (O.isSome(this._value)) {
+      return this._value.value;
+    }
+    const lazyValue = this.factory();
+    this._value = O.some(lazyValue);
+    return lazyValue;
+  }
+}
+export class AsyncLazy {
+  constructor(factory) {
+    this.factory = factory;
+    this._value = O.none;
+  }
+  async getValueAsync() {
+    if (O.isSome(this._value)) {
+      return this._value.value;
+    }
+    const lazyValue = await this.factory();
+    this._value = O.some(lazyValue);
+    return lazyValue;
+  }
+}

package/dist/lib/collection/utils/storage.js

@@ -0,0 +1,5 @@
+import * as O from 'fp-ts/lib/Option';
+import { pipe } from 'fp-ts/lib/pipeable';
+export const getFromSessionStorage = (key) => pipe(sessionStorage.getItem(key), O.fromNullable, O.mapNullable(JSON.parse));
+export const saveToSessionStorage = (key, value) => sessionStorage.setItem(key, JSON.stringify(value));
+export const clearFromSessionStorage = (key) => sessionStorage.removeItem(key);