@hmcts/rpx-xui-common-lib 2.1.2-angular-upgrade-11 → 2.1.2-google-analytics

package/esm2022/lib/services/ref-data/ref-data-data-access/ref-data-data-access.service.mjs

@@ -0,0 +1,33 @@
+import { HttpClient, HttpParams } from '@angular/common/http';
+import { Injectable } from '@angular/core';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common/http";
+export class RefDataDataAccessService {
+    static { this.refDataUrl = '/api/ref-data'; }
+    constructor(http) {
+        this.http = http;
+    }
+    getServices() {
+        return this.http.get(`${RefDataDataAccessService.refDataUrl}/services`);
+    }
+    getRegions() {
+        return this.http.get(`${RefDataDataAccessService.refDataUrl}/regions`);
+    }
+    getLocationsByServiceCode(serviceCode) {
+        const httpParams = new HttpParams()
+            .append('service_code', serviceCode);
+        return this.http.get(`${RefDataDataAccessService.refDataUrl}/locations-by-service-code`, { params: httpParams });
+    }
+    getLocations() {
+        return this.http.get(`${RefDataDataAccessService.refDataUrl}/locations`);
+    }
+    static { this.ɵfac = function RefDataDataAccessService_Factory(__ngFactoryType__) { return new (__ngFactoryType__ || RefDataDataAccessService)(i0.ɵɵinject(i1.HttpClient)); }; }
+    static { this.ɵprov = /*@__PURE__*/ i0.ɵɵdefineInjectable({ token: RefDataDataAccessService, factory: RefDataDataAccessService.ɵfac, providedIn: 'root' }); }
+}
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(RefDataDataAccessService, [{
+        type: Injectable,
+        args: [{
+                providedIn: 'root'
+            }]
+    }], () => [{ type: i1.HttpClient }], null); })();
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/services/ref-data/ref-data.service.mjs

@@ -0,0 +1,34 @@
+import { Injectable } from '@angular/core';
+import { forkJoin, of } from 'rxjs';
+import { catchError, map, shareReplay, take } from 'rxjs/operators';
+import { RefDataDataAccessService } from './ref-data-data-access/ref-data-data-access.service';
+import * as i0 from "@angular/core";
+import * as i1 from "./ref-data-data-access/ref-data-data-access.service";
+export class RefDataService {
+    constructor(refDataDataAccessService) {
+        this.refDataDataAccessService = refDataDataAccessService;
+        this.locationsByServiceCodesCache = {};
+        this.regions$ = this.refDataDataAccessService.getRegions().pipe(shareReplay());
+        this.services$ = this.refDataDataAccessService.getServices().pipe(shareReplay());
+        this.locations$ = this.refDataDataAccessService.getLocations().pipe(shareReplay());
+    }
+    getLocationsByServiceCodes(serviceCodes) {
+        const observables = [];
+        serviceCodes.forEach(serviceCode => {
+            if (!this.locationsByServiceCodesCache[serviceCode]) {
+                this.locationsByServiceCodesCache[serviceCode] = this.refDataDataAccessService.getLocationsByServiceCode(serviceCode).pipe(catchError(() => of({ court_venues: [] })), map(responseData => responseData.court_venues), shareReplay());
+            }
+            observables.push(this.locationsByServiceCodesCache[serviceCode]);
+        });
+        return forkJoin(observables).pipe(map((values) => values.reduce((acc, val) => acc.concat(val)), []), take(1));
+    }
+    static { this.ɵfac = function RefDataService_Factory(__ngFactoryType__) { return new (__ngFactoryType__ || RefDataService)(i0.ɵɵinject(i1.RefDataDataAccessService)); }; }
+    static { this.ɵprov = /*@__PURE__*/ i0.ɵɵdefineInjectable({ token: RefDataService, factory: RefDataService.ɵfac, providedIn: 'root' }); }
+}
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(RefDataService, [{
+        type: Injectable,
+        args: [{
+                providedIn: 'root'
+            }]
+    }], () => [{ type: i1.RefDataDataAccessService }], null); })();
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/services/role-guard/role.guard.mjs

@@ -0,0 +1,43 @@
+import { Injectable } from '@angular/core';
+import { Router } from '@angular/router';
+import { map } from 'rxjs/operators';
+import { RoleService } from './role.service';
+import * as i0 from "@angular/core";
+import * as i1 from "./role.service";
+import * as i2 from "@angular/router";
+export var RoleMatching;
+(function (RoleMatching) {
+    RoleMatching[RoleMatching["ALL"] = 0] = "ALL";
+    RoleMatching[RoleMatching["ANY"] = 1] = "ANY";
+})(RoleMatching || (RoleMatching = {}));
+export class RoleGuard {
+    constructor(roleService, router) {
+        this.roleService = roleService;
+        this.router = router;
+    }
+    // TEST-TODO
+    /*
+    * Note: Per Angular 18, when a guard returns a UrlTree as a redirect,
+    * the redirecting navigation will now use replaceUrl if the initial navigation was also using the replaceUrl option.
+    * */
+    canActivate(route) {
+        return this.roleService.roles$.pipe(map(roles => {
+            const canActivateRoles = route.data.needsRole;
+            const check = (roleRegEx) => {
+                const regex = new RegExp(roleRegEx);
+                return roles.some(role => regex.test(role));
+            };
+            const match = route.data.roleMatching === RoleMatching.ALL ? canActivateRoles.every(check) : canActivateRoles.some(check);
+            return match || this.router.parseUrl(route.data.noRoleMatchRedirect);
+        }));
+    }
+    static { this.ɵfac = function RoleGuard_Factory(__ngFactoryType__) { return new (__ngFactoryType__ || RoleGuard)(i0.ɵɵinject(i1.RoleService), i0.ɵɵinject(i2.Router)); }; }
+    static { this.ɵprov = /*@__PURE__*/ i0.ɵɵdefineInjectable({ token: RoleGuard, factory: RoleGuard.ɵfac, providedIn: 'root' }); }
+}
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(RoleGuard, [{
+        type: Injectable,
+        args: [{
+                providedIn: 'root'
+            }]
+    }], () => [{ type: i1.RoleService }, { type: i2.Router }], null); })();
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/services/role-guard/role.service.mjs

@@ -0,0 +1,22 @@
+import { Injectable } from '@angular/core';
+import { BehaviorSubject } from 'rxjs';
+import { skipWhile } from 'rxjs/operators';
+import * as i0 from "@angular/core";
+export class RoleService {
+    constructor() {
+        this.pRoles = new BehaviorSubject(null);
+        this.roles$ = this.pRoles.asObservable().pipe(skipWhile(item => item === null));
+    }
+    set roles(roles) {
+        this.pRoles.next(roles);
+    }
+    static { this.ɵfac = function RoleService_Factory(__ngFactoryType__) { return new (__ngFactoryType__ || RoleService)(); }; }
+    static { this.ɵprov = /*@__PURE__*/ i0.ɵɵdefineInjectable({ token: RoleService, factory: RoleService.ɵfac, providedIn: 'root' }); }
+}
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(RoleService, [{
+        type: Injectable,
+        args: [{
+                providedIn: 'root'
+            }]
+    }], null, null); })();
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicm9sZS5zZXJ2aWNlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vcHJvamVjdHMvZXh1aS1jb21tb24tbGliL3NyYy9saWIvc2VydmljZXMvcm9sZS1ndWFyZC9yb2xlLnNlcnZpY2UudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLFVBQVUsRUFBRSxNQUFNLGVBQWUsQ0FBQztBQUMzQyxPQUFPLEVBQUUsZUFBZSxFQUFFLE1BQU0sTUFBTSxDQUFDO0FBQ3ZDLE9BQU8sRUFBRSxTQUFTLEVBQUUsTUFBTSxnQkFBZ0IsQ0FBQzs7QUFTM0MsTUFBTSxPQUFPLFdBQVc7SUFIeEI7UUFJb0IsV0FBTSxHQUFHLElBQUksZUFBZSxDQUFRLElBQUksQ0FBQyxDQUFDO1FBQ25ELFdBQU0sR0FBRyxJQUFJLENBQUMsTUFBTSxDQUFDLFlBQVksRUFBRSxDQUFDLElBQUksQ0FBQyxTQUFTLENBQUMsSUFBSSxDQUFDLEVBQUUsQ0FBQyxJQUFJLEtBQUssSUFBSSxDQUFDLENBQUMsQ0FBQztLQUtyRjtJQUhHLElBQVcsS0FBSyxDQUFDLEtBQVk7UUFDekIsSUFBSSxDQUFDLE1BQU0sQ0FBQyxJQUFJLENBQUMsS0FBSyxDQUFDLENBQUM7SUFDNUIsQ0FBQzs0R0FOUSxXQUFXO3VFQUFYLFdBQVcsV0FBWCxXQUFXLG1CQUZSLE1BQU07O2lGQUVULFdBQVc7Y0FIdkIsVUFBVTtlQUFDO2dCQUNSLFVBQVUsRUFBRSxNQUFNO2FBQ25CIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgSW5qZWN0YWJsZSB9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xuaW1wb3J0IHsgQmVoYXZpb3JTdWJqZWN0IH0gZnJvbSAncnhqcyc7XG5pbXBvcnQgeyBza2lwV2hpbGUgfSBmcm9tICdyeGpzL29wZXJhdG9ycyc7XG5cbi8vIHVzZSB0eXBlcyBzbyB3ZSBjYW4gbW92ZSB0byBzdHJpY3RlZCB0eXBpbmcgbGF0ZXIgb25cbmV4cG9ydCB0eXBlIFJvbGUgPSBzdHJpbmc7XG5leHBvcnQgdHlwZSBSb2xlcyA9IFJvbGVbXTtcblxuQEluamVjdGFibGUoe1xuICAgIHByb3ZpZGVkSW46ICdyb290J1xuICB9KVxuZXhwb3J0IGNsYXNzIFJvbGVTZXJ2aWNlIHtcbiAgICBwdWJsaWMgcmVhZG9ubHkgcFJvbGVzID0gbmV3IEJlaGF2aW9yU3ViamVjdDxSb2xlcz4obnVsbCk7XG4gICAgcHVibGljIHJvbGVzJCA9IHRoaXMucFJvbGVzLmFzT2JzZXJ2YWJsZSgpLnBpcGUoc2tpcFdoaWxlKGl0ZW0gPT4gaXRlbSA9PT0gbnVsbCkpO1xuXG4gICAgcHVibGljIHNldCByb2xlcyhyb2xlczogUm9sZXMpIHtcbiAgICAgICAgdGhpcy5wUm9sZXMubmV4dChyb2xlcyk7XG4gICAgfVxufVxuIl19

package/esm2022/lib/services/storage/session-storage/session-storage.service.mjs

@@ -0,0 +1,43 @@
+import { Injectable } from '@angular/core';
+import * as i0 from "@angular/core";
+export class SessionStorageService {
+    /**
+     * Get an item from the session storage.
+     * If remove is true, the item will be removed once read
+     * @param removeAfterRead removed the key once it has been read
+     */
+    getItem(key, removeAfterRead = false) {
+        const item = sessionStorage.getItem(key);
+        if (removeAfterRead) {
+            this.removeItem(key);
+        }
+        return item;
+    }
+    /**
+     * Set an item in the session storage.
+     */
+    setItem(key, value) {
+        sessionStorage.setItem(key, value);
+    }
+    /**
+     * Remove an item in the session storage.
+     */
+    removeItem(key) {
+        sessionStorage.removeItem(key);
+    }
+    /**
+     * Clear all the items held in session storage.
+     */
+    clear() {
+        sessionStorage.clear();
+    }
+    static { this.ɵfac = function SessionStorageService_Factory(__ngFactoryType__) { return new (__ngFactoryType__ || SessionStorageService)(); }; }
+    static { this.ɵprov = /*@__PURE__*/ i0.ɵɵdefineInjectable({ token: SessionStorageService, factory: SessionStorageService.ɵfac, providedIn: 'root' }); }
+}
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(SessionStorageService, [{
+        type: Injectable,
+        args: [{
+                providedIn: 'root'
+            }]
+    }], null, null); })();
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/services/task-name/task-name.service.mjs

@@ -0,0 +1,35 @@
+import { HttpClient } from '@angular/common/http';
+import { Injectable } from '@angular/core';
+import { of } from 'rxjs';
+import { tap } from 'rxjs/operators';
+import { SessionStorageService } from '../storage/session-storage/session-storage.service';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common/http";
+import * as i2 from "../storage/session-storage/session-storage.service";
+export class TaskNameService {
+    static { this.taskNamesKey = 'taskNames'; }
+    constructor(http, sessionStorageService) {
+        this.http = http;
+        this.sessionStorageService = sessionStorageService;
+    }
+    /**
+     * @return Observable<any[]>: Array of taskName in Observable
+     */
+    getTaskName(service) {
+        const serviceTaskTypeKey = `${service}-${TaskNameService.taskNamesKey}`;
+        if (this.sessionStorageService.getItem(serviceTaskTypeKey)) {
+            const taskNames = JSON.parse(this.sessionStorageService.getItem(serviceTaskTypeKey));
+            return of(taskNames);
+        }
+        return this.http.post(`/workallocation/taskNames`, { service }).pipe(tap(taskNames => this.sessionStorageService.setItem(serviceTaskTypeKey, JSON.stringify(taskNames))));
+    }
+    static { this.ɵfac = function TaskNameService_Factory(__ngFactoryType__) { return new (__ngFactoryType__ || TaskNameService)(i0.ɵɵinject(i1.HttpClient), i0.ɵɵinject(i2.SessionStorageService)); }; }
+    static { this.ɵprov = /*@__PURE__*/ i0.ɵɵdefineInjectable({ token: TaskNameService, factory: TaskNameService.ɵfac, providedIn: 'root' }); }
+}
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(TaskNameService, [{
+        type: Injectable,
+        args: [{
+                providedIn: 'root'
+            }]
+    }], () => [{ type: i1.HttpClient }, { type: i2.SessionStorageService }], null); })();
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidGFzay1uYW1lLnNlcnZpY2UuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9leHVpLWNvbW1vbi1saWIvc3JjL2xpYi9zZXJ2aWNlcy90YXNrLW5hbWUvdGFzay1uYW1lLnNlcnZpY2UudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFDLFVBQVUsRUFBQyxNQUFNLHNCQUFzQixDQUFDO0FBQ2hELE9BQU8sRUFBQyxVQUFVLEVBQUMsTUFBTSxlQUFlLENBQUM7QUFDekMsT0FBTyxFQUFhLEVBQUUsRUFBQyxNQUFNLE1BQU0sQ0FBQztBQUNwQyxPQUFPLEVBQUUsR0FBRyxFQUFFLE1BQU0sZ0JBQWdCLENBQUM7QUFFckMsT0FBTyxFQUFFLHFCQUFxQixFQUFFLE1BQU0sb0RBQW9ELENBQUM7Ozs7QUFLM0YsTUFBTSxPQUFPLGVBQWU7YUFDWixpQkFBWSxHQUFXLFdBQVcsQUFBdEIsQ0FBdUI7SUFFakQsWUFBNkIsSUFBZ0IsRUFBbUIscUJBQTRDO1FBQS9FLFNBQUksR0FBSixJQUFJLENBQVk7UUFBbUIsMEJBQXFCLEdBQXJCLHFCQUFxQixDQUF1QjtJQUM1RyxDQUFDO0lBRUQ7O09BRUc7SUFDSSxXQUFXLENBQUMsT0FBZTtRQUNoQyxNQUFNLGtCQUFrQixHQUFHLEdBQUcsT0FBTyxJQUFJLGVBQWUsQ0FBQyxZQUFZLEVBQUUsQ0FBQztRQUN4RSxJQUFJLElBQUksQ0FBQyxxQkFBcUIsQ0FBQyxPQUFPLENBQUMsa0JBQWtCLENBQUMsRUFBRSxDQUFDO1lBQzNELE1BQU0sU0FBUyxHQUFHLElBQUksQ0FBQyxLQUFLLENBQUMsSUFBSSxDQUFDLHFCQUFxQixDQUFDLE9BQU8sQ0FBQyxrQkFBa0IsQ0FBQyxDQUFDLENBQUM7WUFDckYsT0FBTyxFQUFFLENBQUMsU0FBNEIsQ0FBQyxDQUFDO1FBQzFDLENBQUM7UUFDRCxPQUFPLElBQUksQ0FBQyxJQUFJLENBQUMsSUFBSSxDQUFrQiwyQkFBMkIsRUFBRSxFQUFDLE9BQU8sRUFBQyxDQUFDLENBQUMsSUFBSSxDQUNqRixHQUFHLENBQUMsU0FBUyxDQUFDLEVBQUUsQ0FBQyxJQUFJLENBQUMscUJBQXFCLENBQUMsT0FBTyxDQUFDLGtCQUFrQixFQUFFLElBQUksQ0FBQyxTQUFTLENBQUMsU0FBUyxDQUFDLENBQUMsQ0FBQyxDQUNwRyxDQUFDO0lBQ0osQ0FBQztnSEFsQlUsZUFBZTt1RUFBZixlQUFlLFdBQWYsZUFBZSxtQkFGZCxNQUFNOztpRkFFUCxlQUFlO2NBSDNCLFVBQVU7ZUFBQztnQkFDVixVQUFVLEVBQUUsTUFBTTthQUNuQiIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7SHR0cENsaWVudH0gZnJvbSAnQGFuZ3VsYXIvY29tbW9uL2h0dHAnO1xuaW1wb3J0IHtJbmplY3RhYmxlfSBmcm9tICdAYW5ndWxhci9jb3JlJztcbmltcG9ydCB7T2JzZXJ2YWJsZSwgb2Z9IGZyb20gJ3J4anMnO1xuaW1wb3J0IHsgdGFwIH0gZnJvbSAncnhqcy9vcGVyYXRvcnMnO1xuaW1wb3J0IHsgVGFza05hbWVNb2RlbCB9IGZyb20gJy4uLy4uL21vZGVscy90YXNrLW5hbWUubW9kZWwnO1xuaW1wb3J0IHsgU2Vzc2lvblN0b3JhZ2VTZXJ2aWNlIH0gZnJvbSAnLi4vc3RvcmFnZS9zZXNzaW9uLXN0b3JhZ2Uvc2Vzc2lvbi1zdG9yYWdlLnNlcnZpY2UnO1xuXG5ASW5qZWN0YWJsZSh7XG4gIHByb3ZpZGVkSW46ICdyb290J1xufSlcbmV4cG9ydCBjbGFzcyBUYXNrTmFtZVNlcnZpY2Uge1xuICBwdWJsaWMgc3RhdGljIHRhc2tOYW1lc0tleTogc3RyaW5nID0gJ3Rhc2tOYW1lcyc7XG5cbiAgY29uc3RydWN0b3IocHJpdmF0ZSByZWFkb25seSBodHRwOiBIdHRwQ2xpZW50LCBwcml2YXRlIHJlYWRvbmx5IHNlc3Npb25TdG9yYWdlU2VydmljZTogU2Vzc2lvblN0b3JhZ2VTZXJ2aWNlKSB7XG4gIH1cblxuICAvKipcbiAgICogQHJldHVybiBPYnNlcnZhYmxlPGFueVtdPjogQXJyYXkgb2YgdGFza05hbWUgaW4gT2JzZXJ2YWJsZVxuICAgKi9cbiAgcHVibGljIGdldFRhc2tOYW1lKHNlcnZpY2U6IHN0cmluZyk6IE9ic2VydmFibGU8VGFza05hbWVNb2RlbFtdPiB7XG4gICAgY29uc3Qgc2VydmljZVRhc2tUeXBlS2V5ID0gYCR7c2VydmljZX0tJHtUYXNrTmFtZVNlcnZpY2UudGFza05hbWVzS2V5fWA7XG4gICAgaWYgKHRoaXMuc2Vzc2lvblN0b3JhZ2VTZXJ2aWNlLmdldEl0ZW0oc2VydmljZVRhc2tUeXBlS2V5KSkge1xuICAgICAgY29uc3QgdGFza05hbWVzID0gSlNPTi5wYXJzZSh0aGlzLnNlc3Npb25TdG9yYWdlU2VydmljZS5nZXRJdGVtKHNlcnZpY2VUYXNrVHlwZUtleSkpO1xuICAgICAgcmV0dXJuIG9mKHRhc2tOYW1lcyBhcyBUYXNrTmFtZU1vZGVsW10pO1xuICAgIH1cbiAgICByZXR1cm4gdGhpcy5odHRwLnBvc3Q8VGFza05hbWVNb2RlbFtdPihgL3dvcmthbGxvY2F0aW9uL3Rhc2tOYW1lc2AsIHtzZXJ2aWNlfSkucGlwZShcbiAgICAgIHRhcCh0YXNrTmFtZXMgPT4gdGhpcy5zZXNzaW9uU3RvcmFnZVNlcnZpY2Uuc2V0SXRlbShzZXJ2aWNlVGFza1R5cGVLZXksIEpTT04uc3RyaW5naWZ5KHRhc2tOYW1lcykpKVxuICAgICk7XG4gIH1cbn1cbiJdfQ==

package/esm2022/lib/services/timeout-notifications/timeout-notifications.service.mjs

@@ -0,0 +1,103 @@
+import { Injectable } from '@angular/core';
+import { DocumentInterruptSource, Idle, WindowInterruptSource } from '@ng-idle/core';
+import { Keepalive } from '@ng-idle/keepalive';
+import { Subject } from 'rxjs';
+import { distinctUntilChanged, map } from 'rxjs/operators';
+import * as i0 from "@angular/core";
+import * as i1 from "@ng-idle/core";
+import * as i2 from "@ng-idle/keepalive";
+/**
+ * TimeoutNotificationsService
+ *
+ * The Timeout Notification Service allows your application to receive notifications
+ * when a User is approaching the total time that a User has been idle for.
+ *
+ * This can be set by your application using the Timeout Notification Config object.
+ *
+ * Your application will then have to listen to events coming from the Timeout Notification Service,
+ * and handle these events within your application.
+ *
+ * @see README.md for implementation details and code, on how to implement the Timeout Notification
+ * Service within your application.
+ */
+export class TimeoutNotificationsService {
+    constructor(idle, keepalive) {
+        this.idle = idle;
+        this.keepalive = keepalive;
+        this.subs = [];
+        /**
+         * Convert milliseconds to seconds.
+         *
+         * @param milliseconds - 1000
+         * @return seconds - 1
+         */
+        this.millisecondsToSeconds = (milliseconds) => milliseconds / 1000;
+        this.eventEmitter = new Subject();
+    }
+    /**
+     * Initialise
+     *
+     * Initialise the Timeout Notification Events.
+     *
+     * I made the decision not to make ' minutes' and ' seconds' configurable via input parameters -
+     * As I made an assumption that any Reform team would not need to change these to 'secs, mins' or 's, m'.
+     *
+     * idleModalDisplayTime and totalIdleTime need to be passed in, in milliseconds.
+     *
+     * @see README.md for more information on TimeoutNotificationService.
+     */
+    initialise(config) {
+        const DOCUMENT_INTERRUPTS = 'mousedown keydown DOMMouseScroll mousewheel touchstart touchmove scroll';
+        const MINUTES = ' minutes';
+        const SECONDS = ' seconds';
+        const SIGNOUT_EVENT = 'sign-out';
+        const COUNTDOWN_EVENT = 'countdown';
+        const KEEP_ALIVE_EVENT = 'keep-alive';
+        const { idleServiceName, idleModalDisplayTime, totalIdleTime } = config;
+        this.idle.setIdleName(idleServiceName);
+        const idleModalDisplayTimeInSeconds = this.millisecondsToSeconds(idleModalDisplayTime);
+        const totalIdleTimeInSeconds = this.millisecondsToSeconds(totalIdleTime);
+        this.idle.setTimeout(idleModalDisplayTimeInSeconds);
+        const docInterrupts = new DocumentInterruptSource(DOCUMENT_INTERRUPTS);
+        const windowInterrupts = new WindowInterruptSource(DOCUMENT_INTERRUPTS);
+        this.idle.setInterrupts([docInterrupts, windowInterrupts]);
+        this.subs.push(this.idle.onTimeout.subscribe(() => {
+            this.eventEmitter.next({ eventType: SIGNOUT_EVENT });
+        }));
+        this.subs.push(this.idle.onTimeoutWarning.pipe(map(sec => (sec > 60) ? Math.ceil(sec / 60) + MINUTES : sec + SECONDS), distinctUntilChanged()).subscribe((countdown) => {
+            this.eventEmitter.next({ eventType: COUNTDOWN_EVENT, readableCountdown: countdown });
+        }));
+        this.subs.push(this.idle.onIdleStart.subscribe(() => console.log('You\'ve gone idle!')));
+        this.subs.push(this.idle.onIdleEnd.subscribe(() => console.log('You\'re no longer idle!')));
+        this.keepalive.interval(15);
+        this.subs.push(this.keepalive.onPing.subscribe(() => {
+            this.eventEmitter.next({ eventType: KEEP_ALIVE_EVENT });
+        }));
+        const idleInSeconds = Math.floor(totalIdleTimeInSeconds) - idleModalDisplayTimeInSeconds;
+        this.idle.setIdle(idleInSeconds);
+        this.idle.watch();
+    }
+    reset() {
+        this.idle.watch();
+    }
+    close() {
+        this.subs.forEach(s => s.unsubscribe());
+        this.idle.stop();
+        this.idle.clearInterrupts();
+    }
+    /**
+     * Expose the notification events, so that a 3rd party service can listen to the notifications.
+     */
+    notificationOnChange() {
+        return this.eventEmitter.asObservable();
+    }
+    static { this.ɵfac = function TimeoutNotificationsService_Factory(__ngFactoryType__) { return new (__ngFactoryType__ || TimeoutNotificationsService)(i0.ɵɵinject(i1.Idle), i0.ɵɵinject(i2.Keepalive)); }; }
+    static { this.ɵprov = /*@__PURE__*/ i0.ɵɵdefineInjectable({ token: TimeoutNotificationsService, factory: TimeoutNotificationsService.ɵfac, providedIn: 'root' }); }
+}
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(TimeoutNotificationsService, [{
+        type: Injectable,
+        args: [{
+                providedIn: 'root'
+            }]
+    }], () => [{ type: i1.Idle }, { type: i2.Keepalive }], null); })();
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"timeout-notifications.service.js","sourceRoot":"","sources":["../../../../../../projects/exui-common-lib/src/lib/services/timeout-notifications/timeout-notifications.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable } from '@angular/core';\nimport {DocumentInterruptSource, Idle, WindowInterruptSource} from '@ng-idle/core';\nimport {Keepalive} from '@ng-idle/keepalive';\nimport { Observable, Subject, Subscription } from 'rxjs';\nimport {\n  distinctUntilChanged,\n  map\n} from 'rxjs/operators';\nimport {TimeoutNotificationConfig} from '../../models';\n\n/**\n * TimeoutNotificationsService\n *\n * The Timeout Notification Service allows your application to receive notifications\n * when a User is approaching the total time that a User has been idle for.\n *\n * This can be set by your application using the Timeout Notification Config object.\n *\n * Your application will then have to listen to events coming from the Timeout Notification Service,\n * and handle these events within your application.\n *\n * @see README.md for implementation details and code, on how to implement the Timeout Notification\n * Service within your application.\n */\n@Injectable({\n  providedIn: 'root'\n})\nexport class TimeoutNotificationsService {\n\n  private readonly subs: Subscription[] = [];\n  private readonly eventEmitter: Subject<{eventType: string, readableCountdown?: string; }>;\n\n  constructor(\n    private readonly idle: Idle,\n    private readonly keepalive: Keepalive,\n  ) {\n    this.eventEmitter = new Subject();\n  }\n\n  /**\n   * Convert milliseconds to seconds.\n   *\n   * @param milliseconds - 1000\n   * @return seconds - 1\n   */\n  public millisecondsToSeconds = (milliseconds: number): number => milliseconds / 1000;\n\n  /**\n   * Initialise\n   *\n   * Initialise the Timeout Notification Events.\n   *\n   * I made the decision not to make ' minutes' and ' seconds' configurable via input parameters -\n   * As I made an assumption that any Reform team would not need to change these to 'secs, mins' or 's, m'.\n   *\n   * idleModalDisplayTime and totalIdleTime need to be passed in, in milliseconds.\n   *\n   * @see README.md for more information on TimeoutNotificationService.\n   */\n  public initialise(config: TimeoutNotificationConfig): void {\n\n    const DOCUMENT_INTERRUPTS = 'mousedown keydown DOMMouseScroll mousewheel touchstart touchmove scroll';\n\n    const MINUTES = ' minutes';\n    const SECONDS = ' seconds';\n\n    const SIGNOUT_EVENT = 'sign-out';\n    const COUNTDOWN_EVENT = 'countdown';\n    const KEEP_ALIVE_EVENT = 'keep-alive';\n\n    const {idleServiceName, idleModalDisplayTime, totalIdleTime} = config;\n\n    this.idle.setIdleName(idleServiceName);\n\n    const idleModalDisplayTimeInSeconds = this.millisecondsToSeconds(idleModalDisplayTime);\n    const totalIdleTimeInSeconds = this.millisecondsToSeconds(totalIdleTime);\n\n    this.idle.setTimeout(idleModalDisplayTimeInSeconds);\n\n    const docInterrupts = new DocumentInterruptSource(DOCUMENT_INTERRUPTS);\n    const windowInterrupts = new WindowInterruptSource(DOCUMENT_INTERRUPTS);\n    this.idle.setInterrupts([docInterrupts, windowInterrupts]);\n\n    this.subs.push(this.idle.onTimeout.subscribe(() => {\n      this.eventEmitter.next({eventType: SIGNOUT_EVENT});\n    }));\n\n    this.subs.push(this.idle.onTimeoutWarning.pipe(\n      map(sec => (sec > 60) ? Math.ceil(sec / 60) + MINUTES : sec + SECONDS),\n      distinctUntilChanged()\n    ).subscribe((countdown) => {\n      this.eventEmitter.next({eventType: COUNTDOWN_EVENT, readableCountdown: countdown});\n    }));\n    this.subs.push(this.idle.onIdleStart.subscribe(() => console.log('You\\'ve gone idle!')));\n    this.subs.push(this.idle.onIdleEnd.subscribe(() => console.log('You\\'re no longer idle!')));\n\n    this.keepalive.interval(15);\n    this.subs.push(this.keepalive.onPing.subscribe(() => {\n      this.eventEmitter.next({eventType: KEEP_ALIVE_EVENT});\n    }));\n\n    const idleInSeconds = Math.floor(totalIdleTimeInSeconds) - idleModalDisplayTimeInSeconds;\n    this.idle.setIdle(idleInSeconds);\n    this.idle.watch();\n  }\n\n  public reset(): void {\n    this.idle.watch();\n  }\n\n  public close(): void {\n    this.subs.forEach(s => s.unsubscribe());\n    this.idle.stop();\n    this.idle.clearInterrupts();\n  }\n\n  /**\n   * Expose the notification events, so that a 3rd party service can listen to the notifications.\n   */\n  public notificationOnChange(): Observable<any> {\n    return this.eventEmitter.asObservable();\n  }\n}\n"]}

package/esm2022/lib/window.mjs

@@ -0,0 +1,4 @@
+import { InjectionToken } from '@angular/core';
+export const windowToken = new InjectionToken('Window');
+export function windowProvider() { return window; }
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoid2luZG93LmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vcHJvamVjdHMvZXh1aS1jb21tb24tbGliL3NyYy9saWIvd2luZG93LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxjQUFjLEVBQUUsTUFBTSxlQUFlLENBQUM7QUFFL0MsTUFBTSxDQUFDLE1BQU0sV0FBVyxHQUFHLElBQUksY0FBYyxDQUFDLFFBQVEsQ0FBQyxDQUFDO0FBQ3hELE1BQU0sVUFBVSxjQUFjLEtBQUssT0FBTyxNQUFNLENBQUMsQ0FBQyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgSW5qZWN0aW9uVG9rZW4gfSBmcm9tICdAYW5ndWxhci9jb3JlJztcblxuZXhwb3J0IGNvbnN0IHdpbmRvd1Rva2VuID0gbmV3IEluamVjdGlvblRva2VuKCdXaW5kb3cnKTtcbmV4cG9ydCBmdW5jdGlvbiB3aW5kb3dQcm92aWRlcigpIHsgcmV0dXJuIHdpbmRvdzsgfVxuIl19

package/esm2022/public-api.mjs

@@ -0,0 +1,12 @@
+/*
+ * Public API Surface of exui-common-lib
+ */
+export * from './lib/components';
+export * from './lib/directives';
+export * from './lib/exui-common-lib.module';
+export * from './lib/gov-ui';
+export * from './lib/models';
+export * from './lib/pipes';
+export * from './lib/services';
+export * from './lib/window';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHVibGljLWFwaS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3Byb2plY3RzL2V4dWktY29tbW9uLWxpYi9zcmMvcHVibGljLWFwaS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7R0FFRztBQUVILGNBQWMsa0JBQWtCLENBQUM7QUFDakMsY0FBYyxrQkFBa0IsQ0FBQztBQUNqQyxjQUFjLDhCQUE4QixDQUFDO0FBQzdDLGNBQWMsY0FBYyxDQUFDO0FBQzdCLGNBQWMsY0FBYyxDQUFDO0FBQzdCLGNBQWMsYUFBYSxDQUFDO0FBQzVCLGNBQWMsZ0JBQWdCLENBQUM7QUFDL0IsY0FBYyxjQUFjLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyIvKlxuICogUHVibGljIEFQSSBTdXJmYWNlIG9mIGV4dWktY29tbW9uLWxpYlxuICovXG5cbmV4cG9ydCAqIGZyb20gJy4vbGliL2NvbXBvbmVudHMnO1xuZXhwb3J0ICogZnJvbSAnLi9saWIvZGlyZWN0aXZlcyc7XG5leHBvcnQgKiBmcm9tICcuL2xpYi9leHVpLWNvbW1vbi1saWIubW9kdWxlJztcbmV4cG9ydCAqIGZyb20gJy4vbGliL2dvdi11aSc7XG5leHBvcnQgKiBmcm9tICcuL2xpYi9tb2RlbHMnO1xuZXhwb3J0ICogZnJvbSAnLi9saWIvcGlwZXMnO1xuZXhwb3J0ICogZnJvbSAnLi9saWIvc2VydmljZXMnO1xuZXhwb3J0ICogZnJvbSAnLi9saWIvd2luZG93JztcbiJdfQ==