@hmcts/ccd-case-ui-toolkit 7.0.38 → 7.0.39-angular-upgrade-rc

package/esm2022/lib/shared/services/http/http-error.service.mjs

@@ -0,0 +1,67 @@
+import { HttpErrorResponse } from '@angular/common/http';
+import { Injectable } from '@angular/core';
+import { throwError } from 'rxjs';
+import { HttpError } from '../../domain/http/http-error.model';
+import { AuthService } from '../auth/auth.service';
+import * as i0 from "@angular/core";
+import * as i1 from "../auth/auth.service";
+export class HttpErrorService {
+    authService;
+    constructor(authService) {
+        this.authService = authService;
+    }
+    static CONTENT_TYPE = 'Content-Type';
+    static JSON = 'json';
+    error;
+    static convertToHttpError(error) {
+        if (error instanceof HttpError) {
+            return error;
+        }
+        let httpError = new HttpError();
+        if (error instanceof HttpErrorResponse) {
+            if (error.headers?.get(HttpErrorService.CONTENT_TYPE).indexOf(HttpErrorService.JSON) !== -1) {
+                try {
+                    httpError = HttpError.from(error);
+                }
+                catch (e) {
+                    console.error(e, e.message);
+                }
+            }
+            if (!httpError.status) {
+                httpError.status = error.status;
+            }
+        }
+        else if (error) {
+            if (error.message) {
+                httpError.message = error.message;
+            }
+            if (error.status) {
+                httpError.status = error.status;
+            }
+        }
+        return httpError;
+    }
+    setError(error) {
+        this.error = error;
+    }
+    removeError() {
+        const error = this.error;
+        this.error = null;
+        return error;
+    }
+    handle(error, redirectIfNotAuthorised = true) {
+        console.error('Handling error in http error service.');
+        console.error(error);
+        const httpError = HttpErrorService.convertToHttpError(error);
+        if (redirectIfNotAuthorised && httpError.status === 401) {
+            this.authService.signIn();
+        }
+        return throwError(httpError);
+    }
+    static ɵfac = function HttpErrorService_Factory(t) { return new (t || HttpErrorService)(i0.ɵɵinject(i1.AuthService)); };
+    static ɵprov = /*@__PURE__*/ i0.ɵɵdefineInjectable({ token: HttpErrorService, factory: HttpErrorService.ɵfac });
+}
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(HttpErrorService, [{
+        type: Injectable
+    }], () => [{ type: i1.AuthService }], null); })();
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,95 @@
+import { HttpClient, HttpHeaders } from '@angular/common/http';
+import { Injectable } from '@angular/core';
+import { catchError } from 'rxjs/operators';
+import { HttpErrorService } from './http-error.service';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common/http";
+import * as i2 from "./http-error.service";
+export class HttpService {
+    httpclient;
+    httpErrorService;
+    static HEADER_ACCEPT = 'Accept';
+    static HEADER_CONTENT_TYPE = 'Content-Type';
+    constructor(httpclient, httpErrorService) {
+        this.httpclient = httpclient;
+        this.httpErrorService = httpErrorService;
+    }
+    /**
+     *
+     * @param url Url resolved using UrlResolverService
+     * @param options OptionsType
+     * @returns Observable<any> return value
+     * @see UrlResolverService
+     */
+    get(url, options, redirectIfNotAuthorised = true, errorHandler) {
+        return this.httpclient
+            .get(url, this.setDefaultValue(options))
+            .pipe(catchError((res) => {
+            let error = res;
+            if (typeof errorHandler === 'function') {
+                error = errorHandler(res);
+            }
+            return this.httpErrorService.handle(error, redirectIfNotAuthorised);
+        }));
+    }
+    /**
+     *
+     * @param url Url resolved using UrlResolverService
+     * @param body Body for post
+     * @param options OptionsType
+     * @returns Observable<any> return value
+     * @see UrlResolverService
+     */
+    post(url, body, options, redirectIfNotAuthorised = true) {
+        return this.httpclient
+            .post(url, body, this.setDefaultValue(options))
+            .pipe(catchError((res) => {
+            return this.httpErrorService.handle(res, redirectIfNotAuthorised);
+        }));
+    }
+    /**
+     *
+     * @param url Url resolved using UrlResolverService
+     * @param body Body for post
+     * @param options OptionsType
+     * @returns Observable<any> return value
+     * @see UrlResolverService
+     */
+    put(url, body, options) {
+        return this.httpclient
+            .put(url, body, this.setDefaultValue(options))
+            .pipe(catchError((res) => {
+            return this.httpErrorService.handle(res);
+        }));
+    }
+    /**
+     *
+     * @param url Url resolved using UrlResolverService
+     * @param options OptionsType
+     * @returns Observable<any> return value
+     * @see UrlResolverService
+     */
+    delete(url, options) {
+        return this.httpclient
+            .delete(url, this.setDefaultValue(options))
+            .pipe(catchError((res) => {
+            return this.httpErrorService.handle(res);
+        }));
+    }
+    setDefaultValue(options) {
+        options = options || { observe: 'body' };
+        options.withCredentials = true;
+        if (!options.headers) {
+            options.headers = new HttpHeaders()
+                .set(HttpService.HEADER_ACCEPT, 'application/json')
+                .set(HttpService.HEADER_CONTENT_TYPE, 'application/json');
+        }
+        return options;
+    }
+    static ɵfac = function HttpService_Factory(t) { return new (t || HttpService)(i0.ɵɵinject(i1.HttpClient), i0.ɵɵinject(i2.HttpErrorService)); };
+    static ɵprov = /*@__PURE__*/ i0.ɵɵdefineInjectable({ token: HttpService, factory: HttpService.ɵfac });
+}
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(HttpService, [{
+        type: Injectable
+    }], () => [{ type: i1.HttpClient }, { type: i2.HttpErrorService }], null); })();
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,35 @@
+import { Injectable } from '@angular/core';
+import { BehaviorSubject, Subject } from 'rxjs';
+import { HttpService } from '../http';
+import * as i0 from "@angular/core";
+import * as i1 from "../http";
+export class JurisdictionService {
+    httpService;
+    // We retain the Subject observable because subscribing code couldn't happen a null value
+    selectedJurisdictionSource = new Subject();
+    selectedJurisdictionBS = new BehaviorSubject(null);
+    selectedJurisdiction;
+    constructor(httpService) {
+        this.httpService = httpService;
+        this.selectedJurisdiction = this.selectedJurisdictionSource.asObservable();
+    }
+    getJurisdictions() {
+        return this.httpService.get('/aggregated/caseworkers/:uid/jurisdictions?access=read');
+    }
+    announceSelectedJurisdiction(jurisdiction) {
+        this.selectedJurisdictionSource.next(jurisdiction);
+        this.selectedJurisdictionBS.next(jurisdiction);
+    }
+    searchJudicialUsers(searchTerm, serviceId) {
+        return this.httpService.post('api/prd/judicial/getJudicialUsersSearch', { searchString: searchTerm, serviceCode: serviceId });
+    }
+    searchJudicialUsersByPersonalCodes(personalCodes) {
+        return this.httpService.post('api/prd/judicial/searchJudicialUserByPersonalCodes', { personal_code: personalCodes });
+    }
+    static ɵfac = function JurisdictionService_Factory(t) { return new (t || JurisdictionService)(i0.ɵɵinject(i1.HttpService)); };
+    static ɵprov = /*@__PURE__*/ i0.ɵɵdefineInjectable({ token: JurisdictionService, factory: JurisdictionService.ɵfac });
+}
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(JurisdictionService, [{
+        type: Injectable
+    }], () => [{ type: i1.HttpService }], null); })();
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/shared/services/loading/loading.module.mjs

@@ -0,0 +1,22 @@
+import { NgModule } from '@angular/core';
+import { LoadingService } from './loading.service';
+import * as i0 from "@angular/core";
+export class LoadingModule {
+    static ɵfac = function LoadingModule_Factory(t) { return new (t || LoadingModule)(); };
+    static ɵmod = /*@__PURE__*/ i0.ɵɵdefineNgModule({ type: LoadingModule });
+    static ɵinj = /*@__PURE__*/ i0.ɵɵdefineInjector({ providers: [
+            LoadingService
+        ] });
+}
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(LoadingModule, [{
+        type: NgModule,
+        args: [{
+                imports: [],
+                declarations: [],
+                exports: [],
+                providers: [
+                    LoadingService
+                ]
+            }]
+    }], null, null); })();
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibG9hZGluZy5tb2R1bGUuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9jY2QtY2FzZS11aS10b29sa2l0L3NyYy9saWIvc2hhcmVkL3NlcnZpY2VzL2xvYWRpbmcvbG9hZGluZy5tb2R1bGUudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLFFBQVEsRUFBRSxNQUFNLGVBQWUsQ0FBQztBQUN6QyxPQUFPLEVBQUUsY0FBYyxFQUFFLE1BQU0sbUJBQW1CLENBQUM7O0FBY25ELE1BQU0sT0FBTyxhQUFhO3VFQUFiLGFBQWE7NERBQWIsYUFBYTtpRUFMWDtZQUNQLGNBQWM7U0FDakI7O2lGQUdRLGFBQWE7Y0FaekIsUUFBUTtlQUFDO2dCQUNOLE9BQU8sRUFBRSxFQUNSO2dCQUNELFlBQVksRUFBRSxFQUNiO2dCQUNELE9BQU8sRUFBRSxFQUNSO2dCQUNELFNBQVMsRUFBRTtvQkFDUCxjQUFjO2lCQUNqQjthQUNKIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgTmdNb2R1bGUgfSBmcm9tICdAYW5ndWxhci9jb3JlJztcbmltcG9ydCB7IExvYWRpbmdTZXJ2aWNlIH0gZnJvbSAnLi9sb2FkaW5nLnNlcnZpY2UnO1xuXG5ATmdNb2R1bGUoe1xuICAgIGltcG9ydHM6IFtcbiAgICBdLFxuICAgIGRlY2xhcmF0aW9uczogW1xuICAgIF0sXG4gICAgZXhwb3J0czogW1xuICAgIF0sXG4gICAgcHJvdmlkZXJzOiBbXG4gICAgICAgIExvYWRpbmdTZXJ2aWNlXG4gICAgXVxufSlcblxuZXhwb3J0IGNsYXNzIExvYWRpbmdNb2R1bGUge31cbiJdfQ==

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

@@ -0,0 +1,31 @@
+import { Injectable } from '@angular/core';
+import { BehaviorSubject } from 'rxjs';
+import { distinctUntilChanged } from 'rxjs/operators';
+import * as i0 from "@angular/core";
+export class LoadingService {
+    registered = new Map();
+    loading = new BehaviorSubject(false);
+    get isLoading() {
+        return this.loading.pipe(distinctUntilChanged());
+    }
+    register() {
+        const token = this.generateToken();
+        this.registered.set(token, token);
+        this.loading.next(true);
+        return token;
+    }
+    unregister(token) {
+        this.registered.delete(token);
+        this.loading.next(this.registered.size > 0);
+    }
+    generateToken() {
+        const timestamp = window.performance.now();
+        return `toolkit-loading-${timestamp}`; // format: [source-library]-[unique incrementing number]
+    }
+    static ɵfac = function LoadingService_Factory(t) { return new (t || LoadingService)(); };
+    static ɵprov = /*@__PURE__*/ i0.ɵɵdefineInjectable({ token: LoadingService, factory: LoadingService.ɵfac });
+}
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(LoadingService, [{
+        type: Injectable
+    }], null, null); })();
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/shared/services/navigation/navigation-notifier.service.mjs

@@ -0,0 +1,16 @@
+import { Injectable } from '@angular/core';
+import { BehaviorSubject } from 'rxjs';
+import * as i0 from "@angular/core";
+export class NavigationNotifierService {
+    navigationSource = new BehaviorSubject({});
+    navigation = this.navigationSource.asObservable();
+    announceNavigation(origin) {
+        this.navigationSource.next(origin);
+    }
+    static ɵfac = function NavigationNotifierService_Factory(t) { return new (t || NavigationNotifierService)(); };
+    static ɵprov = /*@__PURE__*/ i0.ɵɵdefineInjectable({ token: NavigationNotifierService, factory: NavigationNotifierService.ɵfac });
+}
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(NavigationNotifierService, [{
+        type: Injectable
+    }], null, null); })();
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibmF2aWdhdGlvbi1ub3RpZmllci5zZXJ2aWNlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vLi4vcHJvamVjdHMvY2NkLWNhc2UtdWktdG9vbGtpdC9zcmMvbGliL3NoYXJlZC9zZXJ2aWNlcy9uYXZpZ2F0aW9uL25hdmlnYXRpb24tbm90aWZpZXIuc2VydmljZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsVUFBVSxFQUFFLE1BQU0sZUFBZSxDQUFDO0FBQzNDLE9BQU8sRUFBRSxlQUFlLEVBQUUsTUFBTSxNQUFNLENBQUM7O0FBR3ZDLE1BQU0sT0FBTyx5QkFBeUI7SUFDN0IsZ0JBQWdCLEdBQXlCLElBQUksZUFBZSxDQUFNLEVBQUUsQ0FBQyxDQUFDO0lBQ3RFLFVBQVUsR0FBRyxJQUFJLENBQUMsZ0JBQWdCLENBQUMsWUFBWSxFQUFFLENBQUM7SUFFbEQsa0JBQWtCLENBQUMsTUFBVztRQUNuQyxJQUFJLENBQUMsZ0JBQWdCLENBQUMsSUFBSSxDQUFDLE1BQU0sQ0FBQyxDQUFDO0lBQ3JDLENBQUM7bUZBTlUseUJBQXlCO2dFQUF6Qix5QkFBeUIsV0FBekIseUJBQXlCOztpRkFBekIseUJBQXlCO2NBRHJDLFVBQVUiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBJbmplY3RhYmxlIH0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XG5pbXBvcnQgeyBCZWhhdmlvclN1YmplY3QgfSBmcm9tICdyeGpzJztcblxuQEluamVjdGFibGUoKVxuZXhwb3J0IGNsYXNzIE5hdmlnYXRpb25Ob3RpZmllclNlcnZpY2Uge1xuICBwdWJsaWMgbmF2aWdhdGlvblNvdXJjZTogQmVoYXZpb3JTdWJqZWN0PGFueT4gPSBuZXcgQmVoYXZpb3JTdWJqZWN0PGFueT4oe30pO1xuICBwdWJsaWMgbmF2aWdhdGlvbiA9IHRoaXMubmF2aWdhdGlvblNvdXJjZS5hc09ic2VydmFibGUoKTtcblxuICBwdWJsaWMgYW5ub3VuY2VOYXZpZ2F0aW9uKG9yaWdpbjogYW55KSB7XG4gICAgdGhpcy5uYXZpZ2F0aW9uU291cmNlLm5leHQob3JpZ2luKTtcbiAgfVxufVxuIl19

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

@@ -0,0 +1,37 @@
+import { Injectable } from '@angular/core';
+import * as i0 from "@angular/core";
+// @dynamic
+export class OrderService {
+    /**
+     * Use `sort` function instead or `compareAsc`
+     */
+    static DEFAULT_COMPARE_FUNCTION = (a, b) => {
+        const aOrdered = a.order === 0 || a.order;
+        const bOrdered = b.order === 0 || b.order;
+        if (!aOrdered) {
+            return !bOrdered ? 0 : 1;
+        }
+        if (!bOrdered) {
+            return -1;
+        }
+        return a.order - b.order;
+    };
+    sortAsc = OrderService.DEFAULT_COMPARE_FUNCTION;
+    /**
+     * Clone and sort array. Ascending order used by default.
+     *
+     * @param array Array to sort
+     * @returns Orderable[] Sorted clone array.
+     */
+    sort(array, sortingFunction = this.sortAsc) {
+        return array
+            .slice()
+            .sort(sortingFunction);
+    }
+    static ɵfac = function OrderService_Factory(t) { return new (t || OrderService)(); };
+    static ɵprov = /*@__PURE__*/ i0.ɵɵdefineInjectable({ token: OrderService, factory: OrderService.ɵfac });
+}
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(OrderService, [{
+        type: Injectable
+    }], null, null); })();
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,57 @@
+import { HttpClient } from '@angular/common/http';
+import { Injectable } from '@angular/core';
+import { of } from 'rxjs';
+import { catchError, map, publishReplay, refCount, take } from 'rxjs/operators';
+import { AbstractAppConfig } from '../../../app.config';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common/http";
+import * as i2 from "../../../app.config";
+export class OrganisationService {
+    http;
+    appconfig;
+    constructor(http, appconfig) {
+        this.http = http;
+        this.appconfig = appconfig;
+    }
+    organisations$;
+    static mapOrganisation(organisations) {
+        const organisationsVm = new Array();
+        organisations.forEach(org => {
+            let contactInformation = null;
+            if (org.contactInformation && org.contactInformation[0]) {
+                contactInformation = org.contactInformation[0];
+            }
+            organisationsVm.push({
+                organisationIdentifier: org.organisationIdentifier,
+                name: org.name,
+                addressLine1: contactInformation !== null ? contactInformation.addressLine1 : null,
+                addressLine2: contactInformation !== null ? contactInformation.addressLine2 : null,
+                addressLine3: contactInformation !== null ? contactInformation.addressLine3 : null,
+                townCity: contactInformation !== null ? contactInformation.townCity : null,
+                county: contactInformation !== null ? contactInformation.county : null,
+                country: contactInformation !== null ? contactInformation.country : null,
+                postCode: contactInformation !== null ? contactInformation.postCode : null,
+            });
+        });
+        return organisationsVm;
+    }
+    getActiveOrganisations() {
+        if (!this.organisations$) {
+            const url = this.appconfig.getPrdUrl();
+            const cacheTimeOut = this.appconfig.getCacheTimeOut();
+            this.organisations$ = this.http.get(url)
+                .pipe(map((orgs) => OrganisationService.mapOrganisation(orgs)), publishReplay(1, cacheTimeOut), refCount(), take(1), catchError(e => {
+                console.log(e);
+                // Handle error and return blank Observable array
+                return of([]);
+            }));
+        }
+        return this.organisations$;
+    }
+    static ɵfac = function OrganisationService_Factory(t) { return new (t || OrganisationService)(i0.ɵɵinject(i1.HttpClient), i0.ɵɵinject(i2.AbstractAppConfig)); };
+    static ɵprov = /*@__PURE__*/ i0.ɵɵdefineInjectable({ token: OrganisationService, factory: OrganisationService.ɵfac });
+}
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(OrganisationService, [{
+        type: Injectable
+    }], () => [{ type: i1.HttpClient }, { type: i2.AbstractAppConfig }], null); })();
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/shared/services/profile/profile.notifier.mjs

@@ -0,0 +1,17 @@
+import { Injectable } from '@angular/core';
+import { BehaviorSubject } from 'rxjs';
+import { Profile } from '../../domain/profile/profile.model';
+import * as i0 from "@angular/core";
+export class ProfileNotifier {
+    profileSource = new BehaviorSubject(new Profile());
+    profile = this.profileSource.asObservable();
+    announceProfile(profile) {
+        this.profileSource.next(profile);
+    }
+    static ɵfac = function ProfileNotifier_Factory(t) { return new (t || ProfileNotifier)(); };
+    static ɵprov = /*@__PURE__*/ i0.ɵɵdefineInjectable({ token: ProfileNotifier, factory: ProfileNotifier.ɵfac });
+}
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(ProfileNotifier, [{
+        type: Injectable
+    }], null, null); })();
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHJvZmlsZS5ub3RpZmllci5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL2NjZC1jYXNlLXVpLXRvb2xraXQvc3JjL2xpYi9zaGFyZWQvc2VydmljZXMvcHJvZmlsZS9wcm9maWxlLm5vdGlmaWVyLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxVQUFVLEVBQUUsTUFBTSxlQUFlLENBQUM7QUFDM0MsT0FBTyxFQUFFLGVBQWUsRUFBRSxNQUFNLE1BQU0sQ0FBQztBQUN2QyxPQUFPLEVBQUUsT0FBTyxFQUFFLE1BQU0sb0NBQW9DLENBQUM7O0FBRzdELE1BQU0sT0FBTyxlQUFlO0lBQ1YsYUFBYSxHQUE2QixJQUFJLGVBQWUsQ0FBVSxJQUFJLE9BQU8sRUFBRSxDQUFDLENBQUM7SUFDL0YsT0FBTyxHQUFHLElBQUksQ0FBQyxhQUFhLENBQUMsWUFBWSxFQUFFLENBQUM7SUFFNUMsZUFBZSxDQUFDLE9BQWdCO1FBQ3JDLElBQUksQ0FBQyxhQUFhLENBQUMsSUFBSSxDQUFDLE9BQU8sQ0FBQyxDQUFDO0lBQ25DLENBQUM7eUVBTlUsZUFBZTtnRUFBZixlQUFlLFdBQWYsZUFBZTs7aUZBQWYsZUFBZTtjQUQzQixVQUFVIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgSW5qZWN0YWJsZSB9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xuaW1wb3J0IHsgQmVoYXZpb3JTdWJqZWN0IH0gZnJvbSAncnhqcyc7XG5pbXBvcnQgeyBQcm9maWxlIH0gZnJvbSAnLi4vLi4vZG9tYWluL3Byb2ZpbGUvcHJvZmlsZS5tb2RlbCc7XG5cbkBJbmplY3RhYmxlKClcbmV4cG9ydCBjbGFzcyBQcm9maWxlTm90aWZpZXIge1xuICBwdWJsaWMgcmVhZG9ubHkgcHJvZmlsZVNvdXJjZTogQmVoYXZpb3JTdWJqZWN0PFByb2ZpbGU+ID0gbmV3IEJlaGF2aW9yU3ViamVjdDxQcm9maWxlPihuZXcgUHJvZmlsZSgpKTtcbiAgcHVibGljIHByb2ZpbGUgPSB0aGlzLnByb2ZpbGVTb3VyY2UuYXNPYnNlcnZhYmxlKCk7XG5cbiAgcHVibGljIGFubm91bmNlUHJvZmlsZShwcm9maWxlOiBQcm9maWxlKSB7XG4gICAgdGhpcy5wcm9maWxlU291cmNlLm5leHQocHJvZmlsZSk7XG4gIH1cblxufVxuIl19

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

@@ -0,0 +1,36 @@
+import { HttpHeaders } from '@angular/common/http';
+import { Injectable } from '@angular/core';
+import { plainToClass } from 'class-transformer';
+import { map } from 'rxjs/operators';
+import { AbstractAppConfig } from '../../../app.config';
+import { Profile } from '../../domain/profile/profile.model';
+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 ProfileService {
+    httpService;
+    appConfig;
+    static V2_MEDIATYPE_USER_PROFILE = 'application/vnd.uk.gov.hmcts.ccd-data-store-api.ui-user-profile.v2+json;charset=UTF-8';
+    static URL = '/internal/profile';
+    constructor(httpService, appConfig) {
+        this.httpService = httpService;
+        this.appConfig = appConfig;
+    }
+    get() {
+        const url = this.appConfig.getCaseDataUrl() + ProfileService.URL;
+        const headers = new HttpHeaders()
+            .set('experimental', 'true')
+            .set('Accept', ProfileService.V2_MEDIATYPE_USER_PROFILE)
+            .set('Content-Type', 'application/json');
+        return this.httpService
+            .get(url, { headers, observe: 'body' })
+            .pipe(map((p) => plainToClass(Profile, p)));
+    }
+    static ɵfac = function ProfileService_Factory(t) { return new (t || ProfileService)(i0.ɵɵinject(i1.HttpService), i0.ɵɵinject(i2.AbstractAppConfig)); };
+    static ɵprov = /*@__PURE__*/ i0.ɵɵdefineInjectable({ token: ProfileService, factory: ProfileService.ɵfac });
+}
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(ProfileService, [{
+        type: Injectable
+    }], () => [{ type: i1.HttpService }, { type: i2.AbstractAppConfig }], null); })();
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/shared/services/request/request.options.builder.mjs

@@ -0,0 +1,61 @@
+import { HttpParams } from '@angular/common/http';
+import { Injectable } from '@angular/core';
+import * as i0 from "@angular/core";
+export class RequestOptionsBuilder {
+    static FIELD_PREFIX = 'case.';
+    /**
+     * Assess the value to see if it should be included in the request options.
+     * If it's null or an "empty" string, it shouldn't be.
+     *
+     * @param value The value to be assessed.
+     */
+    static includeParam(value) {
+        /* istanbul ignore else */
+        if (value) {
+            /* istanbul ignore else */
+            if (typeof (value) === 'string') {
+                return value.trim().length > 0;
+            }
+            return true;
+        }
+        return false;
+    }
+    buildOptions(metaCriteria, caseCriteria, view) {
+        // TODO: This should probably be the now built-in URLSearchParams but it
+        // requires a bigger refactor and there are bigger fish to fry right now.
+        let params = new HttpParams();
+        /* istanbul ignore else */
+        if (view) {
+            params = params.set('view', view);
+        }
+        /* istanbul ignore else */
+        if (metaCriteria) {
+            for (const criterion of Object.keys(metaCriteria)) {
+                // EUI-3490. Make sure the parameter should be included for adding it.
+                // This was already handled by the old URLSearchParams mechanism.
+                if (RequestOptionsBuilder.includeParam(metaCriteria[criterion])) {
+                    params = params.set(criterion, metaCriteria[criterion]);
+                }
+            }
+        }
+        /* istanbul ignore else */
+        if (caseCriteria) {
+            for (const criterion of Object.keys(caseCriteria)) {
+                /* istanbul ignore else */
+                if (RequestOptionsBuilder.includeParam(caseCriteria[criterion])) {
+                    const key = RequestOptionsBuilder.FIELD_PREFIX + criterion;
+                    const value = caseCriteria[criterion].trim ? caseCriteria[criterion].trim() : caseCriteria[criterion];
+                    params = params.set(key, value.replace(/’/i, `'`));
+                }
+            }
+        }
+        const options = { params, observe: 'body' };
+        return options;
+    }
+    static ɵfac = function RequestOptionsBuilder_Factory(t) { return new (t || RequestOptionsBuilder)(); };
+    static ɵprov = /*@__PURE__*/ i0.ɵɵdefineInjectable({ token: RequestOptionsBuilder, factory: RequestOptionsBuilder.ɵfac });
+}
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(RequestOptionsBuilder, [{
+        type: Injectable
+    }], null, null); })();
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/shared/services/router/router-helper.service.mjs

@@ -0,0 +1,20 @@
+import { Injectable } from '@angular/core';
+import * as i0 from "@angular/core";
+export class RouterHelperService {
+    getUrlSegmentsFromRoot(route) {
+        return route.pathFromRoot
+            .filter(r => r.url && r.url.length)
+            .reduce((acc, r) => {
+            r.url.forEach(url => {
+                acc.push(url.path);
+            });
+            return acc;
+        }, []);
+    }
+    static ɵfac = function RouterHelperService_Factory(t) { return new (t || RouterHelperService)(); };
+    static ɵprov = /*@__PURE__*/ i0.ɵɵdefineInjectable({ token: RouterHelperService, factory: RouterHelperService.ɵfac });
+}
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(RouterHelperService, [{
+        type: Injectable
+    }], null, null); })();
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicm91dGVyLWhlbHBlci5zZXJ2aWNlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vLi4vcHJvamVjdHMvY2NkLWNhc2UtdWktdG9vbGtpdC9zcmMvbGliL3NoYXJlZC9zZXJ2aWNlcy9yb3V0ZXIvcm91dGVyLWhlbHBlci5zZXJ2aWNlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxVQUFVLEVBQUUsTUFBTSxlQUFlLENBQUM7O0FBSTNDLE1BQU0sT0FBTyxtQkFBbUI7SUFDdkIsc0JBQXNCLENBQUMsS0FBNkI7UUFDekQsT0FBTyxLQUFLLENBQUMsWUFBWTthQUN0QixNQUFNLENBQUMsQ0FBQyxDQUFDLEVBQUUsQ0FBQyxDQUFDLENBQUMsR0FBRyxJQUFJLENBQUMsQ0FBQyxHQUFHLENBQUMsTUFBTSxDQUFDO2FBQ2xDLE1BQU0sQ0FBQyxDQUFDLEdBQUcsRUFBRSxDQUFDLEVBQUUsRUFBRTtZQUNqQixDQUFDLENBQUMsR0FBRyxDQUFDLE9BQU8sQ0FBQyxHQUFHLENBQUMsRUFBRTtnQkFDbEIsR0FBRyxDQUFDLElBQUksQ0FBQyxHQUFHLENBQUMsSUFBSSxDQUFDLENBQUM7WUFDckIsQ0FBQyxDQUFDLENBQUM7WUFDSCxPQUFPLEdBQUcsQ0FBQztRQUNiLENBQUMsRUFBRSxFQUFFLENBQUMsQ0FBQztJQUNYLENBQUM7NkVBVlUsbUJBQW1CO2dFQUFuQixtQkFBbUIsV0FBbkIsbUJBQW1COztpRkFBbkIsbUJBQW1CO2NBRC9CLFVBQVUiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBJbmplY3RhYmxlIH0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XG5pbXBvcnQgeyBBY3RpdmF0ZWRSb3V0ZVNuYXBzaG90IH0gZnJvbSAnQGFuZ3VsYXIvcm91dGVyJztcblxuQEluamVjdGFibGUoKVxuZXhwb3J0IGNsYXNzIFJvdXRlckhlbHBlclNlcnZpY2Uge1xuICBwdWJsaWMgZ2V0VXJsU2VnbWVudHNGcm9tUm9vdChyb3V0ZTogQWN0aXZhdGVkUm91dGVTbmFwc2hvdCk6IHN0cmluZ1tdIHtcbiAgICByZXR1cm4gcm91dGUucGF0aEZyb21Sb290XG4gICAgICAuZmlsdGVyKHIgPT4gci51cmwgJiYgci51cmwubGVuZ3RoKVxuICAgICAgLnJlZHVjZSgoYWNjLCByKSA9PiB7XG4gICAgICAgIHIudXJsLmZvckVhY2godXJsID0+IHtcbiAgICAgICAgICBhY2MucHVzaCh1cmwucGF0aCk7XG4gICAgICAgIH0pO1xuICAgICAgICByZXR1cm4gYWNjO1xuICAgICAgfSwgW10pO1xuICB9XG59XG4iXX0=