@hmcts/ccd-case-ui-toolkit 7.0.33-rc1 → 7.0.34-angular-upgrade

package/esm2022/lib/shared/components/case-viewer/case-viewer.module.mjs

@@ -0,0 +1,191 @@
+import { CommonModule } from '@angular/common';
+import { NgModule } from '@angular/core';
+import { ReactiveFormsModule } from '@angular/forms';
+import { MatLegacyTabsModule as MatTabsModule } from '@angular/material/legacy-tabs';
+import { RouterModule } from '@angular/router';
+import { RpxTranslationModule } from 'rpx-xui-translation';
+import { AlertModule } from '../../../components/banners/alert/alert.module';
+import { BannersModule } from '../../../components/banners/banners.module';
+import { ConditionalShowModule, LabelSubstitutorModule } from '../../directives';
+import { CaseReferencePipe } from '../../pipes';
+import { ActivityPollingService, ActivityService, DraftService, ErrorNotifierService, HttpService, NavigationNotifierService, OrderService } from '../../services';
+import { ActivityModule } from '../activity';
+import { CaseEditorModule, CaseNotifier, ConvertHrefToRouterService } from '../case-editor';
+import { CaseHeaderModule } from '../case-header';
+import { CaseHistoryModule } from '../case-history';
+import { EventMessageModule } from '../error-message/error-message.module';
+import { ErrorsModule } from '../error/errors.module';
+import { EventStartModule } from '../event-start/event-start.module';
+import { EventTriggerModule } from '../event-trigger';
+import { LoadingSpinnerModule } from '../loading-spinner/loading-spinner.module';
+import { PaletteModule } from '../palette';
+import { CaseBasicAccessViewComponent } from './case-basic-access-view';
+import { CaseChallengedAccessRequestComponent } from './case-challenged-access-request/case-challenged-access-request.component';
+import { CaseChallengedAccessSuccessComponent } from './case-challenged-access-success/case-challenged-access-success.component';
+import { CaseEventTriggerComponent } from './case-event-trigger';
+import { CaseFullAccessViewComponent } from './case-full-access-view/case-full-access-view.component';
+import { CaseReviewSpecificAccessRejectComponent } from './case-review-specific-access-reject';
+import { CaseReviewSpecificAccessRequestComponent } from './case-review-specific-access-request/case-review-specific-access-request.component';
+import { CaseSpecificAccessRequestComponent } from './case-specific-access-request/case-specific-access-request.component';
+import { CaseSpecificAccessSuccessComponent } from './case-specific-access-success/case-specific-access-success.component';
+import { CaseViewComponent } from './case-view';
+import { CaseViewerComponent } from './case-viewer.component';
+import { CasePrinterComponent, PrintUrlPipe } from './printer';
+import { CaseResolver, EventTriggerResolver } from './services';
+import * as i0 from "@angular/core";
+import * as i1 from "rpx-xui-translation";
+import * as i2 from "@angular/common";
+import * as i3 from "../activity/activity.component";
+import * as i4 from "../case-editor/case-edit/case-edit.component";
+import * as i5 from "../case-header/case-header.component";
+import * as i6 from "@angular/router";
+import * as i7 from "../error/callback-errors.component";
+import * as i8 from "../event-trigger/event-trigger.component";
+import * as i9 from "../palette/base-field/field-read.component";
+import * as i10 from "@angular/material/legacy-tabs";
+import * as i11 from "../../directives/substitutor/label-substitutor.directive";
+import * as i12 from "../../../components/banners/notification-banner/notification-banner.component";
+import * as i13 from "../palette/utils/is-compound.pipe";
+import * as i14 from "../../pipes/complex/ccd-read-fields-filter.pipe";
+import * as i15 from "../../pipes/complex/ccd-tab-fields.pipe";
+import * as i16 from "@angular/forms";
+import * as i17 from "../../../components/banners/alert/alert.component";
+import * as i18 from "../error-message/error-message.component";
+export class CaseViewerModule {
+    static ɵfac = function CaseViewerModule_Factory(t) { return new (t || CaseViewerModule)(); };
+    static ɵmod = /*@__PURE__*/ i0.ɵɵdefineNgModule({ type: CaseViewerModule });
+    static ɵinj = /*@__PURE__*/ i0.ɵɵdefineInjector({ providers: [
+            CaseNotifier,
+            ConvertHrefToRouterService,
+            NavigationNotifierService,
+            CaseReferencePipe,
+            EventTriggerResolver,
+            ActivityService,
+            ActivityPollingService,
+            OrderService,
+            DraftService,
+            HttpService,
+            CaseResolver,
+            ErrorNotifierService
+        ], imports: [CommonModule,
+            RouterModule,
+            ErrorsModule,
+            ActivityModule,
+            CaseHeaderModule,
+            EventStartModule,
+            EventTriggerModule,
+            PaletteModule,
+            CaseEditorModule,
+            ConditionalShowModule,
+            CaseHistoryModule,
+            MatTabsModule,
+            ReactiveFormsModule,
+            AlertModule,
+            LabelSubstitutorModule,
+            RpxTranslationModule.forChild(),
+            BannersModule,
+            LabelSubstitutorModule,
+            LoadingSpinnerModule,
+            EventMessageModule] });
+}
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(CaseViewerModule, [{
+        type: NgModule,
+        args: [{
+                imports: [
+                    CommonModule,
+                    RouterModule,
+                    ErrorsModule,
+                    ActivityModule,
+                    CaseHeaderModule,
+                    EventStartModule,
+                    EventTriggerModule,
+                    PaletteModule,
+                    CaseEditorModule,
+                    ConditionalShowModule,
+                    CaseHistoryModule,
+                    MatTabsModule,
+                    ReactiveFormsModule,
+                    AlertModule,
+                    LabelSubstitutorModule,
+                    RpxTranslationModule.forChild(),
+                    BannersModule,
+                    LabelSubstitutorModule,
+                    LoadingSpinnerModule,
+                    EventMessageModule
+                ],
+                declarations: [
+                    CaseEventTriggerComponent,
+                    CasePrinterComponent,
+                    CaseViewerComponent,
+                    CaseFullAccessViewComponent,
+                    CaseViewComponent,
+                    CaseBasicAccessViewComponent,
+                    PrintUrlPipe,
+                    CaseChallengedAccessRequestComponent,
+                    CaseSpecificAccessRequestComponent,
+                    CaseReviewSpecificAccessRequestComponent,
+                    CaseChallengedAccessSuccessComponent,
+                    CaseSpecificAccessSuccessComponent,
+                    CaseReviewSpecificAccessRejectComponent
+                ],
+                exports: [
+                    CaseViewerComponent,
+                    CaseViewComponent
+                ],
+                providers: [
+                    CaseNotifier,
+                    ConvertHrefToRouterService,
+                    NavigationNotifierService,
+                    CaseReferencePipe,
+                    EventTriggerResolver,
+                    ActivityService,
+                    ActivityPollingService,
+                    OrderService,
+                    DraftService,
+                    HttpService,
+                    CaseResolver,
+                    ErrorNotifierService
+                ]
+            }]
+    }], null, null); })();
+(function () { (typeof ngJitMode === "undefined" || ngJitMode) && i0.ɵɵsetNgModuleScope(CaseViewerModule, { declarations: [CaseEventTriggerComponent,
+        CasePrinterComponent,
+        CaseViewerComponent,
+        CaseFullAccessViewComponent,
+        CaseViewComponent,
+        CaseBasicAccessViewComponent,
+        PrintUrlPipe,
+        CaseChallengedAccessRequestComponent,
+        CaseSpecificAccessRequestComponent,
+        CaseReviewSpecificAccessRequestComponent,
+        CaseChallengedAccessSuccessComponent,
+        CaseSpecificAccessSuccessComponent,
+        CaseReviewSpecificAccessRejectComponent], imports: [CommonModule,
+        RouterModule,
+        ErrorsModule,
+        ActivityModule,
+        CaseHeaderModule,
+        EventStartModule,
+        EventTriggerModule,
+        PaletteModule,
+        CaseEditorModule,
+        ConditionalShowModule,
+        CaseHistoryModule,
+        MatTabsModule,
+        ReactiveFormsModule,
+        AlertModule,
+        LabelSubstitutorModule, i1.RpxTranslationModule, BannersModule,
+        LabelSubstitutorModule,
+        LoadingSpinnerModule,
+        EventMessageModule], exports: [CaseViewerComponent,
+        CaseViewComponent] }); })();
+i0.ɵɵsetComponentScope(CaseEventTriggerComponent, function () { return [i2.NgIf, i3.ActivityComponent, i4.CaseEditComponent]; }, []);
+i0.ɵɵsetComponentScope(CasePrinterComponent, function () { return [i2.NgForOf, i2.NgIf, i5.CaseHeaderComponent]; }, function () { return [i1.RpxTranslatePipe, PrintUrlPipe]; });
+i0.ɵɵsetComponentScope(CaseViewerComponent, function () { return [i2.NgIf, CaseFullAccessViewComponent,
+    CaseBasicAccessViewComponent]; }, []);
+i0.ɵɵsetComponentScope(CaseFullAccessViewComponent, function () { return [i2.NgForOf, i2.NgIf, i2.NgSwitch, i2.NgSwitchCase, i6.RouterOutlet, i6.RouterLink, i7.CallbackErrorsComponent, i3.ActivityComponent, i5.CaseHeaderComponent, i8.EventTriggerComponent, i9.FieldReadComponent, i10.MatLegacyTabGroup, i10.MatLegacyTab, i10.MatLegacyTabContent, i11.LabelSubstitutorDirective, i12.NotificationBannerComponent]; }, function () { return [i13.IsCompoundPipe, i14.ReadFieldsFilterPipe, i15.CcdTabFieldsPipe, i1.RpxTranslatePipe]; });
+i0.ɵɵsetComponentScope(CaseViewComponent, function () { return [i2.NgIf, CaseViewerComponent]; }, []);
+i0.ɵɵsetComponentScope(CaseChallengedAccessRequestComponent, function () { return [i2.NgClass, i2.NgIf, i16.ɵNgNoValidate, i16.DefaultValueAccessor, i16.RadioControlValueAccessor, i16.NgControlStatus, i16.NgControlStatusGroup, i16.FormGroupDirective, i16.FormControlName, i17.AlertComponent, i18.ErrorMessageComponent]; }, function () { return [i1.RpxTranslatePipe]; });
+i0.ɵɵsetComponentScope(CaseSpecificAccessRequestComponent, function () { return [i2.NgClass, i2.NgIf, i16.ɵNgNoValidate, i16.DefaultValueAccessor, i16.NgControlStatus, i16.NgControlStatusGroup, i16.FormGroupDirective, i16.FormControlName, i17.AlertComponent, i18.ErrorMessageComponent]; }, function () { return [i1.RpxTranslatePipe]; });
+i0.ɵɵsetComponentScope(CaseReviewSpecificAccessRequestComponent, function () { return [i2.NgClass, i2.NgIf, i16.ɵNgNoValidate, i16.DefaultValueAccessor, i16.RadioControlValueAccessor, i16.NgControlStatus, i16.NgControlStatusGroup, i16.FormGroupDirective, i16.FormControlName, i18.ErrorMessageComponent]; }, function () { return [i1.RpxTranslatePipe]; });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"case-viewer.module.js","sourceRoot":"","sources":["../../../../../../../projects/ccd-case-ui-toolkit/src/lib/shared/components/case-viewer/case-viewer.module.ts"],"names":[],"mappings":"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","sourcesContent":["import { CommonModule } from '@angular/common';\nimport { NgModule } from '@angular/core';\nimport { ReactiveFormsModule } from '@angular/forms';\nimport { MatLegacyTabsModule as MatTabsModule } from '@angular/material/legacy-tabs';\nimport { RouterModule } from '@angular/router';\nimport { RpxTranslationModule } from 'rpx-xui-translation';\nimport { AlertModule } from '../../../components/banners/alert/alert.module';\nimport { BannersModule } from '../../../components/banners/banners.module';\nimport { ConditionalShowModule, LabelSubstitutorModule } from '../../directives';\nimport { CaseReferencePipe } from '../../pipes';\nimport {\n  ActivityPollingService,\n  ActivityService,\n  DraftService,\n  ErrorNotifierService,\n  HttpService,\n  NavigationNotifierService,\n  OrderService\n} from '../../services';\nimport { ActivityModule } from '../activity';\nimport { CaseEditorModule, CaseNotifier, ConvertHrefToRouterService } from '../case-editor';\nimport { CaseHeaderModule } from '../case-header';\nimport { CaseHistoryModule } from '../case-history';\nimport { EventMessageModule } from '../error-message/error-message.module';\nimport { ErrorsModule } from '../error/errors.module';\nimport { EventStartModule } from '../event-start/event-start.module';\nimport { EventTriggerModule } from '../event-trigger';\nimport { LoadingSpinnerModule } from '../loading-spinner/loading-spinner.module';\nimport { PaletteModule } from '../palette';\nimport { CaseBasicAccessViewComponent } from './case-basic-access-view';\nimport { CaseChallengedAccessRequestComponent } from './case-challenged-access-request/case-challenged-access-request.component';\nimport { CaseChallengedAccessSuccessComponent } from './case-challenged-access-success/case-challenged-access-success.component';\nimport { CaseEventTriggerComponent } from './case-event-trigger';\nimport { CaseFullAccessViewComponent } from './case-full-access-view/case-full-access-view.component';\nimport { CaseReviewSpecificAccessRejectComponent } from './case-review-specific-access-reject';\nimport { CaseReviewSpecificAccessRequestComponent } from './case-review-specific-access-request/case-review-specific-access-request.component';\nimport { CaseSpecificAccessRequestComponent } from './case-specific-access-request/case-specific-access-request.component';\nimport { CaseSpecificAccessSuccessComponent } from './case-specific-access-success/case-specific-access-success.component';\nimport { CaseViewComponent } from './case-view';\nimport { CaseViewerComponent } from './case-viewer.component';\nimport { CasePrinterComponent, PrintUrlPipe } from './printer';\nimport { CaseResolver, EventTriggerResolver } from './services';\n\n@NgModule({\n  imports: [\n    CommonModule,\n    RouterModule,\n    ErrorsModule,\n    ActivityModule,\n    CaseHeaderModule,\n    EventStartModule,\n    EventTriggerModule,\n    PaletteModule,\n    CaseEditorModule,\n    ConditionalShowModule,\n    CaseHistoryModule,\n    MatTabsModule,\n    ReactiveFormsModule,\n    AlertModule,\n    LabelSubstitutorModule,\n    RpxTranslationModule.forChild(),\n    BannersModule,\n    LabelSubstitutorModule,\n    LoadingSpinnerModule,\n    EventMessageModule\n  ],\n  declarations: [\n    CaseEventTriggerComponent,\n    CasePrinterComponent,\n    CaseViewerComponent,\n    CaseFullAccessViewComponent,\n    CaseViewComponent,\n    CaseBasicAccessViewComponent,\n    PrintUrlPipe,\n    CaseChallengedAccessRequestComponent,\n    CaseSpecificAccessRequestComponent,\n    CaseReviewSpecificAccessRequestComponent,\n    CaseChallengedAccessSuccessComponent,\n    CaseSpecificAccessSuccessComponent,\n    CaseReviewSpecificAccessRejectComponent\n  ],\n  exports: [\n    CaseViewerComponent,\n    CaseViewComponent\n  ],\n  providers: [\n    CaseNotifier,\n    ConvertHrefToRouterService,\n    NavigationNotifierService,\n    CaseReferencePipe,\n    EventTriggerResolver,\n    ActivityService,\n    ActivityPollingService,\n    OrderService,\n    DraftService,\n    HttpService,\n    CaseResolver,\n    ErrorNotifierService\n  ]\n})\nexport class CaseViewerModule {\n}\n"]}

package/esm2022/lib/shared/components/case-viewer/printer/case-printer.component.mjs

@@ -0,0 +1,117 @@
+import { Component } from '@angular/core';
+import { throwError } from 'rxjs';
+import { catchError, map } from 'rxjs/operators';
+import { HttpError } from '../../../domain/http/http-error.model';
+import { AlertService } from '../../../services/alert/alert.service';
+import { CaseNotifier } from '../../case-editor/services/case.notifier';
+import { CasesService } from '../../case-editor/services/cases.service';
+import * as i0 from "@angular/core";
+import * as i1 from "../../case-editor/services/case.notifier";
+import * as i2 from "../../case-editor/services/cases.service";
+import * as i3 from "../../../services/alert/alert.service";
+function CasePrinterComponent_div_0_tr_16_Template(rf, ctx) { if (rf & 1) {
+    i0.ɵɵelementStart(0, "tr")(1, "td", 4)(2, "a", 5);
+    i0.ɵɵpipe(3, "ccdPrintUrl");
+    i0.ɵɵtext(4);
+    i0.ɵɵpipe(5, "rpxTranslate");
+    i0.ɵɵelementEnd()();
+    i0.ɵɵelementStart(6, "td", 6);
+    i0.ɵɵtext(7);
+    i0.ɵɵpipe(8, "rpxTranslate");
+    i0.ɵɵelementEnd()();
+} if (rf & 2) {
+    const document_r1 = ctx.$implicit;
+    i0.ɵɵadvance(2);
+    i0.ɵɵproperty("href", i0.ɵɵpipeBind1(3, 3, document_r1.url), i0.ɵɵsanitizeUrl);
+    i0.ɵɵadvance(2);
+    i0.ɵɵtextInterpolate1(" ", i0.ɵɵpipeBind1(5, 5, document_r1.name), " ");
+    i0.ɵɵadvance(3);
+    i0.ɵɵtextInterpolate(i0.ɵɵpipeBind1(8, 7, document_r1.type));
+} }
+function CasePrinterComponent_div_0_Template(rf, ctx) { if (rf & 1) {
+    i0.ɵɵelementStart(0, "div");
+    i0.ɵɵelement(1, "ccd-case-header", 1);
+    i0.ɵɵelementStart(2, "h2", 2);
+    i0.ɵɵtext(3);
+    i0.ɵɵpipe(4, "rpxTranslate");
+    i0.ɵɵelementEnd();
+    i0.ɵɵelementStart(5, "table");
+    i0.ɵɵpipe(6, "rpxTranslate");
+    i0.ɵɵelementStart(7, "thead")(8, "tr")(9, "th");
+    i0.ɵɵtext(10);
+    i0.ɵɵpipe(11, "rpxTranslate");
+    i0.ɵɵelementEnd();
+    i0.ɵɵelementStart(12, "th");
+    i0.ɵɵtext(13);
+    i0.ɵɵpipe(14, "rpxTranslate");
+    i0.ɵɵelementEnd()()();
+    i0.ɵɵelementStart(15, "tbody");
+    i0.ɵɵtemplate(16, CasePrinterComponent_div_0_tr_16_Template, 9, 9, "tr", 3);
+    i0.ɵɵelementEnd()()();
+} if (rf & 2) {
+    const ctx_r1 = i0.ɵɵnextContext();
+    i0.ɵɵadvance();
+    i0.ɵɵproperty("caseDetails", ctx_r1.caseDetails);
+    i0.ɵɵadvance(2);
+    i0.ɵɵtextInterpolate(i0.ɵɵpipeBind1(4, 6, "Print"));
+    i0.ɵɵadvance(2);
+    i0.ɵɵattribute("aria-describedby", i0.ɵɵpipeBind1(6, 8, "case print table"));
+    i0.ɵɵadvance(5);
+    i0.ɵɵtextInterpolate(i0.ɵɵpipeBind1(11, 10, "Name"));
+    i0.ɵɵadvance(3);
+    i0.ɵɵtextInterpolate(i0.ɵɵpipeBind1(14, 12, "Type"));
+    i0.ɵɵadvance(3);
+    i0.ɵɵproperty("ngForOf", ctx_r1.documents);
+} }
+export class CasePrinterComponent {
+    caseNotifier;
+    casesService;
+    alertService;
+    ERROR_MESSAGE = 'No documents to print';
+    caseDetails;
+    documents;
+    caseSubscription;
+    constructor(caseNotifier, casesService, alertService) {
+        this.caseNotifier = caseNotifier;
+        this.casesService = casesService;
+        this.alertService = alertService;
+    }
+    ngOnInit() {
+        this.caseSubscription = this.caseNotifier.caseView.subscribe(caseDetails => {
+            this.caseDetails = caseDetails;
+            this.casesService
+                .getPrintDocuments(this.caseDetails.case_id)
+                .pipe(map(documents => {
+                if (!documents || !documents.length) {
+                    const error = new HttpError();
+                    error.message = this.ERROR_MESSAGE;
+                    throw error;
+                }
+                this.documents = documents;
+            }), catchError(error => {
+                this.alertService.error(error.message);
+                return throwError(error);
+            })).toPromise();
+        });
+    }
+    ngOnDestroy() {
+        if (this.caseSubscription) {
+            this.caseSubscription.unsubscribe();
+        }
+    }
+    isDataLoaded() {
+        return this.caseDetails && this.documents ? true : false;
+    }
+    static ɵfac = function CasePrinterComponent_Factory(t) { return new (t || CasePrinterComponent)(i0.ɵɵdirectiveInject(i1.CaseNotifier), i0.ɵɵdirectiveInject(i2.CasesService), i0.ɵɵdirectiveInject(i3.AlertService)); };
+    static ɵcmp = /*@__PURE__*/ i0.ɵɵdefineComponent({ type: CasePrinterComponent, selectors: [["ng-component"]], decls: 1, vars: 1, consts: [[4, "ngIf"], [3, "caseDetails"], [1, "heading-h2"], [4, "ngFor", "ngForOf"], [1, "document-name"], ["target", "_blank", "rel", "external", 3, "href"], [1, "document-type"]], template: function CasePrinterComponent_Template(rf, ctx) { if (rf & 1) {
+            i0.ɵɵtemplate(0, CasePrinterComponent_div_0_Template, 17, 14, "div", 0);
+        } if (rf & 2) {
+            i0.ɵɵproperty("ngIf", ctx.isDataLoaded());
+        } }, encapsulation: 2 });
+}
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(CasePrinterComponent, [{
+        type: Component,
+        args: [{ template: "<div *ngIf=\"isDataLoaded()\">\n  <ccd-case-header [caseDetails]=\"caseDetails\"></ccd-case-header>\n  <h2 class=\"heading-h2\">{{'Print' | rpxTranslate}}</h2>\n  <table [attr.aria-describedby]=\"'case print table' | rpxTranslate\">\n    <thead>\n      <tr>\n        <th>{{'Name' | rpxTranslate}}</th>\n        <th>{{'Type' | rpxTranslate}}</th>\n      </tr>\n    </thead>\n    <tbody>\n      <tr *ngFor=\"let document of documents\">\n        <td class=\"document-name\"><a [href]=\"document.url | ccdPrintUrl\" target=\"_blank\" rel=\"external\">\n          {{document.name | rpxTranslate}}\n        </a></td>\n        <td class=\"document-type\">{{document.type | rpxTranslate}}</td>\n      </tr>\n    </tbody>\n  </table>\n</div>\n" }]
+    }], () => [{ type: i1.CaseNotifier }, { type: i2.CasesService }, { type: i3.AlertService }], null); })();
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassDebugInfo(CasePrinterComponent, { className: "CasePrinterComponent", filePath: "lib/shared/components/case-viewer/printer/case-printer.component.ts", lineNumber: 14 }); })();
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/shared/components/case-viewer/printer/pipes/print-url.pipe.mjs

@@ -0,0 +1,61 @@
+import { Pipe } from '@angular/core';
+import { AbstractAppConfig } from '../../../../../app.config';
+import * as i0 from "@angular/core";
+import * as i1 from "../../../../../app.config";
+export class PrintUrlPipe {
+    appConfig;
+    static MSIE_BROWSER_NAME = 'MSIE';
+    static IE11_BROWSER_ENGINE = 'Trident';
+    constructor(appConfig) {
+        this.appConfig = appConfig;
+    }
+    /**
+     * Takes a "remote" Print Service URL (for example, as returned by calling the `/documents` CCD endpoint) and
+     * rewrites it into a "local", application-specific URL for the front-end. The resulting URL is of the form:
+     *
+     * Configurable "Local URL" (e.g. `/print`) + _pathname_ from original "remote URL"
+     * (e.g. `/jurisdictions/TEST/case-types/Test1/cases/1111222233334444`)
+     *
+     * @param remoteUrl The "remote" URL to rewrite
+     * @returns A rewritten URL as per the above description, or the original `remoteUrl` if it is `null`, `undefined`,
+     * or the empty string
+     */
+    transform(remoteUrl) {
+        if (remoteUrl?.length > 0) {
+            let printServiceUrlPathname;
+            /**
+             * Check navigator.userAgent to see if the browser is IE or not. Check for either the browser name, "MSIE", or
+             * the rendering engine, "Trident" (used to identify IE 11 because it no longer reports as "MSIE").
+             * Note: IE does not support the URL interface and requires a workaround to parse URLs.
+             */
+            if (navigator.userAgent.indexOf(PrintUrlPipe.MSIE_BROWSER_NAME) !== -1 ||
+                navigator.userAgent.indexOf(PrintUrlPipe.IE11_BROWSER_ENGINE) !== -1) {
+                // Workaround for not being able to use the URL interface
+                const urlParser = document.createElement('a');
+                urlParser.href = remoteUrl;
+                // Get the pathname from the anchor element with the "remote" Print Service URL
+                printServiceUrlPathname = urlParser.pathname;
+                if (printServiceUrlPathname[0] !== '/') {
+                    // Fix for IE11; it returns the pathname without leading slash
+                    printServiceUrlPathname = `/${printServiceUrlPathname}`;
+                }
+            }
+            else {
+                // Get the pathname parsed from the "remote" Print Service URL object
+                printServiceUrlPathname = new URL(remoteUrl).pathname;
+            }
+            // Return an amended URL comprising the "local" Print Service URL (usually /print) and the "remote" pathname
+            return this.appConfig.getPrintServiceUrl() + printServiceUrlPathname;
+        }
+        return remoteUrl;
+    }
+    static ɵfac = function PrintUrlPipe_Factory(t) { return new (t || PrintUrlPipe)(i0.ɵɵdirectiveInject(i1.AbstractAppConfig, 16)); };
+    static ɵpipe = /*@__PURE__*/ i0.ɵɵdefinePipe({ name: "ccdPrintUrl", type: PrintUrlPipe, pure: true });
+}
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(PrintUrlPipe, [{
+        type: Pipe,
+        args: [{
+                name: 'ccdPrintUrl'
+            }]
+    }], () => [{ type: i1.AbstractAppConfig }], null); })();
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/shared/components/case-viewer/services/case.resolver.mjs

@@ -0,0 +1,141 @@
+import { Injectable } from '@angular/core';
+import { NavigationEnd, Router } from '@angular/router';
+import { plainToClassFromExist } from 'class-transformer';
+import { of, throwError } from 'rxjs';
+import { catchError, filter, map } from 'rxjs/operators';
+import { AbstractAppConfig } from '../../../../app.config';
+import { CaseView, Draft } from '../../../domain';
+import { DraftService, NavigationOrigin, SessionStorageService } from '../../../services';
+import { NavigationNotifierService } from '../../../services/navigation/navigation-notifier.service';
+import { CaseNotifier } from '../../case-editor';
+import * as i0 from "@angular/core";
+import * as i1 from "../../case-editor";
+import * as i2 from "../../../services";
+import * as i3 from "../../../services/navigation/navigation-notifier.service";
+import * as i4 from "@angular/router";
+import * as i5 from "../../../../app.config";
+export class CaseResolver {
+    caseNotifier;
+    draftService;
+    navigationNotifierService;
+    router;
+    sessionStorage;
+    appConfig;
+    static EVENT_REGEX = new RegExp('\/trigger\/.*?\/submit$');
+    static PARAM_CASE_ID = 'cid';
+    static CASE_CREATED_MSG = 'The case has been created successfully';
+    static defaultWAPage = '/work/my-work/list';
+    static defaultPage = '/cases';
+    // we need to run the CaseResolver on every child route of 'case/:jid/:ctid/:cid'
+    // this is achieved with runGuardsAndResolvers: 'always' configuration
+    // we cache the case view to avoid retrieving it for each child route
+    previousUrl;
+    constructor(caseNotifier, draftService, navigationNotifierService, router, sessionStorage, appConfig) {
+        this.caseNotifier = caseNotifier;
+        this.draftService = draftService;
+        this.navigationNotifierService = navigationNotifierService;
+        this.router = router;
+        this.sessionStorage = sessionStorage;
+        this.appConfig = appConfig;
+        router.events.pipe(filter(event => event instanceof NavigationEnd))
+            .subscribe((event) => {
+            this.previousUrl = event.url;
+        });
+    }
+    resolve(route) {
+        const cid = route.paramMap.get(CaseResolver.PARAM_CASE_ID);
+        if (!cid) {
+            console.info('No case ID available in the route. Will navigate to case list.');
+            // when redirected to case view after a case created, and the user has no READ access,
+            // the post returns no id
+            this.navigateToCaseList();
+        }
+        else {
+            return this.isRootCaseViewRoute(route) ? this.getAndCacheCaseView(cid)
+                : this.caseNotifier.cachedCaseView ? Promise.resolve(this.caseNotifier.cachedCaseView)
+                    : this.getAndCacheCaseView(cid);
+        }
+    }
+    navigateToCaseList() {
+        this.navigationNotifierService.announceNavigation({ action: NavigationOrigin.NO_READ_ACCESS_REDIRECTION });
+    }
+    isRootCaseViewRoute(route) {
+        // is route case/:jid/:ctid/:cid
+        return ((!route.firstChild || !route.firstChild.url.length) && !this.isTabViewRoute(route));
+    }
+    isTabViewRoute(route) {
+        // is route case/:jid/:ctid/:cid#fragment
+        return route.firstChild && route.firstChild.fragment;
+    }
+    getAndCacheCaseView(cid) {
+        console.info('getAndCacheCaseView started.');
+        if (this.caseNotifier.cachedCaseView && this.caseNotifier.cachedCaseView.case_id && this.caseNotifier.cachedCaseView.case_id === cid) {
+            this.caseNotifier.announceCase(this.caseNotifier.cachedCaseView);
+            console.info('getAndCacheCaseView - Path A.');
+            return of(this.caseNotifier.cachedCaseView).toPromise();
+        }
+        else {
+            if (Draft.isDraft(cid)) {
+                return this.getAndCacheDraft(cid);
+            }
+            else {
+                console.info('getAndCacheCaseView - Path B.');
+                return this.caseNotifier.fetchAndRefresh(cid)
+                    .pipe(catchError(error => this.processErrorInCaseFetch(error, cid)))
+                    .toPromise();
+            }
+        }
+    }
+    getAndCacheDraft(cid) {
+        return this.draftService
+            .getDraft(cid)
+            .pipe(map(caseView => {
+            this.caseNotifier.cachedCaseView = plainToClassFromExist(new CaseView(), caseView);
+            this.caseNotifier.announceCase(this.caseNotifier.cachedCaseView);
+            return this.caseNotifier.cachedCaseView;
+        }), catchError(error => this.processErrorInCaseFetch(error, cid))).toPromise();
+    }
+    processErrorInCaseFetch(error, caseReference) {
+        console.error('!!! processErrorInCaseFetch !!!');
+        console.error(error);
+        // TODO Should be logged to remote logging infrastructure
+        if (error.status === 400) {
+            this.router.navigate(['/search/noresults']);
+            return of(null);
+        }
+        if (CaseResolver.EVENT_REGEX.test(this.previousUrl) && error.status === 404) {
+            this.router.navigate(['/list/case']);
+            return of(null);
+        }
+        // Error 403 and enable-restricted-case-access Launch Darkly flag is enabled, navigate to restricted case access page
+        if (error.status === 403 && this.appConfig.getEnableRestrictedCaseAccessConfig()) {
+            this.router.navigate([`/cases/restricted-case-access/${caseReference}`]);
+            return of(null);
+        }
+        if (error.status !== 401) {
+            this.router.navigate(['/error']);
+        }
+        this.goToDefaultPage();
+        return throwError(error);
+    }
+    // as discussed for EUI-5456, need functionality to go to default page
+    goToDefaultPage() {
+        console.info('Going to default page!');
+        const userDetails = JSON.parse(this.sessionStorage.getItem('userDetails'));
+        userDetails && userDetails.roles
+            && !userDetails.roles.includes('pui-case-manager')
+            &&
+                (userDetails.roles.includes('caseworker-ia-iacjudge')
+                    || userDetails.roles.includes('caseworker-ia-caseofficer')
+                    || userDetails.roles.includes('caseworker-ia-admofficer')
+                    || userDetails.roles.includes('caseworker-civil')
+                    || userDetails.roles.includes('caseworker-privatelaw'))
+            ? this.router.navigate([CaseResolver.defaultWAPage]) : this.router.navigate([CaseResolver.defaultPage]);
+    }
+    static ɵfac = function CaseResolver_Factory(t) { return new (t || CaseResolver)(i0.ɵɵinject(i1.CaseNotifier), i0.ɵɵinject(i2.DraftService), i0.ɵɵinject(i3.NavigationNotifierService), i0.ɵɵinject(i4.Router), i0.ɵɵinject(i2.SessionStorageService), i0.ɵɵinject(i5.AbstractAppConfig)); };
+    static ɵprov = /*@__PURE__*/ i0.ɵɵdefineInjectable({ token: CaseResolver, factory: CaseResolver.ɵfac });
+}
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(CaseResolver, [{
+        type: Injectable
+    }], () => [{ type: i1.CaseNotifier }, { type: i2.DraftService }, { type: i3.NavigationNotifierService }, { type: i4.Router }, { type: i2.SessionStorageService }, { type: i5.AbstractAppConfig }], null); })();
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"case.resolver.js","sourceRoot":"","sources":["../../../../../../../../projects/ccd-case-ui-toolkit/src/lib/shared/components/case-viewer/services/case.resolver.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable } from '@angular/core';\nimport { ActivatedRouteSnapshot, NavigationEnd, Resolve, Router } from '@angular/router';\nimport { plainToClassFromExist } from 'class-transformer';\nimport { of, throwError } from 'rxjs';\nimport { catchError, filter, map } from 'rxjs/operators';\nimport { AbstractAppConfig } from '../../../../app.config';\nimport { CaseView, Draft } from '../../../domain';\nimport { DraftService, NavigationOrigin, SessionStorageService } from '../../../services';\nimport { NavigationNotifierService } from '../../../services/navigation/navigation-notifier.service';\nimport { CaseNotifier } from '../../case-editor';\n\n@Injectable()\nexport class CaseResolver implements Resolve<CaseView> {\n  public static readonly EVENT_REGEX = new RegExp('\\/trigger\\/.*?\\/submit$');\n  public static readonly PARAM_CASE_ID = 'cid';\n  public static readonly CASE_CREATED_MSG = 'The case has been created successfully';\n\n  public static defaultWAPage = '/work/my-work/list';\n  public static defaultPage = '/cases';\n  // we need to run the CaseResolver on every child route of 'case/:jid/:ctid/:cid'\n  // this is achieved with runGuardsAndResolvers: 'always' configuration\n  // we cache the case view to avoid retrieving it for each child route\n  public previousUrl: string;\n  constructor(private caseNotifier: CaseNotifier,\n              private draftService: DraftService,\n              private navigationNotifierService: NavigationNotifierService,\n              private router: Router,\n              private sessionStorage: SessionStorageService,\n              private readonly appConfig: AbstractAppConfig) {\n    router.events.pipe(filter(event => event instanceof NavigationEnd))\n      .subscribe((event: NavigationEnd) => {\n        this.previousUrl = event.url;\n      });\n  }\n\n  public resolve(route: ActivatedRouteSnapshot): Promise<CaseView> {\n    const cid = route.paramMap.get(CaseResolver.PARAM_CASE_ID);\n\n    if (!cid) {\n      console.info('No case ID available in the route. Will navigate to case list.');\n      // when redirected to case view after a case created, and the user has no READ access,\n      // the post returns no id\n      this.navigateToCaseList();\n    } else {\n      return this.isRootCaseViewRoute(route) ? this.getAndCacheCaseView(cid)\n        : this.caseNotifier.cachedCaseView ? Promise.resolve(this.caseNotifier.cachedCaseView)\n        : this.getAndCacheCaseView(cid);\n    }\n  }\n\n  private navigateToCaseList() {\n    this.navigationNotifierService.announceNavigation({action: NavigationOrigin.NO_READ_ACCESS_REDIRECTION});\n  }\n\n  private isRootCaseViewRoute(route: ActivatedRouteSnapshot) {\n    // is route case/:jid/:ctid/:cid\n    return ((!route.firstChild || !route.firstChild.url.length) && !this.isTabViewRoute(route));\n  }\n\n  private isTabViewRoute(route: ActivatedRouteSnapshot) {\n    // is route case/:jid/:ctid/:cid#fragment\n    return route.firstChild && route.firstChild.fragment;\n  }\n\n  private getAndCacheCaseView(cid): Promise<CaseView> {\n    console.info('getAndCacheCaseView started.');\n    if (this.caseNotifier.cachedCaseView && this.caseNotifier.cachedCaseView.case_id && this.caseNotifier.cachedCaseView.case_id === cid) {\n      this.caseNotifier.announceCase(this.caseNotifier.cachedCaseView);\n      console.info('getAndCacheCaseView - Path A.');\n      return of(this.caseNotifier.cachedCaseView).toPromise();\n    } else {\n      if (Draft.isDraft(cid)) {\n        return this.getAndCacheDraft(cid);\n      } else {\n      console.info('getAndCacheCaseView - Path B.');\n        return this.caseNotifier.fetchAndRefresh(cid)\n          .pipe(catchError(error => this.processErrorInCaseFetch(error, cid)))\n          .toPromise();\n      }\n    }\n  }\n\n  private getAndCacheDraft(cid): Promise<CaseView> {\n      return this.draftService\n      .getDraft(cid)\n      .pipe(\n        map(caseView => {\n          this.caseNotifier.cachedCaseView = plainToClassFromExist(new CaseView(), caseView);\n          this.caseNotifier.announceCase(this.caseNotifier.cachedCaseView);\n          return this.caseNotifier.cachedCaseView;\n        }),\n        catchError(error => this.processErrorInCaseFetch(error, cid))\n      ).toPromise();\n  }\n\n  private processErrorInCaseFetch(error: any, caseReference: string) {\n    console.error('!!! processErrorInCaseFetch !!!');\n    console.error(error);\n    // TODO Should be logged to remote logging infrastructure\n    if (error.status === 400) {\n      this.router.navigate(['/search/noresults']);\n      return of(null);\n    }\n    if (CaseResolver.EVENT_REGEX.test(this.previousUrl) && error.status === 404) {\n      this.router.navigate(['/list/case']);\n      return of(null);\n    }\n    // Error 403 and enable-restricted-case-access Launch Darkly flag is enabled, navigate to restricted case access page\n    if (error.status === 403 && this.appConfig.getEnableRestrictedCaseAccessConfig()) {\n      this.router.navigate([`/cases/restricted-case-access/${caseReference}`]);\n      return of(null);\n    }\n    if (error.status !== 401) {\n      this.router.navigate(['/error']);\n    }\n    this.goToDefaultPage();\n    return throwError(error);\n  }\n\n  // as discussed for EUI-5456, need functionality to go to default page\n  private goToDefaultPage(): void {\n    console.info('Going to default page!');\n    const userDetails = JSON.parse(this.sessionStorage.getItem('userDetails'));\n    userDetails && userDetails.roles\n        && !userDetails.roles.includes('pui-case-manager')\n        &&\n        (userDetails.roles.includes('caseworker-ia-iacjudge')\n          || userDetails.roles.includes('caseworker-ia-caseofficer')\n          || userDetails.roles.includes('caseworker-ia-admofficer')\n          || userDetails.roles.includes('caseworker-civil')\n          || userDetails.roles.includes('caseworker-privatelaw'))\n        ? this.router.navigate([CaseResolver.defaultWAPage]) : this.router.navigate([CaseResolver.defaultPage]);\n  }\n}\n"]}