@hmcts/ccd-case-ui-toolkit 7.0.34-angular-upgrade → 7.0.34-cfv-sort-order-upload-date

package/esm2020/lib/shared/services/search/search.service.mjs

@@ -0,0 +1,89 @@
+import { HttpHeaders } from '@angular/common/http';
+import { Injectable } from '@angular/core';
+import { finalize, map } from 'rxjs/operators';
+import { AbstractAppConfig } from '../../../app.config';
+import { HttpService } from '../http/http.service';
+import { LoadingService } from '../loading/loading.service';
+import { RequestOptionsBuilder } from '../request/request.options.builder';
+import * as i0 from "@angular/core";
+import * as i1 from "../../../app.config";
+import * as i2 from "../http/http.service";
+import * as i3 from "../request/request.options.builder";
+import * as i4 from "../loading/loading.service";
+export class SearchService {
+    constructor(appConfig, httpService, requestOptionsBuilder, loadingService) {
+        this.appConfig = appConfig;
+        this.httpService = httpService;
+        this.requestOptionsBuilder = requestOptionsBuilder;
+        this.loadingService = loadingService;
+    }
+    search(jurisdictionId, caseTypeId, metaCriteria, caseCriteria, view) {
+        const url = `${this.appConfig.getApiUrl()}/caseworkers/:uid/jurisdictions/${jurisdictionId}/case-types/${caseTypeId}/cases`;
+        const options = this.requestOptionsBuilder.buildOptions(metaCriteria, caseCriteria, view);
+        const loadingToken = this.loadingService.register();
+        return this.httpService
+            .get(url, options)
+            .pipe(map(response => response), finalize(() => this.loadingService.unregister(loadingToken)));
+    }
+    searchCasesByIds(caseTypeId, filter, view, sort) {
+        const url = `${this.appConfig.getCaseDataUrl()}/internal/searchCases?ctid=${caseTypeId}&use_case=${view}`;
+        const body = {
+            sort,
+            ...filter,
+            size: this.appConfig.getPaginationPageSize(),
+        };
+        const loadingToken = this.loadingService.register();
+        return this.httpService.post(url, body).pipe(map((response) => response), finalize(() => this.loadingService.unregister(loadingToken)));
+    }
+    searchCases(caseTypeId, metaCriteria, caseCriteria, view, sort) {
+        const url = `${this.appConfig.getCaseDataUrl()}/internal/searchCases?ctid=${caseTypeId}&use_case=${view}`;
+        const options = this.requestOptionsBuilder.buildOptions(metaCriteria, caseCriteria, view);
+        const body = {
+            sort,
+            size: this.appConfig.getPaginationPageSize()
+        };
+        const loadingToken = this.loadingService.register();
+        return this.httpService
+            .post(url, body, options)
+            .pipe(map(response => response), finalize(() => this.loadingService.unregister(loadingToken)));
+    }
+    getSearchInputUrl(caseTypeId) {
+        return `${this.appConfig.getCaseDataUrl()}/internal/case-types/${caseTypeId}/search-inputs`;
+    }
+    getSearchInputs(jurisdictionId, caseTypeId) {
+        const url = this.getSearchInputUrl(caseTypeId);
+        const headers = new HttpHeaders()
+            .set('experimental', 'true')
+            .set('Accept', SearchService.V2_MEDIATYPE_SEARCH_INPUTS)
+            .set('Content-Type', 'application/json');
+        this.currentJurisdiction = jurisdictionId;
+        this.currentCaseType = caseTypeId;
+        return this.httpService
+            .get(url, { headers, observe: 'body' })
+            .pipe(map(body => {
+            const searchInputs = body.searchInputs;
+            if (this.isDataValid(jurisdictionId, caseTypeId)) {
+                searchInputs.forEach(item => {
+                    item.field.label = item.label;
+                    item.field.display_context_parameter = item.display_context_parameter;
+                });
+            }
+            else {
+                throw new Error('Response expired');
+            }
+            return searchInputs;
+        }));
+    }
+    isDataValid(jurisdictionId, caseTypeId) {
+        return this.currentJurisdiction === jurisdictionId && this.currentCaseType === caseTypeId;
+    }
+}
+SearchService.V2_MEDIATYPE_SEARCH_INPUTS = 'application/vnd.uk.gov.hmcts.ccd-data-store-api.ui-search-input-details.v2+json;charset=UTF-8';
+// public static readonly VIEW_SEARCH = 'SEARCH';
+SearchService.VIEW_WORKBASKET = 'WORKBASKET';
+SearchService.ɵfac = function SearchService_Factory(t) { return new (t || SearchService)(i0.ɵɵinject(i1.AbstractAppConfig), i0.ɵɵinject(i2.HttpService), i0.ɵɵinject(i3.RequestOptionsBuilder), i0.ɵɵinject(i4.LoadingService)); };
+SearchService.ɵprov = /*@__PURE__*/ i0.ɵɵdefineInjectable({ token: SearchService, factory: SearchService.ɵfac });
+(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(SearchService, [{
+        type: Injectable
+    }], function () { return [{ type: i1.AbstractAppConfig }, { type: i2.HttpService }, { type: i3.RequestOptionsBuilder }, { type: i4.LoadingService }]; }, null); })();
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"search.service.js","sourceRoot":"","sources":["../../../../../../../projects/ccd-case-ui-toolkit/src/lib/shared/services/search/search.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { HttpHeaders } from '@angular/common/http';\nimport { Injectable } from '@angular/core';\nimport { Observable } from 'rxjs';\nimport { finalize, map } from 'rxjs/operators';\nimport { AbstractAppConfig } from '../../../app.config';\nimport { SearchInput } from '../../components/search-filters';\nimport { SearchResultView } from '../../domain/search/search-result-view.model';\nimport { HttpService, OptionsType } from '../http/http.service';\nimport { LoadingService } from '../loading/loading.service';\nimport { RequestOptionsBuilder, SearchView } from '../request/request.options.builder';\n\n@Injectable()\nexport class SearchService {\n  public static readonly V2_MEDIATYPE_SEARCH_INPUTS =\n    'application/vnd.uk.gov.hmcts.ccd-data-store-api.ui-search-input-details.v2+json;charset=UTF-8';\n  // public static readonly VIEW_SEARCH = 'SEARCH';\n  public static readonly VIEW_WORKBASKET = 'WORKBASKET';\n  // public static readonly FIELD_PREFIX = 'case.';\n  private currentJurisdiction: string;\n  private currentCaseType: string;\n\n  constructor(private readonly appConfig: AbstractAppConfig,\n              private readonly httpService: HttpService,\n              private readonly requestOptionsBuilder: RequestOptionsBuilder,\n              private readonly loadingService: LoadingService) { }\n\n  public search(jurisdictionId: string,\n                caseTypeId: string,\n                metaCriteria: object,\n                caseCriteria: object,\n                view?: SearchView): Observable<SearchResultView> {\n    const url = `${this.appConfig.getApiUrl()}/caseworkers/:uid/jurisdictions/${jurisdictionId}/case-types/${caseTypeId}/cases`;\n\n    const options: OptionsType  = this.requestOptionsBuilder.buildOptions(metaCriteria, caseCriteria, view);\n    const loadingToken = this.loadingService.register();\n    return this.httpService\n      .get(url, options)\n      .pipe(\n        map(response => response),\n        finalize(() => this.loadingService.unregister(loadingToken))\n      );\n  }\n\n  public searchCasesByIds(caseTypeId: string,\n                          filter: any,\n                          view?: SearchView,\n                          sort?: { column: string; order: number }): Observable<{}> {\n    const url =\n      `${this.appConfig.getCaseDataUrl()}/internal/searchCases?ctid=${caseTypeId}&use_case=${view}`;\n\n    const body: {} = {\n      sort,\n      ...filter,\n      size: this.appConfig.getPaginationPageSize(),\n    };\n    const loadingToken = this.loadingService.register();\n    return this.httpService.post(url, body).pipe(\n      map((response) => response),\n      finalize(() => this.loadingService.unregister(loadingToken))\n    );\n  }\n\n  public searchCases(caseTypeId: string,\n                     metaCriteria: object,\n                     caseCriteria: object,\n                     view?: SearchView,\n                     sort?: {column: string, order: number}): Observable<{}> {\n    const url = `${this.appConfig.getCaseDataUrl()}/internal/searchCases?ctid=${caseTypeId}&use_case=${view}`;\n\n    const options: OptionsType = this.requestOptionsBuilder.buildOptions(metaCriteria, caseCriteria, view);\n    const body: {} = {\n      sort,\n      size: this.appConfig.getPaginationPageSize()\n    };\n    const loadingToken = this.loadingService.register();\n    return this.httpService\n      .post(url, body, options)\n      .pipe(\n        map(response => response),\n        finalize(() => this.loadingService.unregister(loadingToken))\n      );\n  }\n\n  public getSearchInputUrl(caseTypeId: string): string {\n    return `${this.appConfig.getCaseDataUrl()}/internal/case-types/${caseTypeId}/search-inputs`;\n  }\n\n  public getSearchInputs(jurisdictionId: string, caseTypeId: string): Observable<SearchInput[]> {\n    const url = this.getSearchInputUrl(caseTypeId);\n    const headers = new HttpHeaders()\n      .set('experimental', 'true')\n      .set('Accept', SearchService.V2_MEDIATYPE_SEARCH_INPUTS)\n      .set('Content-Type', 'application/json');\n    this.currentJurisdiction = jurisdictionId;\n    this.currentCaseType = caseTypeId;\n    return this.httpService\n      .get(url, { headers, observe: 'body' })\n      .pipe(\n        map(body => {\n          const searchInputs = body.searchInputs;\n          if (this.isDataValid(jurisdictionId, caseTypeId)) {\n            searchInputs.forEach(item => {\n              item.field.label = item.label;\n              item.field.display_context_parameter = item.display_context_parameter;\n            });\n          } else {\n            throw new Error('Response expired');\n          }\n          return searchInputs;\n        })\n      );\n  }\n\n  public isDataValid(jurisdictionId: string, caseTypeId: string): boolean {\n    return this.currentJurisdiction === jurisdictionId && this.currentCaseType === caseTypeId;\n  }\n}\n"]}

package/esm2020/lib/shared/services/search-result/sorting/search-result-view-item-comparator-factory.mjs

@@ -0,0 +1,71 @@
+import { Injectable } from '@angular/core';
+import { isUndefined } from 'util';
+import * as i0 from "@angular/core";
+export class SearchResultViewItemComparatorFactory {
+    createSearchResultViewItemComparator(column) {
+        const fieldId = column.case_field_id;
+        switch (column.case_field_type.type) {
+            case ('MultiSelectList'): {
+                return this.textArrayComparator(fieldId);
+            }
+            case ('Number'):
+            case ('MoneyGBP'): {
+                return this.numberComparator(fieldId);
+            }
+            case ('Text'):
+            case ('TextArea'):
+            case ('Email'):
+            case ('Date'):
+            case ('DateTime'):
+            case ('Label'):
+            case ('Postcode'):
+            case ('YesOrNo'):
+            case ('PhoneUK'):
+            case ('FixedList'): {
+                return this.stringComparator(fieldId);
+            }
+            default: {
+                return undefined;
+            }
+        }
+    }
+    numberComparator(fieldId) {
+        return {
+            compare(a, b) {
+                let fieldA = a.case_fields[fieldId];
+                let fieldB = b.case_fields[fieldId];
+                fieldA = isUndefined(fieldA) || fieldA === null ? 0 : fieldA;
+                fieldB = isUndefined(fieldB) || fieldB === null ? 0 : fieldB;
+                return fieldA - fieldB;
+            }
+        };
+    }
+    stringComparator(fieldId) {
+        return {
+            compare(a, b) {
+                let fieldA = a.case_fields[fieldId];
+                let fieldB = b.case_fields[fieldId];
+                fieldA = isUndefined(fieldA) || fieldA === null ? '' : fieldA.toLowerCase();
+                fieldB = isUndefined(fieldB) || fieldB === null ? '' : fieldB.toLowerCase();
+                return fieldA === fieldB ? 0 : fieldA > fieldB ? 1 : -1;
+            }
+        };
+    }
+    textArrayComparator(fieldId) {
+        return {
+            compare(a, b) {
+                let fieldA = a.case_fields[fieldId];
+                let fieldB = b.case_fields[fieldId];
+                fieldA = isUndefined(fieldA) || fieldA === null ? '' : fieldA.join().toLowerCase();
+                fieldB = isUndefined(fieldB) || fieldB === null ? '' : fieldB.join().toLowerCase();
+                return fieldA === fieldB ? 0 : fieldA > fieldB ? 1 : -1;
+            }
+        };
+    }
+}
+SearchResultViewItemComparatorFactory.ɵfac = function SearchResultViewItemComparatorFactory_Factory(t) { return new (t || SearchResultViewItemComparatorFactory)(); };
+SearchResultViewItemComparatorFactory.ɵprov = /*@__PURE__*/ i0.ɵɵdefineInjectable({ token: SearchResultViewItemComparatorFactory, factory: SearchResultViewItemComparatorFactory.ɵfac });
+(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(SearchResultViewItemComparatorFactory, [{
+        type: Injectable
+    }], null, null); })();
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/shared/services/session/session-storage.service.mjs

@@ -0,0 +1,34 @@
+import { Injectable } from '@angular/core';
+import * as i0 from "@angular/core";
+export class SessionStorageService {
+    /**
+     * Get an item from the session storage.
+     */
+    getItem(key) {
+        return sessionStorage.getItem(key);
+    }
+    /**
+     * Set an item in the session storage.
+     */
+    setItem(key, value) {
+        sessionStorage.setItem(key, value);
+    }
+    /**
+     * Remove an item from the session storage.
+     */
+    removeItem(key) {
+        sessionStorage.removeItem(key);
+    }
+    /**
+     * Clear all the items held in session storage.
+     */
+    clear() {
+        sessionStorage.clear();
+    }
+}
+SessionStorageService.ɵfac = function SessionStorageService_Factory(t) { return new (t || SessionStorageService)(); };
+SessionStorageService.ɵprov = /*@__PURE__*/ i0.ɵɵdefineInjectable({ token: SessionStorageService, factory: SessionStorageService.ɵfac });
+(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(SessionStorageService, [{
+        type: Injectable
+    }], null, null); })();
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic2Vzc2lvbi1zdG9yYWdlLnNlcnZpY2UuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9jY2QtY2FzZS11aS10b29sa2l0L3NyYy9saWIvc2hhcmVkL3NlcnZpY2VzL3Nlc3Npb24vc2Vzc2lvbi1zdG9yYWdlLnNlcnZpY2UudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLFVBQVUsRUFBRSxNQUFNLGVBQWUsQ0FBQzs7QUFHM0MsTUFBTSxPQUFPLHFCQUFxQjtJQUVoQzs7T0FFRztJQUNJLE9BQU8sQ0FBQyxHQUFXO1FBQ3hCLE9BQU8sY0FBYyxDQUFDLE9BQU8sQ0FBQyxHQUFHLENBQUMsQ0FBQztJQUNyQyxDQUFDO0lBRUQ7O09BRUc7SUFDSSxPQUFPLENBQUMsR0FBVyxFQUFFLEtBQWE7UUFDdkMsY0FBYyxDQUFDLE9BQU8sQ0FBQyxHQUFHLEVBQUUsS0FBSyxDQUFDLENBQUM7SUFDckMsQ0FBQztJQUVEOztPQUVHO0lBQ0ksVUFBVSxDQUFDLEdBQVc7UUFDM0IsY0FBYyxDQUFDLFVBQVUsQ0FBQyxHQUFHLENBQUMsQ0FBQztJQUNqQyxDQUFDO0lBRUQ7O09BRUc7SUFDSSxLQUFLO1FBQ1YsY0FBYyxDQUFDLEtBQUssRUFBRSxDQUFDO0lBQ3pCLENBQUM7OzBGQTVCVSxxQkFBcUI7MkVBQXJCLHFCQUFxQixXQUFyQixxQkFBcUI7dUZBQXJCLHFCQUFxQjtjQURqQyxVQUFVIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgSW5qZWN0YWJsZSB9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xuXG5ASW5qZWN0YWJsZSgpXG5leHBvcnQgY2xhc3MgU2Vzc2lvblN0b3JhZ2VTZXJ2aWNlIHtcblxuICAvKipcbiAgICogR2V0IGFuIGl0ZW0gZnJvbSB0aGUgc2Vzc2lvbiBzdG9yYWdlLlxuICAgKi9cbiAgcHVibGljIGdldEl0ZW0oa2V5OiBzdHJpbmcpOiBzdHJpbmcge1xuICAgIHJldHVybiBzZXNzaW9uU3RvcmFnZS5nZXRJdGVtKGtleSk7XG4gIH1cblxuICAvKipcbiAgICogU2V0IGFuIGl0ZW0gaW4gdGhlIHNlc3Npb24gc3RvcmFnZS5cbiAgICovXG4gIHB1YmxpYyBzZXRJdGVtKGtleTogc3RyaW5nLCB2YWx1ZTogc3RyaW5nKTogdm9pZCB7XG4gICAgc2Vzc2lvblN0b3JhZ2Uuc2V0SXRlbShrZXksIHZhbHVlKTtcbiAgfVxuXG4gIC8qKlxuICAgKiBSZW1vdmUgYW4gaXRlbSBmcm9tIHRoZSBzZXNzaW9uIHN0b3JhZ2UuXG4gICAqL1xuICBwdWJsaWMgcmVtb3ZlSXRlbShrZXk6IHN0cmluZyk6IHZvaWQge1xuICAgIHNlc3Npb25TdG9yYWdlLnJlbW92ZUl0ZW0oa2V5KTtcbiAgfVxuXG4gIC8qKlxuICAgKiBDbGVhciBhbGwgdGhlIGl0ZW1zIGhlbGQgaW4gc2Vzc2lvbiBzdG9yYWdlLlxuICAgKi9cbiAgcHVibGljIGNsZWFyKCk6IHZvaWQge1xuICAgIHNlc3Npb25TdG9yYWdlLmNsZWFyKCk7XG4gIH1cbn1cbiJdfQ==

package/esm2020/lib/shared/services/utils/retry/retry.service.mjs

@@ -0,0 +1,86 @@
+import { Injectable } from '@angular/core';
+import { timer } from 'rxjs';
+import { delayWhen, finalize, mergeMap, retryWhen, tap, timeout } from 'rxjs/operators';
+import * as i0 from "@angular/core";
+class ArtificialDelayContext {
+    constructor(preferredDelay) {
+        this.preferredDelay = preferredDelay;
+        this.artificialDelayOn = true;
+        this.selectedDelay = this.selectActualDelayTime();
+    }
+    switchArtificialDelays(status) {
+        this.artificialDelayOn = status;
+        this.selectedDelay = this.selectActualDelayTime();
+    }
+    turnOnArtificialDelays() {
+        this.switchArtificialDelays(true);
+    }
+    turnOffArtificialDelays() {
+        this.switchArtificialDelays(false);
+    }
+    getActualDelay() {
+        return this.artificialDelayOn ? this.selectedDelay : 0;
+    }
+    shouldApplyArtificialDelay() {
+        return this.preferredDelay > 0;
+    }
+    selectActualDelayTime() {
+        return Date.now() % 2 == 0 ? this.preferredDelay : 1;
+    }
+}
+export class RetryUtil {
+    pipeTimeoutMechanismOn(in$, preferredArtificialDelay, timeoutPeriods) {
+        const artificialDelayContext = new ArtificialDelayContext(preferredArtificialDelay);
+        console.info(`Piping a retry mechanism with timeouts {${timeoutPeriods}}.`);
+        console.info(`Artificial delay will be applied: ${artificialDelayContext.shouldApplyArtificialDelay()}.`);
+        let out$ = in$;
+        if (artificialDelayContext.shouldApplyArtificialDelay()) {
+            console.info(`Preferred artificial delay: ${preferredArtificialDelay} seconds. Actual delay selected: ${artificialDelayContext.getActualDelay()}`);
+            out$ = this.pipeArtificialDelayOn(out$, artificialDelayContext);
+        }
+        out$ = this.pipeTimeOutControlOn(out$, timeoutPeriods);
+        out$ = this.pipeRetryMechanismOn(out$, artificialDelayContext);
+        return out$;
+    }
+    pipeTimeOutControlOn(in$, timeoutPeriods) {
+        const timeOutAfterSeconds = timeoutPeriods[0];
+        console.info(`Piping timeout control with ${timeOutAfterSeconds} seconds.`);
+        const out$ = in$.pipe(timeout(timeOutAfterSeconds * 1000));
+        return out$;
+    }
+    pipeRetryMechanismOn(in$, artificialDelayContext) {
+        const retryStrategy = (errors) => {
+            return errors.pipe(mergeMap((error, i) => {
+                console.error(`Mapping error ${error?.name}, ${i}`);
+                console.error(error);
+                if (error?.name === 'TimeoutError' && i === 0) {
+                    artificialDelayContext.turnOffArtificialDelays();
+                    console.info('Will retry, after a timeout error.');
+                }
+                else {
+                    console.error('Will NOT retry.');
+                    throw error;
+                }
+                return timer(0);
+            }), finalize(() => console.log('We are done!')));
+        };
+        const out$ = in$.pipe(retryWhen(retryStrategy));
+        return out$;
+    }
+    pipeArtificialDelayOn(in$, artificialDelayContext) {
+        let out$ = in$.pipe(tap(() => {
+            console.log(`Artificially delaying for ${artificialDelayContext.getActualDelay()} seconds..`);
+        }));
+        out$ = out$.pipe(delayWhen(() => timer(artificialDelayContext.getActualDelay() * 1000)));
+        out$ = out$.pipe(tap(() => {
+            console.log(`Artificially delayed for ${artificialDelayContext.getActualDelay()} seconds..`);
+        }));
+        return out$;
+    }
+}
+RetryUtil.ɵfac = function RetryUtil_Factory(t) { return new (t || RetryUtil)(); };
+RetryUtil.ɵprov = /*@__PURE__*/ i0.ɵɵdefineInjectable({ token: RetryUtil, factory: RetryUtil.ɵfac });
+(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(RetryUtil, [{
+        type: Injectable
+    }], null, null); })();
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"retry.service.js","sourceRoot":"","sources":["../../../../../../../../projects/ccd-case-ui-toolkit/src/lib/shared/services/utils/retry/retry.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable } from '@angular/core';\nimport { Observable, throwError, timer } from 'rxjs';\nimport { delayWhen, finalize, mergeMap, retryWhen, tap, timeout } from 'rxjs/operators';\n\nclass ArtificialDelayContext {\n    private artificialDelayOn = true;\n    private selectedDelay = this.selectActualDelayTime();\n    constructor(\n        private preferredDelay: number\n    ) {\n    }\n    public switchArtificialDelays(status: boolean) {\n        this.artificialDelayOn = status;\n        this.selectedDelay = this.selectActualDelayTime();\n    }\n    public turnOnArtificialDelays() {\n        this.switchArtificialDelays(true);\n    }\n\n    public turnOffArtificialDelays() {\n        this.switchArtificialDelays(false);\n    }\n    public getActualDelay() {\n        return this.artificialDelayOn ? this.selectedDelay : 0;\n    }\n\n    public shouldApplyArtificialDelay() {\n        return this.preferredDelay > 0;\n    }\n\n    private selectActualDelayTime() {\n        return Date.now() % 2 == 0 ? this.preferredDelay : 1;\n    }\n}\n\n@Injectable()\nexport class RetryUtil {\n    public pipeTimeoutMechanismOn<T>(in$: Observable<T>, preferredArtificialDelay: number, timeoutPeriods: number[]): Observable<T> {\n        const artificialDelayContext = new ArtificialDelayContext(preferredArtificialDelay);\n        console.info(`Piping a retry mechanism with timeouts {${timeoutPeriods}}.`);\n        console.info(`Artificial delay will be applied: ${artificialDelayContext.shouldApplyArtificialDelay()}.`);\n\n        let out$ = in$;\n        if (artificialDelayContext.shouldApplyArtificialDelay()) {\n            console.info(`Preferred artificial delay: ${preferredArtificialDelay} seconds. Actual delay selected: ${artificialDelayContext.getActualDelay()}`);\n            out$ = this.pipeArtificialDelayOn(out$, artificialDelayContext);\n        }\n        out$ = this.pipeTimeOutControlOn(out$, timeoutPeriods);\n        out$ = this.pipeRetryMechanismOn(out$, artificialDelayContext);\n        return out$;\n    }\n\n    private pipeTimeOutControlOn<T>(in$: Observable<T>, timeoutPeriods: number[]): Observable<T> {\n        const timeOutAfterSeconds = timeoutPeriods[0];\n        console.info(`Piping timeout control with ${timeOutAfterSeconds} seconds.`);\n        const out$ = in$.pipe(timeout(timeOutAfterSeconds * 1000));\n        return out$;\n    }\n\n    private pipeRetryMechanismOn<T>(in$: Observable<T>, artificialDelayContext: ArtificialDelayContext): Observable<T> {\n        const retryStrategy = (errors) => {\n            return errors.pipe(\n                mergeMap((error: Error, i) => {\n                    console.error(`Mapping error ${error?.name}, ${i}`);\n                    console.error(error);\n                    if (error?.name === 'TimeoutError' && i === 0) {\n                        artificialDelayContext.turnOffArtificialDelays();\n                        console.info('Will retry, after a timeout error.');\n                    }\n                    else {\n                        console.error('Will NOT retry.');\n                        throw error;\n                    }\n                    return timer(0);\n                }),\n                finalize(() => console.log('We are done!')));\n        };\n        const out$ = in$.pipe(retryWhen(retryStrategy));\n        return out$;\n    }\n\n    private pipeArtificialDelayOn<T>(in$: Observable<T>, artificialDelayContext: ArtificialDelayContext): Observable<T> {\n        let out$ = in$.pipe(tap(() => {\n            console.log(`Artificially delaying for ${artificialDelayContext.getActualDelay()} seconds..`);\n        }));\n        out$ = out$.pipe(delayWhen(() => timer(artificialDelayContext.getActualDelay() * 1000)));\n        out$ = out$.pipe(tap(() => {\n            console.log(`Artificially delayed for ${artificialDelayContext.getActualDelay()} seconds..`);\n        }));\n        return out$;\n    }\n}\n"]}

package/esm2020/lib/shared/services/window/window.service.mjs

@@ -0,0 +1,40 @@
+import { Injectable } from '@angular/core';
+import * as i0 from "@angular/core";
+export class WindowService {
+    locationAssign(url) {
+        window.location.assign(url);
+    }
+    setLocalStorage(key, value) {
+        window.localStorage.setItem(key, value);
+    }
+    getLocalStorage(key) {
+        return window.localStorage.getItem(key);
+    }
+    clearLocalStorage() {
+        window.localStorage.clear();
+    }
+    removeLocalStorage(key) {
+        window.localStorage.removeItem(key);
+    }
+    setSessionStorage(key, value) {
+        window.sessionStorage.setItem(key, value);
+    }
+    getSessionStorage(key) {
+        return window.sessionStorage.getItem(key);
+    }
+    openOnNewTab(url) {
+        window.open(url, '_blank');
+    }
+    confirm(message) {
+        return window.confirm(message);
+    }
+    alert(message) {
+        return window.alert(message);
+    }
+}
+WindowService.ɵfac = function WindowService_Factory(t) { return new (t || WindowService)(); };
+WindowService.ɵprov = /*@__PURE__*/ i0.ɵɵdefineInjectable({ token: WindowService, factory: WindowService.ɵfac });
+(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(WindowService, [{
+        type: Injectable
+    }], null, null); })();
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/shared/services/workbasket/workbasket-input-filter.service.mjs

@@ -0,0 +1,53 @@
+import { HttpHeaders } 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 WorkbasketInputFilterService {
+    constructor(httpService, appConfig) {
+        this.httpService = httpService;
+        this.appConfig = appConfig;
+    }
+    getWorkbasketInputUrl(caseTypeId) {
+        return `${this.appConfig.getCaseDataUrl()}/internal/case-types/${caseTypeId}/work-basket-inputs`;
+    }
+    getWorkbasketInputs(jurisdictionId, caseTypeId) {
+        const url = this.getWorkbasketInputUrl(caseTypeId);
+        const headers = new HttpHeaders()
+            .set('experimental', 'true')
+            .set('Accept', WorkbasketInputFilterService.V2_MEDIATYPE_WORKBASKET_INPUT_DETAILS)
+            .set('Content-Type', 'application/json');
+        this.currentJurisdiction = jurisdictionId;
+        this.currentCaseType = caseTypeId;
+        return this.httpService
+            .get(url, { headers, observe: 'body' })
+            .pipe(map(body => {
+            const workbasketInputs = body.workbasketInputs;
+            if (this.isDataValid(jurisdictionId, caseTypeId)) {
+                workbasketInputs.forEach(item => {
+                    item.field.label = item.label;
+                    if (item.display_context_parameter) {
+                        item.field.display_context_parameter = item.display_context_parameter;
+                    }
+                });
+            }
+            else {
+                throw new Error('Response expired');
+            }
+            return workbasketInputs;
+        }));
+    }
+    isDataValid(jurisdictionId, caseTypeId) {
+        return this.currentJurisdiction === jurisdictionId && this.currentCaseType === caseTypeId;
+    }
+}
+WorkbasketInputFilterService.V2_MEDIATYPE_WORKBASKET_INPUT_DETAILS = 'application/vnd.uk.gov.hmcts.ccd-data-store-api.ui-workbasket-input-details.v2+json;charset=UTF-8';
+WorkbasketInputFilterService.ɵfac = function WorkbasketInputFilterService_Factory(t) { return new (t || WorkbasketInputFilterService)(i0.ɵɵinject(i1.HttpService), i0.ɵɵinject(i2.AbstractAppConfig)); };
+WorkbasketInputFilterService.ɵprov = /*@__PURE__*/ i0.ɵɵdefineInjectable({ token: WorkbasketInputFilterService, factory: WorkbasketInputFilterService.ɵfac });
+(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(WorkbasketInputFilterService, [{
+        type: Injectable
+    }], function () { return [{ type: i1.HttpService }, { type: i2.AbstractAppConfig }]; }, null); })();
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/shared/test/test-route-snapshot-builder.mjs

@@ -0,0 +1,40 @@
+export class TestRouteSnapshotBuilder {
+    constructor() {
+        this.parent = null;
+        this.params = {};
+        this.data = {};
+    }
+    withParent(parent) {
+        this.parent = parent;
+        return this;
+    }
+    withParams(params) {
+        this.params = params;
+        return this;
+    }
+    withData(data) {
+        this.data = data;
+        return this;
+    }
+    build() {
+        return {
+            url: [],
+            title: '',
+            params: this.params,
+            queryParams: [],
+            fragment: '',
+            data: this.data,
+            outlet: null,
+            component: null,
+            routeConfig: null,
+            root: null,
+            parent: this.parent,
+            firstChild: null,
+            children: [],
+            pathFromRoot: null,
+            paramMap: null,
+            queryParamMap: null,
+        };
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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