@hmcts/ccd-case-ui-toolkit 7.0.20 → 7.0.21-CVE-fix

package/esm2022/lib/shared/services/activity/activity.polling.service.mjs

@@ -0,0 +1,122 @@
+import { Injectable, NgZone } from '@angular/core';
+import { EMPTY, Subject } from 'rxjs';
+import { AbstractAppConfig } from '../../../app.config';
+import { ActivityService } from './activity.service';
+import { polling } from 'rx-polling-hmcts';
+import * as i0 from "@angular/core";
+import * as i1 from "./activity.service";
+import * as i2 from "../../../app.config";
+// @dynamic
+export class ActivityPollingService {
+    activityService;
+    ngZone;
+    config;
+    pendingRequests = new Map();
+    currentTimeoutHandle;
+    pollActivitiesSubscription;
+    pollConfig;
+    batchCollectionDelayMs;
+    maxRequestsPerBatch;
+    constructor(activityService, ngZone, config) {
+        this.activityService = activityService;
+        this.ngZone = ngZone;
+        this.config = config;
+        this.pollConfig = {
+            interval: config.getActivityNexPollRequestMs(),
+            attempts: config.getActivityRetry(),
+            backgroundPolling: true
+        };
+        this.batchCollectionDelayMs = config.getActivityBatchCollectionDelayMs();
+        this.maxRequestsPerBatch = config.getActivityMaxRequestPerBatch();
+    }
+    get isEnabled() {
+        return this.activityService.isEnabled;
+    }
+    subscribeToActivity(caseId, done) {
+        if (!this.isEnabled) {
+            return new Subject();
+        }
+        let subject = this.pendingRequests.get(caseId);
+        if (subject) {
+            subject.subscribe(done);
+        }
+        else {
+            subject = new Subject();
+            subject.subscribe(done);
+            this.pendingRequests.set(caseId, subject);
+        }
+        if (this.pendingRequests.size === 1) {
+            this.ngZone.runOutsideAngular(() => {
+                this.currentTimeoutHandle = setTimeout(() => this.ngZone.run(() => {
+                    // console.log('timeout: flushing requests')
+                    this.flushRequests();
+                }), this.batchCollectionDelayMs);
+            });
+        }
+        if (this.pendingRequests.size >= this.maxRequestsPerBatch) {
+            // console.log('max pending hit: flushing requests');
+            this.flushRequests();
+        }
+        return subject;
+    }
+    stopPolling() {
+        if (this.pollActivitiesSubscription) {
+            this.pollActivitiesSubscription.unsubscribe();
+        }
+    }
+    flushRequests() {
+        if (this.currentTimeoutHandle) {
+            clearTimeout(this.currentTimeoutHandle);
+            this.currentTimeoutHandle = undefined;
+        }
+        const requests = new Map(this.pendingRequests);
+        this.pendingRequests.clear();
+        this.performBatchRequest(requests);
+    }
+    pollActivities(...caseIds) {
+        if (!this.isEnabled) {
+            return EMPTY;
+        }
+        return polling(this.activityService.getActivities(...caseIds), this.pollConfig);
+    }
+    postViewActivity(caseId) {
+        return this.postActivity(caseId, ActivityService.ACTIVITY_VIEW);
+    }
+    postEditActivity(caseId) {
+        return this.postActivity(caseId, ActivityService.ACTIVITY_EDIT);
+    }
+    performBatchRequest(requests) {
+        const caseIds = Array.from(requests.keys()).join();
+        // console.log('issuing batch request for cases: ' + caseIds);
+        this.ngZone.runOutsideAngular(() => {
+            // run polling outside angular zone so it does not trigger change detection
+            this.pollActivitiesSubscription = this.pollActivities(caseIds).subscribe(
+            // process activity inside zone so it triggers change detection for activity.component.ts
+            (activities) => this.ngZone.run(() => {
+                activities.forEach((activity) => {
+                    // console.log('pushing activity: ' + activity.caseId);
+                    requests.get(activity.caseId).next(activity);
+                });
+            }, (err) => {
+                console.log(`error: ${err}`);
+                Array.from(requests.values()).forEach((subject) => subject.error(err));
+            }));
+        });
+    }
+    postActivity(caseId, activityType) {
+        if (!this.isEnabled) {
+            return EMPTY;
+        }
+        const pollingConfig = {
+            ...this.pollConfig,
+            interval: 5000 // inline with CCD Backend
+        };
+        return polling(this.activityService.postActivity(caseId, activityType), pollingConfig);
+    }
+    static ɵfac = function ActivityPollingService_Factory(t) { return new (t || ActivityPollingService)(i0.ɵɵinject(i1.ActivityService), i0.ɵɵinject(i0.NgZone), i0.ɵɵinject(i2.AbstractAppConfig)); };
+    static ɵprov = /*@__PURE__*/ i0.ɵɵdefineInjectable({ token: ActivityPollingService, factory: ActivityPollingService.ɵfac });
+}
+(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(ActivityPollingService, [{
+        type: Injectable
+    }], function () { return [{ type: i1.ActivityService }, { type: i0.NgZone }, { type: i2.AbstractAppConfig }]; }, null); })();
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"activity.polling.service.js","sourceRoot":"","sources":["../../../../../../../projects/ccd-case-ui-toolkit/src/lib/shared/services/activity/activity.polling.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable, NgZone } from '@angular/core';\nimport { EMPTY, Observable, Subject, Subscription } from 'rxjs';\nimport { AbstractAppConfig } from '../../../app.config';\nimport { Activity } from '../../domain/activity/activity.model';\nimport { ActivityService } from './activity.service';\nimport { polling, IOptions } from 'rx-polling-hmcts';\n\n// @dynamic\n@Injectable()\nexport class ActivityPollingService {\n  private readonly pendingRequests = new Map<string, Subject<Activity>>();\n  private currentTimeoutHandle: any;\n  private pollActivitiesSubscription: Subscription;\n  private readonly pollConfig: IOptions;\n  private readonly batchCollectionDelayMs: number;\n  private readonly maxRequestsPerBatch: number;\n\n  constructor(private readonly activityService: ActivityService, private readonly ngZone: NgZone, private readonly config: AbstractAppConfig) {\n    this.pollConfig = {\n      interval: config.getActivityNexPollRequestMs(),\n      attempts: config.getActivityRetry(),\n      backgroundPolling: true\n    };\n    this.batchCollectionDelayMs = config.getActivityBatchCollectionDelayMs();\n    this.maxRequestsPerBatch = config.getActivityMaxRequestPerBatch();\n  }\n\n  public get isEnabled(): boolean {\n    return this.activityService.isEnabled;\n  }\n\n  public subscribeToActivity(caseId: string, done: (activity: Activity) => void): Subject<Activity> {\n    if (!this.isEnabled) {\n      return new Subject<Activity>();\n    }\n\n    let subject = this.pendingRequests.get(caseId);\n    if (subject) {\n      subject.subscribe(done);\n    } else {\n      subject = new Subject<Activity>();\n      subject.subscribe(done);\n      this.pendingRequests.set(caseId, subject);\n    }\n    if (this.pendingRequests.size === 1) {\n      this.ngZone.runOutsideAngular(() => {\n        this.currentTimeoutHandle = setTimeout(\n          () => this.ngZone.run(() => {\n            // console.log('timeout: flushing requests')\n            this.flushRequests();\n          }),\n          this.batchCollectionDelayMs);\n      });\n    }\n\n    if (this.pendingRequests.size >= this.maxRequestsPerBatch) {\n      // console.log('max pending hit: flushing requests');\n      this.flushRequests();\n    }\n    return subject;\n  }\n\n  public stopPolling() {\n    if (this.pollActivitiesSubscription) {\n      this.pollActivitiesSubscription.unsubscribe();\n    }\n  }\n\n  public flushRequests(): void {\n    if (this.currentTimeoutHandle) {\n      clearTimeout(this.currentTimeoutHandle);\n      this.currentTimeoutHandle = undefined;\n    }\n\n    const requests = new Map(this.pendingRequests);\n    this.pendingRequests.clear();\n    this.performBatchRequest(requests);\n  }\n\n  public pollActivities(...caseIds: string[]): Observable<Activity[]> {\n    if (!this.isEnabled) {\n      return EMPTY;\n    }\n\n    return polling(this.activityService.getActivities(...caseIds), this.pollConfig);\n  }\n\n  public postViewActivity(caseId: string): Observable<Activity[]> {\n    return this.postActivity(caseId, ActivityService.ACTIVITY_VIEW);\n  }\n\n  public postEditActivity(caseId: string): Observable<Activity[]> {\n    return this.postActivity(caseId, ActivityService.ACTIVITY_EDIT);\n  }\n\n  protected performBatchRequest(requests: Map<string, Subject<Activity>>): void {\n    const caseIds = Array.from(requests.keys()).join();\n    // console.log('issuing batch request for cases: ' + caseIds);\n    this.ngZone.runOutsideAngular( () => {\n      // run polling outside angular zone so it does not trigger change detection\n      this.pollActivitiesSubscription = this.pollActivities(caseIds).subscribe(\n              // process activity inside zone so it triggers change detection for activity.component.ts\n        (activities: Activity[]) => this.ngZone.run( () => {\n            activities.forEach((activity) => {\n              // console.log('pushing activity: ' + activity.caseId);\n              requests.get(activity.caseId).next(activity);\n            });\n          },\n          (err) => {\n            console.log(`error: ${err}`);\n            Array.from(requests.values()).forEach((subject) => subject.error(err));\n          }\n        )\n      );\n    });\n  }\n\n  private postActivity(caseId: string, activityType: string): Observable<Activity[]> {\n    if (!this.isEnabled) {\n      return EMPTY;\n    }\n\n    const pollingConfig = {\n      ...this.pollConfig,\n      interval: 5000 // inline with CCD Backend\n    };\n\n    return polling(this.activityService.postActivity(caseId, activityType), pollingConfig);\n  }\n}\n"]}

package/esm2022/lib/shared/services/activity/activity.service.mjs

@@ -0,0 +1,85 @@
+import { HttpHeaders } from '@angular/common/http';
+import { Injectable } from '@angular/core';
+import { map } from 'rxjs/operators';
+import { AbstractAppConfig } from '../../../app.config';
+import { HttpErrorService, HttpService } from '../http';
+import { SessionStorageService } from '../session';
+import * as i0 from "@angular/core";
+import * as i1 from "../http";
+import * as i2 from "../../../app.config";
+import * as i3 from "../session";
+// @dynamic
+export class ActivityService {
+    http;
+    appConfig;
+    sessionStorageService;
+    static get ACTIVITY_VIEW() { return 'view'; }
+    static get ACTIVITY_EDIT() { return 'edit'; }
+    constructor(http, appConfig, sessionStorageService) {
+        this.http = http;
+        this.appConfig = appConfig;
+        this.sessionStorageService = sessionStorageService;
+    }
+    get isEnabled() {
+        return this.activityUrl() && this.userAuthorised;
+    }
+    static DUMMY_CASE_REFERENCE = '0';
+    userAuthorised = undefined;
+    static handleHttpError(response) {
+        const error = HttpErrorService.convertToHttpError(response);
+        if (response?.status !== error.status) {
+            error.status = response.status;
+        }
+        return error;
+    }
+    getOptions() {
+        const userDetails = JSON.parse(this.sessionStorageService.getItem('userDetails'));
+        const headers = new HttpHeaders().set('Content-Type', 'application/json').set('Authorization', userDetails.token);
+        return {
+            headers,
+            withCredentials: true,
+            observe: 'body',
+        };
+    }
+    getActivities(...caseId) {
+        try {
+            const options = this.getOptions();
+            const url = `${this.activityUrl()}/cases/${caseId.join(',')}/activity`;
+            return this.http
+                .get(url, options, false, ActivityService.handleHttpError)
+                .pipe(map(response => response));
+        }
+        catch (error) {
+            console.log(`user may not be authenticated.${error}`);
+        }
+    }
+    postActivity(caseId, activity) {
+        try {
+            const options = this.getOptions();
+            const url = `${this.activityUrl()}/cases/${caseId}/activity`;
+            const body = { activity };
+            return this.http
+                .post(url, body, options, false)
+                .pipe(map(response => response));
+        }
+        catch (error) {
+            console.log(`user may not be authenticated.${error}`);
+        }
+    }
+    verifyUserIsAuthorized() {
+        if (this.sessionStorageService.getItem('userDetails') && this.activityUrl() && this.userAuthorised === undefined) {
+            this.getActivities(ActivityService.DUMMY_CASE_REFERENCE).subscribe(() => this.userAuthorised = true, error => {
+                this.userAuthorised = [401, 403].indexOf(error.status) <= -1;
+            });
+        }
+    }
+    activityUrl() {
+        return this.appConfig.getActivityUrl();
+    }
+    static ɵfac = function ActivityService_Factory(t) { return new (t || ActivityService)(i0.ɵɵinject(i1.HttpService), i0.ɵɵinject(i2.AbstractAppConfig), i0.ɵɵinject(i3.SessionStorageService)); };
+    static ɵprov = /*@__PURE__*/ i0.ɵɵdefineInjectable({ token: ActivityService, factory: ActivityService.ɵfac });
+}
+(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(ActivityService, [{
+        type: Injectable
+    }], function () { return [{ type: i1.HttpService }, { type: i2.AbstractAppConfig }, { type: i3.SessionStorageService }]; }, null); })();
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/shared/services/addresses/addresses.service.mjs

@@ -0,0 +1,65 @@
+import { Injectable } from '@angular/core';
+import { BehaviorSubject } from 'rxjs';
+import { map } from 'rxjs/operators';
+import { AbstractAppConfig } from '../../../app.config';
+import { HttpService } from '../http';
+import { AddressParser } from './address-parser';
+import { AddressType } from './address-type.enum';
+import * as i0 from "@angular/core";
+import * as i1 from "../http";
+import * as i2 from "../../../app.config";
+export class AddressesService {
+    http;
+    appConfig;
+    mandatoryError = new BehaviorSubject(false);
+    constructor(http, appConfig) {
+        this.http = http;
+        this.appConfig = appConfig;
+    }
+    getAddressesForPostcode(postcode) {
+        return this.http
+            .get(this.appConfig.getPostcodeLookupUrl()
+            .replace('${postcode}', postcode), undefined, false)
+            .pipe(map(res => res.results))
+            .pipe(map(output => output.map(addresses => this.format(new AddressParser().parse(addresses[AddressType.DPA])))));
+    }
+    getMandatoryError() {
+        return this.mandatoryError.asObservable();
+    }
+    setMandatoryError(value) {
+        this.mandatoryError.next(value);
+    }
+    format(addressModel) {
+        return this.formatAddressLines(this.shiftAddressLinesUp(addressModel));
+    }
+    formatAddressLines(addressModel) {
+        ['AddressLine1', 'AddressLine2', 'AddressLine3', 'PostTown'].forEach(value => {
+            addressModel[value] = this.toCapitalCase(addressModel[value]);
+        });
+        return addressModel;
+    }
+    shiftAddressLinesUp(addressModel) {
+        if (addressModel.AddressLine2 === '') {
+            addressModel.AddressLine2 = addressModel.AddressLine3;
+            addressModel.AddressLine3 = '';
+        }
+        if (addressModel.AddressLine1 === '') {
+            addressModel.AddressLine1 = addressModel.AddressLine2;
+            addressModel.AddressLine2 = '';
+        }
+        return addressModel;
+    }
+    toCapitalCase(sentence) {
+        sentence = sentence.toLowerCase();
+        sentence.split(' ').forEach((value, index) => {
+            sentence = sentence.replace(value, value.charAt(0).toUpperCase() + value.substr(1));
+        });
+        return sentence;
+    }
+    static ɵfac = function AddressesService_Factory(t) { return new (t || AddressesService)(i0.ɵɵinject(i1.HttpService), i0.ɵɵinject(i2.AbstractAppConfig)); };
+    static ɵprov = /*@__PURE__*/ i0.ɵɵdefineInjectable({ token: AddressesService, factory: AddressesService.ɵfac });
+}
+(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(AddressesService, [{
+        type: Injectable
+    }], function () { return [{ type: i1.HttpService }, { type: i2.AbstractAppConfig }]; }, null); })();
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/shared/services/alert/alert.service.mjs

@@ -0,0 +1,157 @@
+import { Injectable } from '@angular/core';
+import { NavigationStart, Router } from '@angular/router';
+import { RpxTranslationService } from 'rpx-xui-translation';
+import { Observable } from 'rxjs';
+import { publish, refCount } from 'rxjs/operators';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/router";
+import * as i2 from "rpx-xui-translation";
+export class AlertService {
+    router;
+    rpxTranslationService;
+    // the preserved messages
+    preservedError = '';
+    preservedWarning = '';
+    preservedSuccess = '';
+    // TODO: Remove
+    message;
+    level;
+    successes;
+    errors;
+    warnings;
+    // TODO: Remove
+    alerts;
+    successObserver;
+    errorObserver;
+    warningObserver;
+    // TODO: Remove
+    alertObserver;
+    preserveAlerts = false;
+    constructor(router, rpxTranslationService) {
+        this.router = router;
+        this.rpxTranslationService = rpxTranslationService;
+        this.successes = Observable
+            .create(observer => this.successObserver = observer).pipe(publish(), refCount());
+        this.successes.subscribe();
+        this.errors = Observable
+            .create(observer => this.errorObserver = observer).pipe(publish(), refCount());
+        this.errors.subscribe();
+        this.warnings = Observable
+            .create(observer => this.warningObserver = observer).pipe(publish(), refCount());
+        this.warnings.subscribe();
+        // TODO: Remove
+        this.alerts = Observable
+            .create(observer => this.alertObserver = observer).pipe(publish(), refCount());
+        this.alerts.subscribe();
+        this.router
+            .events
+            .subscribe(event => {
+            if (event instanceof NavigationStart) {
+                // if there is no longer a preserve alerts setting for the page then clear all observers and preserved messages
+                if (!this.preserveAlerts) {
+                    this.clear();
+                }
+                // if not, then set the preserving of alerts to false so rendering to a new page
+                this.preserveAlerts = false;
+            }
+        });
+    }
+    clear() {
+        this.successObserver.next(null);
+        this.errorObserver.next(null);
+        this.warningObserver.next(null);
+        this.preservedError = '';
+        this.preservedWarning = '';
+        this.preservedSuccess = '';
+        // EUI-3381.
+        this.alertObserver.next(null);
+        this.message = '';
+    }
+    error({ phrase, replacements }) {
+        const message = this.getTranslationWithReplacements(phrase, replacements);
+        this.preservedError = this.preserveMessages(message);
+        const alert = { level: 'error', message };
+        this.errorObserver.next(alert);
+        // EUI-3381.
+        this.push(alert);
+    }
+    warning({ phrase, replacements }) {
+        const message = this.getTranslationWithReplacements(phrase, replacements);
+        this.preservedWarning = this.preserveMessages(message);
+        const alert = { level: 'warning', message };
+        this.warningObserver.next(alert);
+        // EUI-3381.
+        this.push(alert);
+    }
+    success({ preserve, phrase, replacements }) {
+        const message = this.getTranslationWithReplacements(phrase, replacements);
+        this.preserveAlerts = preserve || this.preserveAlerts;
+        const alert = { level: 'success', message };
+        this.preservedSuccess = this.preserveMessages(message);
+        this.successObserver.next(alert);
+        // EUI-3381.
+        this.push(alert);
+    }
+    getTranslationWithReplacements(phrase, replacements) {
+        let message;
+        if (replacements) {
+            this.rpxTranslationService.getTranslationWithReplacements$(phrase, replacements).subscribe(translation => {
+                message = translation;
+            });
+        }
+        else {
+            this.rpxTranslationService.getTranslation$(phrase).subscribe(translation => {
+                message = translation;
+            });
+        }
+        return message;
+    }
+    setPreserveAlerts(preserve, urlInfo) {
+        // if there is no url setting then just preserve the messages
+        if (!urlInfo) {
+            this.preserveAlerts = preserve;
+        }
+        else {
+            // check if the url includes the sting given
+            this.preserveAlerts = this.currentUrlIncludesInfo(preserve, urlInfo);
+        }
+    }
+    currentUrlIncludesInfo(preserve, urlInfo) {
+        // loop through the list of strings and check the router includes all of them
+        for (const urlSnip of urlInfo) {
+            if (!this.router.url.includes(urlSnip)) {
+                // return the opposite boolean value if the router does not include one of the strings
+                return !preserve;
+            }
+        }
+        // return the boolean value if all strings are in the url
+        return preserve;
+    }
+    isPreserveAlerts() {
+        return this.preserveAlerts;
+    }
+    preserveMessages(message) {
+        // preserve the messages if set to preserve them
+        if (this.isPreserveAlerts()) {
+            return message;
+        }
+        else {
+            return '';
+        }
+    }
+    // TODO: Remove
+    push(msgObject) {
+        this.message = msgObject.message;
+        this.level = msgObject.level;
+        this.alertObserver.next({
+            level: this.level,
+            message: this.message
+        });
+    }
+    static ɵfac = function AlertService_Factory(t) { return new (t || AlertService)(i0.ɵɵinject(i1.Router), i0.ɵɵinject(i2.RpxTranslationService)); };
+    static ɵprov = /*@__PURE__*/ i0.ɵɵdefineInjectable({ token: AlertService, factory: AlertService.ɵfac });
+}
+(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(AlertService, [{
+        type: Injectable
+    }], function () { return [{ type: i1.Router }, { type: i2.RpxTranslationService }]; }, null); })();
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"alert.service.js","sourceRoot":"","sources":["../../../../../../../projects/ccd-case-ui-toolkit/src/lib/shared/services/alert/alert.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable } from '@angular/core';\nimport { NavigationStart, Router } from '@angular/router';\nimport { RpxTranslationService } from 'rpx-xui-translation';\nimport { ConnectableObservable, Observable, Observer } from 'rxjs';\nimport { publish, refCount } from 'rxjs/operators';\nimport { AlertLevel } from '../../domain/alert/alert-level.model';\nimport { AlertStatusParams } from '../../domain/alert/alert-status-params.model';\nimport { Alert } from '../../domain/alert/alert.model';\n\n@Injectable()\nexport class AlertService {\n  // the preserved messages\n  public preservedError = '';\n  public preservedWarning = '';\n  public preservedSuccess = '';\n\n  // TODO: Remove\n  public message: string;\n  public level: AlertLevel;\n\n  public successes: ConnectableObservable<Alert>;\n  public errors: ConnectableObservable<Alert>;\n  public warnings: ConnectableObservable<Alert>;\n  // TODO: Remove\n  public alerts: ConnectableObservable<Alert>;\n\n  private successObserver: Observer<Alert>;\n  private errorObserver: Observer<Alert>;\n  private warningObserver: Observer<Alert>;\n  // TODO: Remove\n  private alertObserver: Observer<Alert>;\n\n  private preserveAlerts = false;\n\n  constructor(private readonly router: Router, private readonly rpxTranslationService: RpxTranslationService) {\n\n    this.successes = Observable\n      .create(observer => this.successObserver = observer).pipe(\n        publish(),\n        refCount()\n      );\n    this.successes.subscribe();\n\n    this.errors = Observable\n      .create(observer => this.errorObserver = observer).pipe(\n        publish(),\n        refCount()\n      );\n    this.errors.subscribe();\n\n    this.warnings = Observable\n      .create(observer => this.warningObserver = observer).pipe(\n        publish(),\n        refCount()\n      );\n    this.warnings.subscribe();\n\n    // TODO: Remove\n    this.alerts = Observable\n      .create(observer => this.alertObserver = observer).pipe(\n        publish(),\n        refCount()\n      );\n    this.alerts.subscribe();\n\n    this.router\n      .events\n      .subscribe(event => {\n        if (event instanceof NavigationStart) {\n          // if there is no longer a preserve alerts setting for the page then clear all observers and preserved messages\n          if (!this.preserveAlerts) {\n            this.clear();\n          }\n          // if not, then set the preserving of alerts to false so rendering to a new page\n          this.preserveAlerts = false;\n        }\n      });\n  }\n\n  public clear(): void {\n    this.successObserver.next(null);\n    this.errorObserver.next(null);\n    this.warningObserver.next(null);\n    this.preservedError = '';\n    this.preservedWarning = '';\n    this.preservedSuccess = '';\n\n    // EUI-3381.\n    this.alertObserver.next(null);\n    this.message = '';\n  }\n\n  public error({ phrase, replacements}: Omit<AlertStatusParams, 'preserve'>): void {\n    const message = this.getTranslationWithReplacements(phrase, replacements);\n\n    this.preservedError = this.preserveMessages(message);\n    const alert: Alert = { level: 'error', message };\n    this.errorObserver.next(alert);\n\n    // EUI-3381.\n    this.push(alert);\n  }\n\n  public warning({ phrase, replacements}: Omit<AlertStatusParams, 'preserve'>): void {\n    const message = this.getTranslationWithReplacements(phrase, replacements);\n\n    this.preservedWarning = this.preserveMessages(message);\n    const alert: Alert = { level: 'warning', message };\n    this.warningObserver.next(alert);\n\n    // EUI-3381.\n    this.push(alert);\n  }\n\n  public success({ preserve, phrase, replacements}: AlertStatusParams): void {\n    const message = this.getTranslationWithReplacements(phrase, replacements);\n\n    this.preserveAlerts = preserve || this.preserveAlerts;\n    const alert: Alert = { level: 'success', message };\n    this.preservedSuccess = this.preserveMessages(message);\n    this.successObserver.next(alert);\n\n    // EUI-3381.\n    this.push(alert);\n  }\n\n  private getTranslationWithReplacements(phrase: string, replacements: AlertStatusParams['replacements']): string {\n    let message: string;\n    if (replacements) {\n      this.rpxTranslationService.getTranslationWithReplacements$(phrase, replacements).subscribe(translation => {\n        message = translation;\n      });\n    } else {\n      this.rpxTranslationService.getTranslation$(phrase).subscribe(translation => {\n        message = translation;\n      });\n    }\n\n    return message;\n  }\n\n  public setPreserveAlerts(preserve: boolean, urlInfo?: string[]) {\n    // if there is no url setting then just preserve the messages\n    if (!urlInfo) {\n      this.preserveAlerts = preserve;\n    } else {\n      // check if the url includes the sting given\n      this.preserveAlerts = this.currentUrlIncludesInfo(preserve, urlInfo);\n    }\n  }\n\n  public currentUrlIncludesInfo(preserve: boolean, urlInfo: string[]): boolean {\n    // loop through the list of strings and check the router includes all of them\n    for (const urlSnip of urlInfo) {\n      if (!this.router.url.includes(urlSnip)) {\n        // return the opposite boolean value if the router does not include one of the strings\n        return !preserve;\n      }\n    }\n    // return the boolean value if all strings are in the url\n    return preserve;\n  }\n\n  public isPreserveAlerts(): boolean {\n    return this.preserveAlerts;\n  }\n\n  public preserveMessages(message: string): string {\n    // preserve the messages if set to preserve them\n    if (this.isPreserveAlerts()) {\n      return message;\n    } else {\n      return '';\n    }\n  }\n\n  // TODO: Remove\n  public push(msgObject) {\n    this.message = msgObject.message;\n    this.level = msgObject.level;\n\n    this.alertObserver.next({\n      level: this.level,\n      message: this.message\n    });\n  }\n}\n"]}

package/esm2022/lib/shared/services/auth/auth.service.mjs

@@ -0,0 +1,35 @@
+import { DOCUMENT } from '@angular/common';
+import { Inject, Injectable } from '@angular/core';
+import { AbstractAppConfig } from '../../../app.config';
+import * as i0 from "@angular/core";
+import * as i1 from "../../../app.config";
+/**
+ * `Oauth2Service` and `AuthService` cannot be merged as it creates a cyclic dependency on `AuthService` through `HttpErrorService`.
+ */
+export class AuthService {
+    appConfig;
+    document;
+    static PATH_OAUTH2_REDIRECT = '/oauth2redirect';
+    constructor(appConfig, document) {
+        this.appConfig = appConfig;
+        this.document = document;
+    }
+    signIn() {
+        const loginUrl = this.appConfig.getLoginUrl();
+        const clientId = this.appConfig.getOAuth2ClientId();
+        const redirectUri = encodeURIComponent(this.redirectUri());
+        this.document.location.href = `${loginUrl}?response_type=code&client_id=${clientId}&redirect_uri=${redirectUri}`;
+    }
+    redirectUri() {
+        return this.document.location.origin + AuthService.PATH_OAUTH2_REDIRECT;
+    }
+    static ɵfac = function AuthService_Factory(t) { return new (t || AuthService)(i0.ɵɵinject(i1.AbstractAppConfig), i0.ɵɵinject(DOCUMENT)); };
+    static ɵprov = /*@__PURE__*/ i0.ɵɵdefineInjectable({ token: AuthService, factory: AuthService.ɵfac });
+}
+(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(AuthService, [{
+        type: Injectable
+    }], function () { return [{ type: i1.AbstractAppConfig }, { type: undefined, decorators: [{
+                type: Inject,
+                args: [DOCUMENT]
+            }] }]; }, null); })();
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/shared/services/banners/banners.service.mjs

@@ -0,0 +1,35 @@
+import { HttpHeaders, HttpParams } from '@angular/common/http';
+import { Injectable } from '@angular/core';
+import { map } from 'rxjs/operators';
+import { AbstractAppConfig } from '../../../app.config';
+import { HttpService } from '../http/http.service';
+import * as i0 from "@angular/core";
+import * as i1 from "../http/http.service";
+import * as i2 from "../../../app.config";
+export class BannersService {
+    httpService;
+    appConfig;
+    static V2_MEDIATYPE_BANNERS = 'application/vnd.uk.gov.hmcts.ccd-data-store-api.ui-banners.v2+json;charset=UTF-8';
+    constructor(httpService, appConfig) {
+        this.httpService = httpService;
+        this.appConfig = appConfig;
+    }
+    getBanners(jurisdictionReferences) {
+        const url = this.appConfig.getBannersUrl();
+        const headers = new HttpHeaders()
+            .set('experimental', 'true')
+            .set('Accept', BannersService.V2_MEDIATYPE_BANNERS)
+            .set('Content-Type', 'application/json');
+        let params = new HttpParams();
+        jurisdictionReferences.forEach(reference => params = params.append('ids', reference));
+        return this.httpService
+            .get(url, { params, headers, observe: 'body' })
+            .pipe(map(body => body.banners));
+    }
+    static ɵfac = function BannersService_Factory(t) { return new (t || BannersService)(i0.ɵɵinject(i1.HttpService), i0.ɵɵinject(i2.AbstractAppConfig)); };
+    static ɵprov = /*@__PURE__*/ i0.ɵɵdefineInjectable({ token: BannersService, factory: BannersService.ɵfac });
+}
+(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(BannersService, [{
+        type: Injectable
+    }], function () { return [{ type: i1.HttpService }, { type: i2.AbstractAppConfig }]; }, null); })();
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYmFubmVycy5zZXJ2aWNlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vLi4vcHJvamVjdHMvY2NkLWNhc2UtdWktdG9vbGtpdC9zcmMvbGliL3NoYXJlZC9zZXJ2aWNlcy9iYW5uZXJzL2Jhbm5lcnMuc2VydmljZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsV0FBVyxFQUFFLFVBQVUsRUFBRSxNQUFNLHNCQUFzQixDQUFDO0FBQy9ELE9BQU8sRUFBRSxVQUFVLEVBQUUsTUFBTSxlQUFlLENBQUM7QUFFM0MsT0FBTyxFQUFFLEdBQUcsRUFBRSxNQUFNLGdCQUFnQixDQUFDO0FBQ3JDLE9BQU8sRUFBRSxpQkFBaUIsRUFBRSxNQUFNLHFCQUFxQixDQUFDO0FBRXhELE9BQU8sRUFBRSxXQUFXLEVBQUUsTUFBTSxzQkFBc0IsQ0FBQzs7OztBQUduRCxNQUFNLE9BQU8sY0FBYztJQUdJO0lBQTJDO0lBRmpFLE1BQU0sQ0FBVSxvQkFBb0IsR0FBRyxrRkFBa0YsQ0FBQztJQUVqSSxZQUE2QixXQUF3QixFQUFtQixTQUE0QjtRQUF2RSxnQkFBVyxHQUFYLFdBQVcsQ0FBYTtRQUFtQixjQUFTLEdBQVQsU0FBUyxDQUFtQjtJQUNwRyxDQUFDO0lBRU0sVUFBVSxDQUFDLHNCQUFnQztRQUNoRCxNQUFNLEdBQUcsR0FBRyxJQUFJLENBQUMsU0FBUyxDQUFDLGFBQWEsRUFBRSxDQUFDO1FBQzNDLE1BQU0sT0FBTyxHQUFHLElBQUksV0FBVyxFQUFFO2FBQzlCLEdBQUcsQ0FBQyxjQUFjLEVBQUUsTUFBTSxDQUFDO2FBQzNCLEdBQUcsQ0FBQyxRQUFRLEVBQUUsY0FBYyxDQUFDLG9CQUFvQixDQUFDO2FBQ2xELEdBQUcsQ0FBQyxjQUFjLEVBQUUsa0JBQWtCLENBQUMsQ0FBQztRQUMzQyxJQUFJLE1BQU0sR0FBRyxJQUFJLFVBQVUsRUFBRSxDQUFDO1FBQzlCLHNCQUFzQixDQUFDLE9BQU8sQ0FBQyxTQUFTLENBQUMsRUFBRSxDQUFDLE1BQU0sR0FBRyxNQUFNLENBQUMsTUFBTSxDQUFDLEtBQUssRUFBRSxTQUFTLENBQUMsQ0FBQyxDQUFDO1FBQ3RGLE9BQU8sSUFBSSxDQUFDLFdBQVc7YUFDcEIsR0FBRyxDQUFDLEdBQUcsRUFBRSxFQUFDLE1BQU0sRUFBRSxPQUFPLEVBQUUsT0FBTyxFQUFFLE1BQU0sRUFBQyxDQUFDO2FBQzVDLElBQUksQ0FDSCxHQUFHLENBQUMsSUFBSSxDQUFDLEVBQUUsQ0FBQyxJQUFJLENBQUMsT0FBTyxDQUFDLENBQzFCLENBQUM7SUFDTixDQUFDO3dFQW5CVSxjQUFjO2dFQUFkLGNBQWMsV0FBZCxjQUFjOzt1RkFBZCxjQUFjO2NBRDFCLFVBQVUiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBIdHRwSGVhZGVycywgSHR0cFBhcmFtcyB9IGZyb20gJ0Bhbmd1bGFyL2NvbW1vbi9odHRwJztcbmltcG9ydCB7IEluamVjdGFibGUgfSBmcm9tICdAYW5ndWxhci9jb3JlJztcbmltcG9ydCB7IE9ic2VydmFibGUgfSBmcm9tICdyeGpzJztcbmltcG9ydCB7IG1hcCB9IGZyb20gJ3J4anMvb3BlcmF0b3JzJztcbmltcG9ydCB7IEFic3RyYWN0QXBwQ29uZmlnIH0gZnJvbSAnLi4vLi4vLi4vYXBwLmNvbmZpZyc7XG5pbXBvcnQgeyBCYW5uZXIgfSBmcm9tICcuLi8uLi9kb21haW4vZGVmaW5pdGlvbi9iYW5uZXIubW9kZWwnO1xuaW1wb3J0IHsgSHR0cFNlcnZpY2UgfSBmcm9tICcuLi9odHRwL2h0dHAuc2VydmljZSc7XG5cbkBJbmplY3RhYmxlKClcbmV4cG9ydCBjbGFzcyBCYW5uZXJzU2VydmljZSB7XG4gIHB1YmxpYyBzdGF0aWMgcmVhZG9ubHkgVjJfTUVESUFUWVBFX0JBTk5FUlMgPSAnYXBwbGljYXRpb24vdm5kLnVrLmdvdi5obWN0cy5jY2QtZGF0YS1zdG9yZS1hcGkudWktYmFubmVycy52Mitqc29uO2NoYXJzZXQ9VVRGLTgnO1xuXG4gIGNvbnN0cnVjdG9yKHByaXZhdGUgcmVhZG9ubHkgaHR0cFNlcnZpY2U6IEh0dHBTZXJ2aWNlLCBwcml2YXRlIHJlYWRvbmx5IGFwcENvbmZpZzogQWJzdHJhY3RBcHBDb25maWcpIHtcbiAgfVxuXG4gIHB1YmxpYyBnZXRCYW5uZXJzKGp1cmlzZGljdGlvblJlZmVyZW5jZXM6IHN0cmluZ1tdKTogT2JzZXJ2YWJsZTxCYW5uZXJbXT4ge1xuICAgIGNvbnN0IHVybCA9IHRoaXMuYXBwQ29uZmlnLmdldEJhbm5lcnNVcmwoKTtcbiAgICBjb25zdCBoZWFkZXJzID0gbmV3IEh0dHBIZWFkZXJzKClcbiAgICAgIC5zZXQoJ2V4cGVyaW1lbnRhbCcsICd0cnVlJylcbiAgICAgIC5zZXQoJ0FjY2VwdCcsIEJhbm5lcnNTZXJ2aWNlLlYyX01FRElBVFlQRV9CQU5ORVJTKVxuICAgICAgLnNldCgnQ29udGVudC1UeXBlJywgJ2FwcGxpY2F0aW9uL2pzb24nKTtcbiAgICBsZXQgcGFyYW1zID0gbmV3IEh0dHBQYXJhbXMoKTtcbiAgICBqdXJpc2RpY3Rpb25SZWZlcmVuY2VzLmZvckVhY2gocmVmZXJlbmNlID0+IHBhcmFtcyA9IHBhcmFtcy5hcHBlbmQoJ2lkcycsIHJlZmVyZW5jZSkpO1xuICAgIHJldHVybiB0aGlzLmh0dHBTZXJ2aWNlXG4gICAgICAuZ2V0KHVybCwge3BhcmFtcywgaGVhZGVycywgb2JzZXJ2ZTogJ2JvZHknfSlcbiAgICAgIC5waXBlKFxuICAgICAgICBtYXAoYm9keSA9PiBib2R5LmJhbm5lcnMpXG4gICAgICApO1xuICB9XG59XG4iXX0=

package/esm2022/lib/shared/services/browser/browser.service.mjs

@@ -0,0 +1,24 @@
+import { Injectable } from '@angular/core';
+import * as i0 from "@angular/core";
+export class BrowserService {
+    isFirefox() {
+        return window.navigator.userAgent.indexOf('Firefox') > -1;
+    }
+    isSafari() {
+        const isSafariAgent = window.navigator.userAgent.indexOf('Safari') > -1;
+        const isChromeAgent = window.navigator.userAgent.indexOf('Chrome') > -1;
+        if ((isChromeAgent) && (isSafariAgent)) {
+            return false;
+        }
+        return isSafariAgent;
+    }
+    isIEOrEdge() {
+        return /msie\s|trident\/|edge\//i.test(window.navigator.userAgent);
+    }
+    static ɵfac = function BrowserService_Factory(t) { return new (t || BrowserService)(); };
+    static ɵprov = /*@__PURE__*/ i0.ɵɵdefineInjectable({ token: BrowserService, factory: BrowserService.ɵfac });
+}
+(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(BrowserService, [{
+        type: Injectable
+    }], null, null); })();
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYnJvd3Nlci5zZXJ2aWNlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vLi4vcHJvamVjdHMvY2NkLWNhc2UtdWktdG9vbGtpdC9zcmMvbGliL3NoYXJlZC9zZXJ2aWNlcy9icm93c2VyL2Jyb3dzZXIuc2VydmljZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsVUFBVSxFQUFFLE1BQU0sZUFBZSxDQUFDOztBQUczQyxNQUFNLE9BQU8sY0FBYztJQUNsQixTQUFTO1FBQ2QsT0FBTyxNQUFNLENBQUMsU0FBUyxDQUFDLFNBQVMsQ0FBQyxPQUFPLENBQUMsU0FBUyxDQUFDLEdBQUcsQ0FBQyxDQUFDLENBQUM7SUFDNUQsQ0FBQztJQUNNLFFBQVE7UUFDYixNQUFNLGFBQWEsR0FBRyxNQUFNLENBQUMsU0FBUyxDQUFDLFNBQVMsQ0FBQyxPQUFPLENBQUMsUUFBUSxDQUFDLEdBQUcsQ0FBQyxDQUFDLENBQUM7UUFDeEUsTUFBTSxhQUFhLEdBQUcsTUFBTSxDQUFDLFNBQVMsQ0FBQyxTQUFTLENBQUMsT0FBTyxDQUFDLFFBQVEsQ0FBQyxHQUFHLENBQUMsQ0FBQyxDQUFDO1FBQ3hFLElBQUksQ0FBQyxhQUFhLENBQUMsSUFBSSxDQUFDLGFBQWEsQ0FBQyxFQUFFO1lBQ3RDLE9BQU8sS0FBSyxDQUFDO1NBQ2Q7UUFDRCxPQUFPLGFBQWEsQ0FBQztJQUN2QixDQUFDO0lBQ00sVUFBVTtRQUNmLE9BQU8sMEJBQTBCLENBQUMsSUFBSSxDQUFDLE1BQU0sQ0FBQyxTQUFTLENBQUMsU0FBUyxDQUFDLENBQUM7SUFDckUsQ0FBQzt3RUFkVSxjQUFjO2dFQUFkLGNBQWMsV0FBZCxjQUFjOzt1RkFBZCxjQUFjO2NBRDFCLFVBQVUiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBJbmplY3RhYmxlIH0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XG5cbkBJbmplY3RhYmxlKClcbmV4cG9ydCBjbGFzcyBCcm93c2VyU2VydmljZSB7XG4gIHB1YmxpYyBpc0ZpcmVmb3goKTogYm9vbGVhbiB7XG4gICAgcmV0dXJuIHdpbmRvdy5uYXZpZ2F0b3IudXNlckFnZW50LmluZGV4T2YoJ0ZpcmVmb3gnKSA+IC0xO1xuICB9XG4gIHB1YmxpYyBpc1NhZmFyaSgpOiBib29sZWFuIHtcbiAgICBjb25zdCBpc1NhZmFyaUFnZW50ID0gd2luZG93Lm5hdmlnYXRvci51c2VyQWdlbnQuaW5kZXhPZignU2FmYXJpJykgPiAtMTtcbiAgICBjb25zdCBpc0Nocm9tZUFnZW50ID0gd2luZG93Lm5hdmlnYXRvci51c2VyQWdlbnQuaW5kZXhPZignQ2hyb21lJykgPiAtMTtcbiAgICBpZiAoKGlzQ2hyb21lQWdlbnQpICYmIChpc1NhZmFyaUFnZW50KSkge1xuICAgICAgcmV0dXJuIGZhbHNlO1xuICAgIH1cbiAgICByZXR1cm4gaXNTYWZhcmlBZ2VudDtcbiAgfVxuICBwdWJsaWMgaXNJRU9yRWRnZSgpOiBib29sZWFuIHtcbiAgICByZXR1cm4gL21zaWVcXHN8dHJpZGVudFxcL3xlZGdlXFwvL2kudGVzdCh3aW5kb3cubmF2aWdhdG9yLnVzZXJBZ2VudCk7XG4gIH1cbn1cbiJdfQ==