@hmcts/ccd-case-ui-toolkit 7.0.34-angular-upgrade → 7.0.34-ng-packageManagr-update

package/esm2020/lib/shared/pipes/link-cases-reason-code/ccd-link-cases-reason-code.pipe.mjs

@@ -0,0 +1,27 @@
+import { Pipe } from '@angular/core';
+import { LinkedCasesService } from '../../components/palette/linked-cases/services';
+import * as i0 from "@angular/core";
+import * as i1 from "../../components/palette/linked-cases/services";
+export class LinkCasesReasonValuePipe {
+    constructor(linkedCasesService) {
+        this.linkedCasesService = linkedCasesService;
+    }
+    transform(linkReason) {
+        if (linkReason?.OtherDescription) {
+            const reasonCodeMapping = this.linkedCasesService.linkCaseReasons?.find(reason => reason.key === linkReason.Reason);
+            return reasonCodeMapping?.value_en === 'Other'
+                ? `${reasonCodeMapping?.value_en} - ${linkReason.OtherDescription}`
+                : reasonCodeMapping?.value_en;
+        }
+        return this.linkedCasesService.linkCaseReasons?.find(reason => reason.key === linkReason.Reason)?.value_en;
+    }
+}
+LinkCasesReasonValuePipe.ɵfac = function LinkCasesReasonValuePipe_Factory(t) { return new (t || LinkCasesReasonValuePipe)(i0.ɵɵdirectiveInject(i1.LinkedCasesService, 16)); };
+LinkCasesReasonValuePipe.ɵpipe = /*@__PURE__*/ i0.ɵɵdefinePipe({ name: "ccdLinkCasesReasonValue", type: LinkCasesReasonValuePipe, pure: true });
+(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(LinkCasesReasonValuePipe, [{
+        type: Pipe,
+        args: [{
+                name: 'ccdLinkCasesReasonValue'
+            }]
+    }], function () { return [{ type: i1.LinkedCasesService }]; }, null); })();
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/shared/pipes/pipes.module.mjs

@@ -0,0 +1,64 @@
+import { CommonModule } from '@angular/common';
+import { NgModule } from '@angular/core';
+import { CaseReferencePipe } from './case-reference';
+import { CcdCaseTitlePipe } from './case-title';
+import { CcdCollectionTableCaseFieldsFilterPipe, CcdCYAPageLabelFilterPipe, CcdPageFieldsPipe, CcdTabFieldsPipe, ReadFieldsFilterPipe } from './complex';
+import { EnumDisplayDescriptionPipe } from './generic/enum-display-description/enum-display-description.pipe';
+import { LinkCasesFromReasonValuePipe } from './link-cases-from-reason-code/ccd-link-cases-from-reason-code.pipe';
+import { LinkCasesReasonValuePipe } from './link-cases-reason-code/ccd-link-cases-reason-code.pipe';
+import { SortSearchResultPipe } from './search-result/sorting/sort-search-result.pipe';
+import * as i0 from "@angular/core";
+const pipeDeclarations = [
+    CaseReferencePipe,
+    SortSearchResultPipe,
+    CcdCaseTitlePipe,
+    CcdCollectionTableCaseFieldsFilterPipe,
+    CcdCYAPageLabelFilterPipe,
+    ReadFieldsFilterPipe,
+    CcdTabFieldsPipe,
+    CcdPageFieldsPipe,
+    LinkCasesReasonValuePipe,
+    LinkCasesFromReasonValuePipe,
+    EnumDisplayDescriptionPipe
+];
+export class PipesModule {
+}
+PipesModule.ɵfac = function PipesModule_Factory(t) { return new (t || PipesModule)(); };
+PipesModule.ɵmod = /*@__PURE__*/ i0.ɵɵdefineNgModule({ type: PipesModule });
+PipesModule.ɵinj = /*@__PURE__*/ i0.ɵɵdefineInjector({ imports: [CommonModule] });
+(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(PipesModule, [{
+        type: NgModule,
+        args: [{
+                imports: [
+                    CommonModule,
+                ],
+                declarations: [
+                    ...pipeDeclarations
+                ],
+                exports: [
+                    ...pipeDeclarations,
+                ]
+            }]
+    }], null, null); })();
+(function () { (typeof ngJitMode === "undefined" || ngJitMode) && i0.ɵɵsetNgModuleScope(PipesModule, { declarations: [CaseReferencePipe,
+        SortSearchResultPipe,
+        CcdCaseTitlePipe,
+        CcdCollectionTableCaseFieldsFilterPipe,
+        CcdCYAPageLabelFilterPipe,
+        ReadFieldsFilterPipe,
+        CcdTabFieldsPipe,
+        CcdPageFieldsPipe,
+        LinkCasesReasonValuePipe,
+        LinkCasesFromReasonValuePipe,
+        EnumDisplayDescriptionPipe], imports: [CommonModule], exports: [CaseReferencePipe,
+        SortSearchResultPipe,
+        CcdCaseTitlePipe,
+        CcdCollectionTableCaseFieldsFilterPipe,
+        CcdCYAPageLabelFilterPipe,
+        ReadFieldsFilterPipe,
+        CcdTabFieldsPipe,
+        CcdPageFieldsPipe,
+        LinkCasesReasonValuePipe,
+        LinkCasesFromReasonValuePipe,
+        EnumDisplayDescriptionPipe] }); })();
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicGlwZXMubW9kdWxlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vcHJvamVjdHMvY2NkLWNhc2UtdWktdG9vbGtpdC9zcmMvbGliL3NoYXJlZC9waXBlcy9waXBlcy5tb2R1bGUudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLFlBQVksRUFBRSxNQUFNLGlCQUFpQixDQUFDO0FBQy9DLE9BQU8sRUFBRSxRQUFRLEVBQUUsTUFBTSxlQUFlLENBQUM7QUFDekMsT0FBTyxFQUFFLGlCQUFpQixFQUFFLE1BQU0sa0JBQWtCLENBQUM7QUFDckQsT0FBTyxFQUFFLGdCQUFnQixFQUFFLE1BQU0sY0FBYyxDQUFDO0FBQ2hELE9BQU8sRUFBRSxzQ0FBc0MsRUFBRSx5QkFBeUIsRUFBRSxpQkFBaUIsRUFBRSxnQkFBZ0IsRUFBRSxvQkFBb0IsRUFBRSxNQUFNLFdBQVcsQ0FBQztBQUN6SixPQUFPLEVBQUUsMEJBQTBCLEVBQUUsTUFBTSxrRUFBa0UsQ0FBQztBQUM5RyxPQUFPLEVBQUUsNEJBQTRCLEVBQUUsTUFBTSxvRUFBb0UsQ0FBQztBQUNsSCxPQUFPLEVBQUUsd0JBQXdCLEVBQUUsTUFBTSwwREFBMEQsQ0FBQztBQUNwRyxPQUFPLEVBQUUsb0JBQW9CLEVBQUUsTUFBTSxpREFBaUQsQ0FBQzs7QUFFdkYsTUFBTSxnQkFBZ0IsR0FBRztJQUN2QixpQkFBaUI7SUFDakIsb0JBQW9CO0lBQ3BCLGdCQUFnQjtJQUNoQixzQ0FBc0M7SUFDdEMseUJBQXlCO0lBQ3pCLG9CQUFvQjtJQUNwQixnQkFBZ0I7SUFDaEIsaUJBQWlCO0lBQ2pCLHdCQUF3QjtJQUN4Qiw0QkFBNEI7SUFDNUIsMEJBQTBCO0NBQzNCLENBQUM7QUFhRixNQUFNLE9BQU8sV0FBVzs7c0VBQVgsV0FBVzs2REFBWCxXQUFXO2lFQVRwQixZQUFZO3VGQVNILFdBQVc7Y0FYdkIsUUFBUTtlQUFDO2dCQUNSLE9BQU8sRUFBRTtvQkFDUCxZQUFZO2lCQUNiO2dCQUNELFlBQVksRUFBRTtvQkFDWixHQUFHLGdCQUFnQjtpQkFDcEI7Z0JBQ0QsT0FBTyxFQUFFO29CQUNQLEdBQUcsZ0JBQWdCO2lCQUNwQjthQUNGOzt3RkFDWSxXQUFXLG1CQXhCdEIsaUJBQWlCO1FBQ2pCLG9CQUFvQjtRQUNwQixnQkFBZ0I7UUFDaEIsc0NBQXNDO1FBQ3RDLHlCQUF5QjtRQUN6QixvQkFBb0I7UUFDcEIsZ0JBQWdCO1FBQ2hCLGlCQUFpQjtRQUNqQix3QkFBd0I7UUFDeEIsNEJBQTRCO1FBQzVCLDBCQUEwQixhQUt4QixZQUFZLGFBZmQsaUJBQWlCO1FBQ2pCLG9CQUFvQjtRQUNwQixnQkFBZ0I7UUFDaEIsc0NBQXNDO1FBQ3RDLHlCQUF5QjtRQUN6QixvQkFBb0I7UUFDcEIsZ0JBQWdCO1FBQ2hCLGlCQUFpQjtRQUNqQix3QkFBd0I7UUFDeEIsNEJBQTRCO1FBQzVCLDBCQUEwQiIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IENvbW1vbk1vZHVsZSB9IGZyb20gJ0Bhbmd1bGFyL2NvbW1vbic7XG5pbXBvcnQgeyBOZ01vZHVsZSB9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xuaW1wb3J0IHsgQ2FzZVJlZmVyZW5jZVBpcGUgfSBmcm9tICcuL2Nhc2UtcmVmZXJlbmNlJztcbmltcG9ydCB7IENjZENhc2VUaXRsZVBpcGUgfSBmcm9tICcuL2Nhc2UtdGl0bGUnO1xuaW1wb3J0IHsgQ2NkQ29sbGVjdGlvblRhYmxlQ2FzZUZpZWxkc0ZpbHRlclBpcGUsIENjZENZQVBhZ2VMYWJlbEZpbHRlclBpcGUsIENjZFBhZ2VGaWVsZHNQaXBlLCBDY2RUYWJGaWVsZHNQaXBlLCBSZWFkRmllbGRzRmlsdGVyUGlwZSB9IGZyb20gJy4vY29tcGxleCc7XG5pbXBvcnQgeyBFbnVtRGlzcGxheURlc2NyaXB0aW9uUGlwZSB9IGZyb20gJy4vZ2VuZXJpYy9lbnVtLWRpc3BsYXktZGVzY3JpcHRpb24vZW51bS1kaXNwbGF5LWRlc2NyaXB0aW9uLnBpcGUnO1xuaW1wb3J0IHsgTGlua0Nhc2VzRnJvbVJlYXNvblZhbHVlUGlwZSB9IGZyb20gJy4vbGluay1jYXNlcy1mcm9tLXJlYXNvbi1jb2RlL2NjZC1saW5rLWNhc2VzLWZyb20tcmVhc29uLWNvZGUucGlwZSc7XG5pbXBvcnQgeyBMaW5rQ2FzZXNSZWFzb25WYWx1ZVBpcGUgfSBmcm9tICcuL2xpbmstY2FzZXMtcmVhc29uLWNvZGUvY2NkLWxpbmstY2FzZXMtcmVhc29uLWNvZGUucGlwZSc7XG5pbXBvcnQgeyBTb3J0U2VhcmNoUmVzdWx0UGlwZSB9IGZyb20gJy4vc2VhcmNoLXJlc3VsdC9zb3J0aW5nL3NvcnQtc2VhcmNoLXJlc3VsdC5waXBlJztcblxuY29uc3QgcGlwZURlY2xhcmF0aW9ucyA9IFtcbiAgQ2FzZVJlZmVyZW5jZVBpcGUsXG4gIFNvcnRTZWFyY2hSZXN1bHRQaXBlLFxuICBDY2RDYXNlVGl0bGVQaXBlLFxuICBDY2RDb2xsZWN0aW9uVGFibGVDYXNlRmllbGRzRmlsdGVyUGlwZSxcbiAgQ2NkQ1lBUGFnZUxhYmVsRmlsdGVyUGlwZSxcbiAgUmVhZEZpZWxkc0ZpbHRlclBpcGUsXG4gIENjZFRhYkZpZWxkc1BpcGUsXG4gIENjZFBhZ2VGaWVsZHNQaXBlLFxuICBMaW5rQ2FzZXNSZWFzb25WYWx1ZVBpcGUsXG4gIExpbmtDYXNlc0Zyb21SZWFzb25WYWx1ZVBpcGUsXG4gIEVudW1EaXNwbGF5RGVzY3JpcHRpb25QaXBlXG5dO1xuXG5ATmdNb2R1bGUoe1xuICBpbXBvcnRzOiBbXG4gICAgQ29tbW9uTW9kdWxlLFxuICBdLFxuICBkZWNsYXJhdGlvbnM6IFtcbiAgICAuLi5waXBlRGVjbGFyYXRpb25zXG4gIF0sXG4gIGV4cG9ydHM6IFtcbiAgICAuLi5waXBlRGVjbGFyYXRpb25zLFxuICBdXG59KVxuZXhwb3J0IGNsYXNzIFBpcGVzTW9kdWxlIHt9XG4iXX0=

package/esm2020/lib/shared/pipes/search-result/sorting/sort-search-result.pipe.mjs

@@ -0,0 +1,24 @@
+import { Pipe } from '@angular/core';
+import { isUndefined } from 'util';
+import { SortOrder } from '../../../domain';
+import * as i0 from "@angular/core";
+export class SortSearchResultPipe {
+    transform(searchResults, sortParameters) {
+        if (isUndefined(searchResults) || isUndefined(sortParameters)) {
+            return searchResults;
+        }
+        return searchResults.sort((a, b) => {
+            return sortParameters.comparator.compare(a, b)
+                * (sortParameters.sortOrder === SortOrder.DESCENDING ? 1 : -1);
+        });
+    }
+}
+SortSearchResultPipe.ɵfac = function SortSearchResultPipe_Factory(t) { return new (t || SortSearchResultPipe)(); };
+SortSearchResultPipe.ɵpipe = /*@__PURE__*/ i0.ɵɵdefinePipe({ name: "ccdSortSearchResult", type: SortSearchResultPipe, pure: true });
+(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(SortSearchResultPipe, [{
+        type: Pipe,
+        args: [{
+                name: 'ccdSortSearchResult'
+            }]
+    }], null, null); })();
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,114 @@
+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 {
+    constructor(activityService, ngZone, config) {
+        this.activityService = activityService;
+        this.ngZone = ngZone;
+        this.config = config;
+        this.pendingRequests = new Map();
+        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);
+    }
+}
+ActivityPollingService.ɵfac = function ActivityPollingService_Factory(t) { return new (t || ActivityPollingService)(i0.ɵɵinject(i1.ActivityService), i0.ɵɵinject(i0.NgZone), i0.ɵɵinject(i2.AbstractAppConfig)); };
+ActivityPollingService.ɵ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/esm2020/lib/shared/services/activity/activity.service.mjs

@@ -0,0 +1,82 @@
+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 {
+    constructor(http, appConfig, sessionStorageService) {
+        this.http = http;
+        this.appConfig = appConfig;
+        this.sessionStorageService = sessionStorageService;
+        this.userAuthorised = undefined;
+    }
+    static get ACTIVITY_VIEW() { return 'view'; }
+    static get ACTIVITY_EDIT() { return 'edit'; }
+    get isEnabled() {
+        return this.activityUrl() && this.userAuthorised;
+    }
+    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();
+    }
+}
+ActivityService.DUMMY_CASE_REFERENCE = '0';
+ActivityService.ɵfac = function ActivityService_Factory(t) { return new (t || ActivityService)(i0.ɵɵinject(i1.HttpService), i0.ɵɵinject(i2.AbstractAppConfig), i0.ɵɵinject(i3.SessionStorageService)); };
+ActivityService.ɵ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/esm2020/lib/shared/services/addresses/address-parser.mjs

@@ -0,0 +1,76 @@
+import { AddressModel } from '../../domain/addresses/address.model';
+import { AddressType } from './address-type.enum';
+/**
+ * Moving all this logic here into Address Parser class, so that it
+ * will be easier for us when we move this parsing logic to into
+ * `Shim` java service.
+ */
+export class AddressParser {
+    parse(address) {
+        const classification = `${address.CLASSIFICATION_CODE}`;
+        const addressModel = new AddressModel();
+        addressModel.AddressLine1 = this.parseAddressLine1(classification, address);
+        addressModel.AddressLine2 = this.parseAddressLine2(classification, address);
+        addressModel.AddressLine3 = this.parseAddressLine3(classification, address);
+        addressModel.PostCode = address.POSTCODE;
+        addressModel.PostTown = address.POST_TOWN;
+        addressModel.Country = AddressType.UK;
+        return addressModel;
+    }
+    parseAddressLine1(classification, address) {
+        let addressLine;
+        if (classification === AddressType.RD06) {
+            addressLine =
+                `${address.SUB_BUILDING_NAME} ${address.ORGANISATION_NAME} ${address.DEPARTMENT_NAME} ${address.PO_BOX_NUMBER}`;
+        }
+        else {
+            addressLine =
+                `${address.ORGANISATION_NAME}${this.prefixWithCommaIfPresent(address.BUILDING_NAME)}` +
+                    `${address.DEPARTMENT_NAME} ${address.PO_BOX_NUMBER}`;
+        }
+        return this.removeNonAddressValues(addressLine);
+    }
+    parseAddressLine2(classification, address) {
+        let addressLine;
+        if (classification === AddressType.RD06) {
+            addressLine = `${address.BUILDING_NAME} `;
+        }
+        else {
+            addressLine =
+                `${address.SUB_BUILDING_NAME} ${address.BUILDING_NUMBER} ${address.THOROUGHFARE_NAME}`;
+        }
+        return this.removeNonAddressValues(addressLine);
+    }
+    parseAddressLine3(classification, address) {
+        let addressLine;
+        if (classification === AddressType.RD06) {
+            addressLine =
+                `${address.BUILDING_NUMBER} ${address.THOROUGHFARE_NAME}`;
+        }
+        else {
+            addressLine =
+                `${address.DEPENDENT_LOCALITY} ${address.DOUBLE_DEPENDENT_LOCALITY} ${address.DEPENDENT_THOROUGHFARE_NAME}`;
+        }
+        return this.removeNonAddressValues(addressLine);
+    }
+    removeNonAddressValues(line) {
+        line = line.replace(' null', ' ').replace('null ', ' ');
+        line = this.removeUndefinedString(line);
+        line = this.removeInitialComma(line);
+        line = this.removeEmptySpaces(line);
+        return line;
+    }
+    removeUndefinedString(value) {
+        return value.replace(new RegExp('undefined', 'gi'), '');
+    }
+    removeEmptySpaces(value) {
+        return value.replace(new RegExp(' +', 'gi'), ' ').trim();
+    }
+    removeInitialComma(value) {
+        return value.replace(new RegExp('^,', 'gi'), '');
+    }
+    prefixWithCommaIfPresent(value) {
+        return value ? `, ${value}` : value;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,63 @@
+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 {
+    constructor(http, appConfig) {
+        this.http = http;
+        this.appConfig = appConfig;
+        this.mandatoryError = new BehaviorSubject(false);
+    }
+    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;
+    }
+}
+AddressesService.ɵfac = function AddressesService_Factory(t) { return new (t || AddressesService)(i0.ɵɵinject(i1.HttpService), i0.ɵɵinject(i2.AbstractAppConfig)); };
+AddressesService.ɵ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,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYWRkcmVzc2VzLnNlcnZpY2UuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9jY2QtY2FzZS11aS10b29sa2l0L3NyYy9saWIvc2hhcmVkL3NlcnZpY2VzL2FkZHJlc3Nlcy9hZGRyZXNzZXMuc2VydmljZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsVUFBVSxFQUFFLE1BQU0sZUFBZSxDQUFDO0FBQzNDLE9BQU8sRUFBRSxlQUFlLEVBQWMsTUFBTSxNQUFNLENBQUM7QUFDbkQsT0FBTyxFQUFFLEdBQUcsRUFBRSxNQUFNLGdCQUFnQixDQUFDO0FBQ3JDLE9BQU8sRUFBRSxpQkFBaUIsRUFBRSxNQUFNLHFCQUFxQixDQUFDO0FBRXhELE9BQU8sRUFBRSxXQUFXLEVBQUUsTUFBTSxTQUFTLENBQUM7QUFDdEMsT0FBTyxFQUFFLGFBQWEsRUFBRSxNQUFNLGtCQUFrQixDQUFDO0FBQ2pELE9BQU8sRUFBRSxXQUFXLEVBQUUsTUFBTSxxQkFBcUIsQ0FBQzs7OztBQUdsRCxNQUFNLE9BQU8sZ0JBQWdCO0lBSTNCLFlBQTZCLElBQWlCLEVBQW1CLFNBQTRCO1FBQWhFLFNBQUksR0FBSixJQUFJLENBQWE7UUFBbUIsY0FBUyxHQUFULFNBQVMsQ0FBbUI7UUFGckYsbUJBQWMsR0FBNkIsSUFBSSxlQUFlLENBQVUsS0FBSyxDQUFDLENBQUM7SUFHdkYsQ0FBQztJQUVNLHVCQUF1QixDQUFDLFFBQWdCO1FBQzdDLE9BQU8sSUFBSSxDQUFDLElBQUk7YUFDYixHQUFHLENBQUMsSUFBSSxDQUFDLFNBQVMsQ0FBQyxvQkFBb0IsRUFBRTthQUN2QyxPQUFPLENBQUMsYUFBYSxFQUFFLFFBQVEsQ0FBQyxFQUFFLFNBQVMsRUFBRSxLQUFLLENBQUM7YUFDckQsSUFBSSxDQUNILEdBQUcsQ0FBQyxHQUFHLENBQUMsRUFBRSxDQUFDLEdBQUcsQ0FBQyxPQUFPLENBQUMsQ0FBQzthQUN6QixJQUFJLENBQ0gsR0FBRyxDQUFDLE1BQU0sQ0FBQyxFQUFFLENBQUMsTUFBTSxDQUFDLEdBQUcsQ0FBQyxTQUFTLENBQUMsRUFBRSxDQUNuQyxJQUFJLENBQUMsTUFBTSxDQUFDLElBQUksYUFBYSxFQUFFLENBQUMsS0FBSyxDQUFDLFNBQVMsQ0FBQyxXQUFXLENBQUMsR0FBRyxDQUFDLENBQUMsQ0FBQyxDQUNuRSxDQUFDLENBQ0gsQ0FBQztJQUNOLENBQUM7SUFFTSxpQkFBaUI7UUFDdEIsT0FBTyxJQUFJLENBQUMsY0FBYyxDQUFDLFlBQVksRUFBRSxDQUFDO0lBQzVDLENBQUM7SUFFTSxpQkFBaUIsQ0FBQyxLQUFjO1FBQ3JDLElBQUksQ0FBQyxjQUFjLENBQUMsSUFBSSxDQUFDLEtBQUssQ0FBQyxDQUFDO0lBQ2xDLENBQUM7SUFFTyxNQUFNLENBQUMsWUFBMEI7UUFDdkMsT0FBTyxJQUFJLENBQUMsa0JBQWtCLENBQUMsSUFBSSxDQUFDLG1CQUFtQixDQUFDLFlBQVksQ0FBQyxDQUFDLENBQUM7SUFDekUsQ0FBQztJQUVPLGtCQUFrQixDQUFDLFlBQTBCO1FBQ25ELENBQUMsY0FBYyxFQUFFLGNBQWMsRUFBRSxjQUFjLEVBQUUsVUFBVSxDQUFDLENBQUMsT0FBTyxDQUFDLEtBQUssQ0FBQyxFQUFFO1lBQzNFLFlBQVksQ0FBQyxLQUFLLENBQUMsR0FBRyxJQUFJLENBQUMsYUFBYSxDQUFDLFlBQVksQ0FBQyxLQUFLLENBQUMsQ0FBQyxDQUFDO1FBQ2hFLENBQUMsQ0FBQyxDQUFDO1FBQ0gsT0FBTyxZQUFZLENBQUM7SUFDdEIsQ0FBQztJQUVPLG1CQUFtQixDQUFDLFlBQTBCO1FBQ3BELElBQUksWUFBWSxDQUFDLFlBQVksS0FBSyxFQUFFLEVBQUU7WUFDcEMsWUFBWSxDQUFDLFlBQVksR0FBRyxZQUFZLENBQUMsWUFBWSxDQUFDO1lBQ3RELFlBQVksQ0FBQyxZQUFZLEdBQUcsRUFBRSxDQUFDO1NBQ2hDO1FBQ0QsSUFBSSxZQUFZLENBQUMsWUFBWSxLQUFLLEVBQUUsRUFBRTtZQUNwQyxZQUFZLENBQUMsWUFBWSxHQUFHLFlBQVksQ0FBQyxZQUFZLENBQUM7WUFDdEQsWUFBWSxDQUFDLFlBQVksR0FBRyxFQUFFLENBQUM7U0FDaEM7UUFDRCxPQUFPLFlBQVksQ0FBQztJQUN0QixDQUFDO0lBRU8sYUFBYSxDQUFDLFFBQWdCO1FBQ3BDLFFBQVEsR0FBRyxRQUFRLENBQUMsV0FBVyxFQUFFLENBQUM7UUFDbEMsUUFBUSxDQUFDLEtBQUssQ0FBQyxHQUFHLENBQUMsQ0FBQyxPQUFPLENBQUMsQ0FBQyxLQUFLLEVBQUUsS0FBSyxFQUFFLEVBQUU7WUFDekMsUUFBUSxHQUFHLFFBQVEsQ0FBQyxPQUFPLENBQUMsS0FBSyxFQUFFLEtBQUssQ0FBQyxNQUFNLENBQUMsQ0FBQyxDQUFDLENBQUMsV0FBVyxFQUFFLEdBQUcsS0FBSyxDQUFDLE1BQU0sQ0FBQyxDQUFDLENBQUMsQ0FBQyxDQUFDO1FBQ3RGLENBQUMsQ0FDRixDQUFDO1FBQ0YsT0FBTyxRQUFRLENBQUM7SUFDbEIsQ0FBQzs7Z0ZBMURVLGdCQUFnQjtzRUFBaEIsZ0JBQWdCLFdBQWhCLGdCQUFnQjt1RkFBaEIsZ0JBQWdCO2NBRDVCLFVBQVUiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBJbmplY3RhYmxlIH0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XG5pbXBvcnQgeyBCZWhhdmlvclN1YmplY3QsIE9ic2VydmFibGUgfSBmcm9tICdyeGpzJztcbmltcG9ydCB7IG1hcCB9IGZyb20gJ3J4anMvb3BlcmF0b3JzJztcbmltcG9ydCB7IEFic3RyYWN0QXBwQ29uZmlnIH0gZnJvbSAnLi4vLi4vLi4vYXBwLmNvbmZpZyc7XG5pbXBvcnQgeyBBZGRyZXNzTW9kZWwgfSBmcm9tICcuLi8uLi9kb21haW4vYWRkcmVzc2VzJztcbmltcG9ydCB7IEh0dHBTZXJ2aWNlIH0gZnJvbSAnLi4vaHR0cCc7XG5pbXBvcnQgeyBBZGRyZXNzUGFyc2VyIH0gZnJvbSAnLi9hZGRyZXNzLXBhcnNlcic7XG5pbXBvcnQgeyBBZGRyZXNzVHlwZSB9IGZyb20gJy4vYWRkcmVzcy10eXBlLmVudW0nO1xuXG5ASW5qZWN0YWJsZSgpXG5leHBvcnQgY2xhc3MgQWRkcmVzc2VzU2VydmljZSB7XG5cbiAgcHJpdmF0ZSBtYW5kYXRvcnlFcnJvcjogQmVoYXZpb3JTdWJqZWN0PGJvb2xlYW4+ID0gbmV3IEJlaGF2aW9yU3ViamVjdDxib29sZWFuPihmYWxzZSk7XG5cbiAgY29uc3RydWN0b3IocHJpdmF0ZSByZWFkb25seSBodHRwOiBIdHRwU2VydmljZSwgcHJpdmF0ZSByZWFkb25seSBhcHBDb25maWc6IEFic3RyYWN0QXBwQ29uZmlnKSB7XG4gIH1cblxuICBwdWJsaWMgZ2V0QWRkcmVzc2VzRm9yUG9zdGNvZGUocG9zdGNvZGU6IHN0cmluZyk6IE9ic2VydmFibGU8QWRkcmVzc01vZGVsW10+IHtcbiAgICByZXR1cm4gdGhpcy5odHRwXG4gICAgICAuZ2V0KHRoaXMuYXBwQ29uZmlnLmdldFBvc3Rjb2RlTG9va3VwVXJsKClcbiAgICAgICAgLnJlcGxhY2UoJyR7cG9zdGNvZGV9JywgcG9zdGNvZGUpLCB1bmRlZmluZWQsIGZhbHNlKVxuICAgICAgLnBpcGUoXG4gICAgICAgIG1hcChyZXMgPT4gcmVzLnJlc3VsdHMpKVxuICAgICAgLnBpcGUoXG4gICAgICAgIG1hcChvdXRwdXQgPT4gb3V0cHV0Lm1hcChhZGRyZXNzZXMgPT5cbiAgICAgICAgICB0aGlzLmZvcm1hdChuZXcgQWRkcmVzc1BhcnNlcigpLnBhcnNlKGFkZHJlc3Nlc1tBZGRyZXNzVHlwZS5EUEFdKSlcbiAgICAgICAgKSlcbiAgICAgICk7XG4gIH1cblxuICBwdWJsaWMgZ2V0TWFuZGF0b3J5RXJyb3IoKTogT2JzZXJ2YWJsZTxib29sZWFuPiB7XG4gICAgcmV0dXJuIHRoaXMubWFuZGF0b3J5RXJyb3IuYXNPYnNlcnZhYmxlKCk7XG4gIH1cblxuICBwdWJsaWMgc2V0TWFuZGF0b3J5RXJyb3IodmFsdWU6IGJvb2xlYW4pOiB2b2lkIHtcbiAgICB0aGlzLm1hbmRhdG9yeUVycm9yLm5leHQodmFsdWUpO1xuICB9XG5cbiAgcHJpdmF0ZSBmb3JtYXQoYWRkcmVzc01vZGVsOiBBZGRyZXNzTW9kZWwpIHtcbiAgICByZXR1cm4gdGhpcy5mb3JtYXRBZGRyZXNzTGluZXModGhpcy5zaGlmdEFkZHJlc3NMaW5lc1VwKGFkZHJlc3NNb2RlbCkpO1xuICB9XG5cbiAgcHJpdmF0ZSBmb3JtYXRBZGRyZXNzTGluZXMoYWRkcmVzc01vZGVsOiBBZGRyZXNzTW9kZWwpIHtcbiAgICBbJ0FkZHJlc3NMaW5lMScsICdBZGRyZXNzTGluZTInLCAnQWRkcmVzc0xpbmUzJywgJ1Bvc3RUb3duJ10uZm9yRWFjaCh2YWx1ZSA9PiB7XG4gICAgICBhZGRyZXNzTW9kZWxbdmFsdWVdID0gdGhpcy50b0NhcGl0YWxDYXNlKGFkZHJlc3NNb2RlbFt2YWx1ZV0pO1xuICAgIH0pO1xuICAgIHJldHVybiBhZGRyZXNzTW9kZWw7XG4gIH1cblxuICBwcml2YXRlIHNoaWZ0QWRkcmVzc0xpbmVzVXAoYWRkcmVzc01vZGVsOiBBZGRyZXNzTW9kZWwpIHtcbiAgICBpZiAoYWRkcmVzc01vZGVsLkFkZHJlc3NMaW5lMiA9PT0gJycpIHtcbiAgICAgIGFkZHJlc3NNb2RlbC5BZGRyZXNzTGluZTIgPSBhZGRyZXNzTW9kZWwuQWRkcmVzc0xpbmUzO1xuICAgICAgYWRkcmVzc01vZGVsLkFkZHJlc3NMaW5lMyA9ICcnO1xuICAgIH1cbiAgICBpZiAoYWRkcmVzc01vZGVsLkFkZHJlc3NMaW5lMSA9PT0gJycpIHtcbiAgICAgIGFkZHJlc3NNb2RlbC5BZGRyZXNzTGluZTEgPSBhZGRyZXNzTW9kZWwuQWRkcmVzc0xpbmUyO1xuICAgICAgYWRkcmVzc01vZGVsLkFkZHJlc3NMaW5lMiA9ICcnO1xuICAgIH1cbiAgICByZXR1cm4gYWRkcmVzc01vZGVsO1xuICB9XG5cbiAgcHJpdmF0ZSB0b0NhcGl0YWxDYXNlKHNlbnRlbmNlOiBzdHJpbmcpIHtcbiAgICBzZW50ZW5jZSA9IHNlbnRlbmNlLnRvTG93ZXJDYXNlKCk7XG4gICAgc2VudGVuY2Uuc3BsaXQoJyAnKS5mb3JFYWNoKCh2YWx1ZSwgaW5kZXgpID0+IHtcbiAgICAgICAgc2VudGVuY2UgPSBzZW50ZW5jZS5yZXBsYWNlKHZhbHVlLCB2YWx1ZS5jaGFyQXQoMCkudG9VcHBlckNhc2UoKSArIHZhbHVlLnN1YnN0cigxKSk7XG4gICAgICB9XG4gICAgKTtcbiAgICByZXR1cm4gc2VudGVuY2U7XG4gIH1cbn1cbiJdfQ==