@hmcts/media-viewer 4.1.6-angular-20 → 4.1.7-exui-2986

package/esm2022/lib/toolbar/toolbar-button-visibility.service.mjs

@@ -0,0 +1,94 @@
+import { Injectable } from '@angular/core';
+import * as i0 from "@angular/core";
+export class ToolbarButtonVisibilityService {
+    constructor() {
+        this.showPrint = false;
+        this.showDownload = false;
+        this.showNavigation = false;
+        this.showZoom = false;
+        this.showRotate = false;
+        this.showPresentationMode = false;
+        this.showRedact = false;
+        this.showOpenFile = false;
+        this.showBookmark = false;
+        this.showHighlightButton = false;
+        this.showDrawButton = false;
+        this.showSearchBar = false;
+        this.showSidebar = false;
+        this.showCommentSummary = false;
+        this.showGrabNDragButton = false;
+        this.showSaveRotationButton = false;
+    }
+    /**
+     * Reset the visibility of all buttons to false then set the value from the options
+     */
+    setup(options) {
+        this.showPrint = false;
+        this.showDownload = false;
+        this.showNavigation = false;
+        this.showZoom = false;
+        this.showRotate = false;
+        this.showPresentationMode = false;
+        this.showRedact = false;
+        this.showOpenFile = false;
+        this.showBookmark = false;
+        this.showHighlightButton = false;
+        this.showDrawButton = false;
+        this.showSearchBar = false;
+        this.showSidebar = false;
+        this.showCommentSummary = false;
+        this.showGrabNDragButton = false;
+        this.showSaveRotationButton = false;
+        for (const key in options) {
+            this[key] = options[key];
+        }
+    }
+    /** @nocollapse */ static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: ToolbarButtonVisibilityService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    /** @nocollapse */ static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: ToolbarButtonVisibilityService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: ToolbarButtonVisibilityService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }] });
+/**
+ * Default toolbar state for the PDF viewer
+ */
+export const defaultPdfOptions = {
+    showPrint: true,
+    showDownload: true,
+    showNavigation: true,
+    showZoom: true,
+    showRotate: true,
+    showSearchBar: true,
+    showSidebar: true,
+    showGrabNDragButton: true,
+    showCommentSummary: true,
+    showPresentationMode: true,
+    showRedact: true
+};
+/**
+ * Default toolbar state for the image viewer
+ */
+export const defaultImageOptions = {
+    showPrint: true,
+    showDownload: true,
+    showZoom: true,
+    showRotate: true,
+    showGrabNDragButton: true,
+    showCommentSummary: true,
+    showRedact: true
+};
+/**
+ * Default toolbar state for multimedia
+ */
+export const defaultMultimediaOptions = {
+    showDownload: true
+};
+/**
+ * Default toolbar state for unsupported media
+ */
+export const defaultUnsupportedOptions = {
+    showDownload: true,
+    showPrint: true
+};
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/toolbar/toolbar-event.service.mjs

@@ -0,0 +1,178 @@
+import { Injectable } from '@angular/core';
+import { BehaviorSubject, Subject } from 'rxjs';
+import * as i0 from "@angular/core";
+import * as i1 from "./icp-event.service";
+export var SearchType;
+(function (SearchType) {
+    SearchType["Redact"] = "Redact";
+    SearchType["Highlight"] = "Highlight";
+})(SearchType || (SearchType = {}));
+export class ToolbarEventService {
+    constructor(icpEventService) {
+        this.icpEventService = icpEventService;
+        this.highlightModeSubject = new BehaviorSubject(false);
+        this.highlightToolbarSubject = new BehaviorSubject(false);
+        this.drawModeSubject = new BehaviorSubject(false);
+        this.rotateSubject = new Subject();
+        this.searchSubject = new Subject();
+        this.searchResultsCountSubject = new Subject();
+        this.zoomSubject = new Subject();
+        this.stepZoomSubject = new Subject();
+        this.zoomValueSubject = new BehaviorSubject(1);
+        this.pageCountSubject = new Subject();
+        this.printSubject = new Subject();
+        this.downloadSubject = new Subject();
+        this.setCurrentPageSubject = new Subject();
+        this.setCurrentPageInputValueSubject = new Subject();
+        this.changePageByDeltaSubject = new Subject();
+        this.showCommentSummary = new BehaviorSubject(false);
+        this.grabNDrag = new BehaviorSubject(false);
+        this.saveRotationSubject = new Subject();
+        this.redactionMode = new BehaviorSubject(false);
+        this.redactionPreview = new Subject();
+        this.applyRedactToDocument = new Subject();
+        this.clearAllRedactMarkers = new Subject();
+        this.redactWholePage = new Subject();
+        this.redactionSerachSubject = new Subject();
+        this.redactAllInProgressSubject = new BehaviorSubject(false);
+        this.openRedactionSearch = new BehaviorSubject(null);
+        this.sidebarOpen = new BehaviorSubject(false);
+        this.sidebarOutlineView = new BehaviorSubject(true);
+        this.searchBarHidden = new BehaviorSubject(true);
+        this.commentsPanelVisible = new BehaviorSubject(false);
+    }
+    /**
+     * Reset the stateful behaviour subjects
+     */
+    reset() {
+        this.setCurrentPageSubject.next(1);
+        this.zoomValueSubject.next(1);
+        this.highlightModeSubject.next(false);
+        this.highlightToolbarSubject.next(false);
+        this.drawModeSubject.next(false);
+        this.showCommentSummary.next(false);
+        this.grabNDrag.next(false);
+    }
+    // Function to inform Observers that highlightMode has been enabled
+    toggleHighlightMode() {
+        // Highlight and Draw states are mutually exclusive
+        if (this.highlightModeSubject.getValue() === false) {
+            this.drawModeSubject.next(false);
+            this.grabNDrag.next(false);
+            this.highlightModeSubject.next(true);
+        }
+        else {
+            this.highlightModeSubject.next(false);
+        }
+    }
+    // Function to inform Observers that ToggleMode has been enabled
+    toggleDrawMode() {
+        if (this.drawModeSubject.getValue() === false) {
+            this.highlightModeSubject.next(false);
+            this.grabNDrag.next(false);
+            this.drawModeSubject.next(true);
+        }
+        else {
+            this.drawModeSubject.next(false);
+        }
+    }
+    toggleHighlightToolbar() {
+        this.highlightToolbarSubject.next(!this.highlightToolbarSubject.getValue());
+    }
+    rotate(angle) {
+        this.rotateSubject.next(angle);
+    }
+    search(phrase) {
+        this.searchSubject.next(phrase);
+    }
+    getSearchResultsCount() {
+        return this.searchResultsCountSubject.asObservable();
+    }
+    zoom(value) {
+        this.zoomSubject.next(value);
+    }
+    stepZoom(value) {
+        this.stepZoomSubject.next(value);
+    }
+    getZoomValue() {
+        return this.zoomValueSubject.asObservable();
+    }
+    getPageCount() {
+        return this.pageCountSubject.asObservable();
+    }
+    print() {
+        this.printSubject.next();
+    }
+    download() {
+        this.downloadSubject.next();
+    }
+    setPage(value) {
+        this.setCurrentPageSubject.next(value);
+    }
+    incrementPage(value) {
+        this.changePageByDeltaSubject.next(value);
+    }
+    getCurrentPageNumber() {
+        return this.setCurrentPageInputValueSubject.asObservable();
+    }
+    getShowCommentSummary() {
+        return this.showCommentSummary.asObservable();
+    }
+    toggleCommentsSummary(value) {
+        this.showCommentSummary.next(value);
+    }
+    saveRotation() {
+        this.saveRotationSubject.next();
+    }
+    toggleGrabNDrag() {
+        this.grabNDrag.next(!this.grabNDrag.getValue());
+    }
+    toggleSideBar(toggle) {
+        this.sidebarOpen.next(toggle);
+    }
+    toggleSideBarView(toggle) {
+        this.sidebarOutlineView.next(toggle);
+    }
+    toggleRedactionMode() {
+        if (this.redactionMode.getValue() === false) {
+            this.drawModeSubject.next(false);
+            this.grabNDrag.next(false);
+            this.redactionMode.next(true);
+        }
+        else {
+            this.redactionMode.next(false);
+        }
+        this.openRedactionSearch.next({ modeType: SearchType.Redact, isOpen: false });
+    }
+    toggleRedactionPreview(viewMode) {
+        this.redactionPreview.next(viewMode);
+    }
+    unmarkAll() {
+        this.clearAllRedactMarkers.next();
+    }
+    applyRedactionToDocument() {
+        this.applyRedactToDocument.next();
+    }
+    redactPage() {
+        this.redactWholePage.next();
+    }
+    toggleCommentsPanel(isVisible) {
+        if (isVisible) {
+            this.toggleParticipantsList(!isVisible);
+        }
+        this.commentsPanelVisible.next(isVisible);
+    }
+    toggleParticipantsList(isVisible) {
+        if (isVisible) {
+            this.toggleCommentsPanel(!isVisible);
+        }
+        this.icpEventService.participantsListVisible.next(isVisible);
+    }
+    /** @nocollapse */ static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: ToolbarEventService, deps: [{ token: i1.IcpEventService }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    /** @nocollapse */ static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: ToolbarEventService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: ToolbarEventService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }], ctorParameters: () => [{ type: i1.IcpEventService }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"toolbar-event.service.js","sourceRoot":"","sources":["../../../../../projects/media-viewer/src/lib/toolbar/toolbar-event.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable } from '@angular/core';\nimport { BehaviorSubject, Observable, Subject } from 'rxjs';\n// import * as icpEvents from './icp-event.service';\n// import { participantsListVisible } from './icp-event.service';\nimport { RedactionSearch } from './redaction-search-bar/redaction-search.model';\nimport { IcpEventService } from './icp-event.service';\n\n// Toolbar Custom-Event Types\nexport type HighlightMode = boolean;\nexport type DrawMode = boolean;\nexport interface SearchOperation {\n  searchTerm: string;\n  highlightAll: boolean;\n  matchCase: boolean;\n  wholeWord: boolean;\n  previous: boolean;\n  reset: boolean;\n}\nexport interface SearchResultsCount {\n  current: number;\n  total: number;\n  isPrevious: boolean;\n}\n\nexport enum SearchType {\n  Redact = 'Redact',\n  Highlight = 'Highlight',\n}\n\nexport interface SearchMode {\n  modeType: SearchType;\n  isOpen: boolean;\n}\n\n@Injectable({ providedIn: 'root' })\nexport class ToolbarEventService {\n\n  constructor(private icpEventService: IcpEventService) {}\n\n  public readonly highlightModeSubject = new BehaviorSubject<HighlightMode>(false);\n  public readonly highlightToolbarSubject = new BehaviorSubject<HighlightMode>(false);\n  public readonly drawModeSubject = new BehaviorSubject<DrawMode>(false);\n  public readonly rotateSubject = new Subject<number>();\n  public readonly searchSubject = new Subject<SearchOperation>();\n  public readonly searchResultsCountSubject = new Subject<SearchResultsCount>();\n  public readonly zoomSubject = new Subject<number>();\n  public readonly stepZoomSubject = new Subject<number>();\n  public readonly zoomValueSubject = new BehaviorSubject<number>(1);\n  public readonly pageCountSubject = new Subject<number>();\n  public readonly printSubject = new Subject<void>();\n  public readonly downloadSubject = new Subject<void>();\n  public readonly setCurrentPageSubject = new Subject<number>();\n  public readonly setCurrentPageInputValueSubject = new Subject<number>();\n  public readonly changePageByDeltaSubject = new Subject<number>();\n  public readonly showCommentSummary = new BehaviorSubject<boolean>(false);\n  public readonly grabNDrag = new BehaviorSubject<boolean>(false);\n  public readonly saveRotationSubject = new Subject<void>();\n\n  public readonly redactionMode = new BehaviorSubject(false);\n  public readonly redactionPreview = new Subject<boolean>();\n  public readonly applyRedactToDocument = new Subject<void>();\n\n  public readonly clearAllRedactMarkers = new Subject<void>();\n  public readonly redactWholePage = new Subject<void>();\n  public readonly redactionSerachSubject = new Subject<RedactionSearch>();\n  public readonly redactAllInProgressSubject = new BehaviorSubject(false);\n  public readonly openRedactionSearch = new BehaviorSubject<SearchMode | null>(null);\n\n  public readonly sidebarOpen = new BehaviorSubject(false);\n  public readonly sidebarOutlineView = new BehaviorSubject(true);\n\n  public readonly searchBarHidden = new BehaviorSubject(true);\n  public readonly commentsPanelVisible = new BehaviorSubject(false);\n\n  /**\n   * Reset the stateful behaviour subjects\n   */\n  public reset(): void {\n    this.setCurrentPageSubject.next(1);\n    this.zoomValueSubject.next(1);\n    this.highlightModeSubject.next(false);\n    this.highlightToolbarSubject.next(false);\n    this.drawModeSubject.next(false);\n    this.showCommentSummary.next(false);\n    this.grabNDrag.next(false);\n  }\n\n  // Function to inform Observers that highlightMode has been enabled\n  public toggleHighlightMode(): void {\n    // Highlight and Draw states are mutually exclusive\n    if (this.highlightModeSubject.getValue() === false) {\n      this.drawModeSubject.next(false);\n      this.grabNDrag.next(false);\n      this.highlightModeSubject.next(true);\n    } else {\n      this.highlightModeSubject.next(false);\n    }\n  }\n\n  // Function to inform Observers that ToggleMode has been enabled\n  public toggleDrawMode(): void {\n    if (this.drawModeSubject.getValue() === false) {\n      this.highlightModeSubject.next(false);\n      this.grabNDrag.next(false);\n      this.drawModeSubject.next(true);\n    } else {\n      this.drawModeSubject.next(false);\n    }\n  }\n\n  public toggleHighlightToolbar(): void {\n    this.highlightToolbarSubject.next(!this.highlightToolbarSubject.getValue());\n  }\n\n  public rotate(angle: number): void {\n    this.rotateSubject.next(angle);\n  }\n\n  public search(phrase: SearchOperation): void {\n    this.searchSubject.next(phrase);\n  }\n\n  public getSearchResultsCount(): Observable<SearchResultsCount> {\n    return this.searchResultsCountSubject.asObservable();\n  }\n\n  public zoom(value: number): void {\n    this.zoomSubject.next(value);\n  }\n\n  public stepZoom(value: number): void {\n    this.stepZoomSubject.next(value);\n  }\n\n  public getZoomValue(): Observable<number> {\n    return this.zoomValueSubject.asObservable();\n  }\n\n  public getPageCount(): Observable<number> {\n    return this.pageCountSubject.asObservable();\n  }\n\n  public print(): void {\n    this.printSubject.next();\n  }\n\n  public download(): void {\n    this.downloadSubject.next();\n  }\n\n  public setPage(value: number): void {\n    this.setCurrentPageSubject.next(value);\n  }\n\n  public incrementPage(value: number): void {\n    this.changePageByDeltaSubject.next(value);\n  }\n\n  public getCurrentPageNumber(): Observable<number> {\n    return this.setCurrentPageInputValueSubject.asObservable();\n  }\n\n  public getShowCommentSummary(): Observable<boolean> {\n    return this.showCommentSummary.asObservable();\n  }\n\n  public toggleCommentsSummary(value: boolean): void {\n    this.showCommentSummary.next(value);\n  }\n\n  public saveRotation(): void {\n    this.saveRotationSubject.next();\n  }\n\n  public toggleGrabNDrag(): void {\n    this.grabNDrag.next(!this.grabNDrag.getValue());\n  }\n\n  toggleSideBar(toggle: boolean) {\n    this.sidebarOpen.next(toggle);\n  }\n\n  toggleSideBarView(toggle: boolean) {\n    this.sidebarOutlineView.next(toggle);\n  }\n\n  public toggleRedactionMode(): void {\n    if (this.redactionMode.getValue() === false) {\n      this.drawModeSubject.next(false);\n      this.grabNDrag.next(false);\n      this.redactionMode.next(true);\n    } else {\n      this.redactionMode.next(false);\n    }\n    this.openRedactionSearch.next({ modeType: SearchType.Redact, isOpen: false });\n  }\n\n  public toggleRedactionPreview(viewMode: boolean): void {\n    this.redactionPreview.next(viewMode);\n  }\n\n  public unmarkAll(): void {\n    this.clearAllRedactMarkers.next();\n  }\n\n  public applyRedactionToDocument(): void {\n    this.applyRedactToDocument.next();\n  }\n\n  public redactPage(): void {\n    this.redactWholePage.next();\n  }\n\n  public toggleCommentsPanel(isVisible: boolean) {\n    if (isVisible) {\n      this.toggleParticipantsList(!isVisible);\n    }\n    this.commentsPanelVisible.next(isVisible);\n  }\n\n  public toggleParticipantsList(isVisible: boolean) {\n    if (isVisible) {\n      this.toggleCommentsPanel(!isVisible);\n    }\n    this.icpEventService.participantsListVisible.next(isVisible);\n  }\n}\n"]}

package/esm2022/lib/toolbar/toolbar.module.mjs

@@ -0,0 +1,72 @@
+import { RedactionSearchBarComponent } from './redaction-search-bar/redaction-search-bar.component';
+import { NgModule } from '@angular/core';
+import { CommonModule } from '@angular/common';
+import { MainToolbarComponent } from './main-toolbar/main-toolbar.component';
+import { SearchBarComponent } from './search-bar/search-bar.component';
+import { FormsModule } from '@angular/forms';
+import { ToolbarButtonVisibilityService } from './toolbar-button-visibility.service';
+import { RedactionToolbarComponent } from './redaction-toolbar/redaction-toolbar.component';
+import { IcpToolbarComponent } from './icp-toolbar/icp-toolbar.component';
+import { OverlayModule } from '@angular/cdk/overlay';
+import { RouterModule } from '@angular/router';
+import { HighlightToolbarComponent } from './highlight-toolbar/highlight-toolbar.component';
+import { RpxTranslationModule } from 'rpx-xui-translation';
+import * as i0 from "@angular/core";
+import * as i1 from "rpx-xui-translation";
+export { ToolbarButtonVisibilityService } from './toolbar-button-visibility.service';
+export class ToolbarModule {
+    /** @nocollapse */ static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: ToolbarModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }
+    /** @nocollapse */ static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "18.2.13", ngImport: i0, type: ToolbarModule, declarations: [SearchBarComponent,
+            MainToolbarComponent,
+            RedactionToolbarComponent,
+            IcpToolbarComponent,
+            RedactionSearchBarComponent,
+            HighlightToolbarComponent], imports: [CommonModule,
+            FormsModule,
+            OverlayModule,
+            RouterModule, i1.RpxTranslationModule], exports: [MainToolbarComponent,
+            SearchBarComponent,
+            RedactionToolbarComponent,
+            IcpToolbarComponent,
+            RedactionSearchBarComponent,
+            HighlightToolbarComponent] }); }
+    /** @nocollapse */ static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: ToolbarModule, providers: [
+            ToolbarButtonVisibilityService
+        ], imports: [CommonModule,
+            FormsModule,
+            OverlayModule,
+            RouterModule,
+            RpxTranslationModule.forChild()] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: ToolbarModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    declarations: [
+                        SearchBarComponent,
+                        MainToolbarComponent,
+                        RedactionToolbarComponent,
+                        IcpToolbarComponent,
+                        RedactionSearchBarComponent,
+                        HighlightToolbarComponent
+                    ],
+                    providers: [
+                        ToolbarButtonVisibilityService
+                    ],
+                    exports: [
+                        MainToolbarComponent,
+                        SearchBarComponent,
+                        RedactionToolbarComponent,
+                        IcpToolbarComponent,
+                        RedactionSearchBarComponent,
+                        HighlightToolbarComponent
+                    ],
+                    imports: [
+                        CommonModule,
+                        FormsModule,
+                        OverlayModule,
+                        RouterModule,
+                        RpxTranslationModule.forChild(),
+                    ]
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/viewers/convertible-content-viewer/convertible-content-viewer.component.mjs

@@ -0,0 +1,82 @@
+import { Component, EventEmitter, Input, Output, ViewEncapsulation } from '@angular/core';
+import { ViewerException } from '../viewer-exception.model';
+import { select } from '@ngrx/store';
+import * as fromDocumentActions from '../../store/actions/document.actions';
+import * as fromSelectors from '../../store/selectors/document.selectors';
+import { filter } from 'rxjs/operators';
+import * as i0 from "@angular/core";
+import * as i1 from "@ngrx/store";
+import * as i2 from "@angular/common";
+import * as i3 from "../pdf-viewer/pdf-viewer.component";
+export class ConvertibleContentViewerComponent {
+    constructor(store) {
+        this.store = store;
+        this.mediaLoadStatus = new EventEmitter();
+        this.viewerException = new EventEmitter();
+        this.documentTitle = new EventEmitter();
+    }
+    ngOnInit() {
+        this.$subscription = this.store.pipe(select(fromSelectors.getConvertedDocument), filter(value => !!value))
+            .subscribe((docInfo) => {
+            if (docInfo.url) {
+                this.convertedUrl = docInfo.url;
+                this.store.dispatch(new fromDocumentActions.ClearConvertDocUrl());
+            }
+            else {
+                this.onLoadException(new ViewerException(docInfo.error));
+            }
+        });
+    }
+    ngOnChanges(changes) {
+        if (changes.originalUrl?.currentValue && changes.originalUrl.currentValue !== changes.originalUrl.previousValue) {
+            this.store.dispatch(new fromDocumentActions.Convert(this.extractDMStoreDocId(this.originalUrl)));
+        }
+    }
+    ngOnDestroy() {
+        this.$subscription.unsubscribe();
+    }
+    onMediaLoad(status) {
+        this.mediaLoadStatus.emit(status);
+    }
+    onLoadException(exception) {
+        this.viewerException.emit(exception);
+    }
+    onDocumentTitleChange(title) {
+        this.documentTitle.emit(title);
+    }
+    // todo move this to common place for media viewer and pdf
+    extractDMStoreDocId(url) {
+        if (url.includes('/documents/')) {
+            url = url.split('/documents/')[1];
+        }
+        else if (url.includes('/documentsv2/')) {
+            url = url.split('/documentsv2/')[1];
+        }
+        return url.replace('/binary', '');
+    }
+    /** @nocollapse */ static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: ConvertibleContentViewerComponent, deps: [{ token: i1.Store }], target: i0.ɵɵFactoryTarget.Component }); }
+    /** @nocollapse */ static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "18.2.13", type: ConvertibleContentViewerComponent, selector: "mv-conversion-viewer", inputs: { originalUrl: "originalUrl", downloadFileName: "downloadFileName", height: "height", enableAnnotations: "enableAnnotations", enableRedactions: "enableRedactions", annotationSet: "annotationSet" }, outputs: { mediaLoadStatus: "mediaLoadStatus", viewerException: "viewerException", documentTitle: "documentTitle" }, usesOnChanges: true, ngImport: i0, template: "<mv-pdf-viewer *ngIf=\"convertedUrl\"\n               (mediaLoadStatus)=\"onMediaLoad($event)\"\n               (pdfViewerException)=\"onLoadException($event)\"\n               (documentTitle)=\"onDocumentTitleChange($event)\"\n               [url]=\"convertedUrl\"\n               [downloadUrl]=\"originalUrl\"\n               [enableAnnotations]=\"enableAnnotations\"\n               [enableRedactions]=\"enableRedactions\"\n               [annotationSet]=\"enableAnnotations ? annotationSet : null\"\n               [downloadFileName]=\"downloadFileName\"\n               [height]=\"height\">\n</mv-pdf-viewer>\n", dependencies: [{ kind: "directive", type: i2.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { kind: "component", type: i3.PdfViewerComponent, selector: "mv-pdf-viewer", inputs: ["downloadUrl", "url", "downloadFileName", "enableAnnotations", "enableRedactions", "enableICP", "annotationSet", "enableRedactSearch", "height", "caseId", "searchBarHidden"], outputs: ["mediaLoadStatus", "pdfViewerException", "documentTitle"] }], encapsulation: i0.ViewEncapsulation.None }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: ConvertibleContentViewerComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'mv-conversion-viewer', encapsulation: ViewEncapsulation.None, template: "<mv-pdf-viewer *ngIf=\"convertedUrl\"\n               (mediaLoadStatus)=\"onMediaLoad($event)\"\n               (pdfViewerException)=\"onLoadException($event)\"\n               (documentTitle)=\"onDocumentTitleChange($event)\"\n               [url]=\"convertedUrl\"\n               [downloadUrl]=\"originalUrl\"\n               [enableAnnotations]=\"enableAnnotations\"\n               [enableRedactions]=\"enableRedactions\"\n               [annotationSet]=\"enableAnnotations ? annotationSet : null\"\n               [downloadFileName]=\"downloadFileName\"\n               [height]=\"height\">\n</mv-pdf-viewer>\n" }]
+        }], ctorParameters: () => [{ type: i1.Store }], propDecorators: { originalUrl: [{
+                type: Input
+            }], downloadFileName: [{
+                type: Input
+            }], height: [{
+                type: Input
+            }], enableAnnotations: [{
+                type: Input
+            }], enableRedactions: [{
+                type: Input
+            }], annotationSet: [{
+                type: Input
+            }], mediaLoadStatus: [{
+                type: Output
+            }], viewerException: [{
+                type: Output
+            }], documentTitle: [{
+                type: Output
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"convertible-content-viewer.component.js","sourceRoot":"","sources":["../../../../../../projects/media-viewer/src/lib/viewers/convertible-content-viewer/convertible-content-viewer.component.ts","../../../../../../projects/media-viewer/src/lib/viewers/convertible-content-viewer/convertible-content-viewer.component.html"],"names":[],"mappings":"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","sourcesContent":["import { Component, EventEmitter, Input, OnChanges, OnDestroy, OnInit, Output, SimpleChanges, ViewEncapsulation } from '@angular/core';\nimport { ResponseType, ViewerException } from '../viewer-exception.model';\nimport { select, Store } from '@ngrx/store';\nimport * as fromStore from '../../store/reducers/document.reducer';\nimport * as fromDocumentActions from '../../store/actions/document.actions';\nimport { Subscription } from 'rxjs';\nimport * as fromSelectors from '../../store/selectors/document.selectors';\nimport { AnnotationSet } from '../../annotations/annotation-set/annotation-set.model';\nimport { filter } from 'rxjs/operators';\n\n@Component({\n  selector: 'mv-conversion-viewer',\n  templateUrl: './convertible-content-viewer.component.html',\n  encapsulation: ViewEncapsulation.None\n})\nexport class ConvertibleContentViewerComponent implements OnInit, OnDestroy, OnChanges {\n\n  @Input() originalUrl;\n  @Input() downloadFileName: string;\n\n  @Input() height;\n\n  @Input() enableAnnotations: boolean;\n  @Input() enableRedactions: boolean;\n  @Input() annotationSet: AnnotationSet | null;\n\n\n  @Output() mediaLoadStatus = new EventEmitter<ResponseType>();\n  @Output() viewerException = new EventEmitter<ViewerException>();\n  @Output() documentTitle = new EventEmitter<string>();\n\n  private $subscription: Subscription;\n  convertedUrl: string;\n\n  constructor(private store: Store<fromStore.DocumentState>) {\n  }\n\n  ngOnInit(): void {\n    this.$subscription = this.store.pipe(select(fromSelectors.getConvertedDocument), filter(value => !!value))\n      .subscribe((docInfo) => {\n        if (docInfo.url) {\n          this.convertedUrl = docInfo.url;\n          this.store.dispatch(new fromDocumentActions.ClearConvertDocUrl());\n        } else {\n          this.onLoadException(new ViewerException(docInfo.error));\n        }\n      });\n  }\n\n  ngOnChanges(changes: SimpleChanges) {\n    if (changes.originalUrl?.currentValue && changes.originalUrl.currentValue !== changes.originalUrl.previousValue) {\n      this.store.dispatch(new fromDocumentActions.Convert(this.extractDMStoreDocId(this.originalUrl)));\n    }\n  }\n\n  ngOnDestroy(): void {\n    this.$subscription.unsubscribe();\n  }\n\n  onMediaLoad(status: ResponseType) {\n    this.mediaLoadStatus.emit(status);\n  }\n\n  onLoadException(exception: ViewerException) {\n    this.viewerException.emit(exception);\n  }\n\n  onDocumentTitleChange(title: string) {\n    this.documentTitle.emit(title);\n  }\n\n  // todo move this to common place for media viewer and pdf\n  private extractDMStoreDocId(url: string): string {\n\n    if (url.includes('/documents/')) {\n      url = url.split('/documents/')[1];\n    } else if (url.includes('/documentsv2/')) {\n      url = url.split('/documentsv2/')[1];\n    }\n    return url.replace('/binary', '');\n  }\n}\n","<mv-pdf-viewer *ngIf=\"convertedUrl\"\n               (mediaLoadStatus)=\"onMediaLoad($event)\"\n               (pdfViewerException)=\"onLoadException($event)\"\n               (documentTitle)=\"onDocumentTitleChange($event)\"\n               [url]=\"convertedUrl\"\n               [downloadUrl]=\"originalUrl\"\n               [enableAnnotations]=\"enableAnnotations\"\n               [enableRedactions]=\"enableRedactions\"\n               [annotationSet]=\"enableAnnotations ? annotationSet : null\"\n               [downloadFileName]=\"downloadFileName\"\n               [height]=\"height\">\n</mv-pdf-viewer>\n"]}

package/esm2022/lib/viewers/convertible-content-viewer/document-conversion-api.service.mjs

@@ -0,0 +1,22 @@
+import { Injectable } from '@angular/core';
+import { of } from 'rxjs';
+import { catchError, map } from 'rxjs/operators';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common/http";
+export class DocumentConversionApiService {
+    constructor(httpClient) {
+        this.httpClient = httpClient;
+        this.documentConversionUrl = '/doc-assembly/convert';
+    }
+    convert(documentId) {
+        return this.httpClient
+            .post(`${this.documentConversionUrl}/${documentId}`, {}, { observe: 'response', withCredentials: true, responseType: 'blob' })
+            .pipe(map(response => response), catchError(error => of(error)));
+    }
+    /** @nocollapse */ static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: DocumentConversionApiService, deps: [{ token: i1.HttpClient }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    /** @nocollapse */ static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: DocumentConversionApiService }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: DocumentConversionApiService, decorators: [{
+            type: Injectable
+        }], ctorParameters: () => [{ type: i1.HttpClient }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/viewers/grab-n-drag.directive.mjs

@@ -0,0 +1,57 @@
+import { Directive, HostListener, Input } from '@angular/core';
+import * as i0 from "@angular/core";
+export class GrabNDragDirective {
+    constructor(el) {
+        this.el = el;
+        this.pointerDown = false;
+        this.dragEnabled = false;
+    }
+    onPointerDown(event) {
+        if (this.dragEnabled) {
+            event.preventDefault();
+            this.pointerDown = true;
+            this.originalPosition = {
+                left: event.clientX + this.el.nativeElement.scrollLeft,
+                top: event.clientY + this.el.nativeElement.scrollTop,
+            };
+        }
+    }
+    onPointerMove(event) {
+        if (this.pointerDown && this.dragEnabled) {
+            event.preventDefault();
+            const scrollDiff = {
+                left: this.originalPosition.left - (event.clientX + this.el.nativeElement.scrollLeft),
+                top: this.originalPosition.top - (event.clientY + this.el.nativeElement.scrollTop)
+            };
+            if (this.dragEnabled) {
+                this.dragX.scrollLeft += scrollDiff.left;
+                this.el.nativeElement.scrollTop += scrollDiff.top;
+            }
+        }
+    }
+    onWindowPointerUp() {
+        this.pointerDown = false;
+    }
+    /** @nocollapse */ static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: GrabNDragDirective, deps: [{ token: i0.ElementRef }], target: i0.ɵɵFactoryTarget.Directive }); }
+    /** @nocollapse */ static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "18.2.13", type: GrabNDragDirective, selector: "[mvGrabNDrag]", inputs: { dragEnabled: "dragEnabled", dragX: "dragX" }, host: { listeners: { "pointerdown": "onPointerDown($event)", "window:pointermove": "onPointerMove($event)", "window:pointerup": "onWindowPointerUp()" } }, ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: GrabNDragDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[mvGrabNDrag]'
+                }]
+        }], ctorParameters: () => [{ type: i0.ElementRef }], propDecorators: { dragEnabled: [{
+                type: Input
+            }], dragX: [{
+                type: Input
+            }], onPointerDown: [{
+                type: HostListener,
+                args: ['pointerdown', ['$event']]
+            }], onPointerMove: [{
+                type: HostListener,
+                args: ['window:pointermove', ['$event']]
+            }], onWindowPointerUp: [{
+                type: HostListener,
+                args: ['window:pointerup']
+            }] } });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZ3JhYi1uLWRyYWcuZGlyZWN0aXZlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vcHJvamVjdHMvbWVkaWEtdmlld2VyL3NyYy9saWIvdmlld2Vycy9ncmFiLW4tZHJhZy5kaXJlY3RpdmUudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLFNBQVMsRUFBYyxZQUFZLEVBQUUsS0FBSyxFQUFFLE1BQU0sZUFBZSxDQUFDOztBQU0zRSxNQUFNLE9BQU8sa0JBQWtCO0lBUTdCLFlBQW9CLEVBQWM7UUFBZCxPQUFFLEdBQUYsRUFBRSxDQUFZO1FBTDFCLGdCQUFXLEdBQUcsS0FBSyxDQUFDO1FBRW5CLGdCQUFXLEdBQUcsS0FBSyxDQUFDO0lBSTdCLENBQUM7SUFHRCxhQUFhLENBQUMsS0FBbUI7UUFDL0IsSUFBSSxJQUFJLENBQUMsV0FBVyxFQUFFLENBQUM7WUFDckIsS0FBSyxDQUFDLGNBQWMsRUFBRSxDQUFDO1lBQ3ZCLElBQUksQ0FBQyxXQUFXLEdBQUcsSUFBSSxDQUFDO1lBQ3hCLElBQUksQ0FBQyxnQkFBZ0IsR0FBRztnQkFDdEIsSUFBSSxFQUFFLEtBQUssQ0FBQyxPQUFPLEdBQUcsSUFBSSxDQUFDLEVBQUUsQ0FBQyxhQUFhLENBQUMsVUFBVTtnQkFDdEQsR0FBRyxFQUFFLEtBQUssQ0FBQyxPQUFPLEdBQUcsSUFBSSxDQUFDLEVBQUUsQ0FBQyxhQUFhLENBQUMsU0FBUzthQUNyRCxDQUFDO1FBQ0osQ0FBQztJQUNILENBQUM7SUFHRCxhQUFhLENBQUMsS0FBbUI7UUFDL0IsSUFBSSxJQUFJLENBQUMsV0FBVyxJQUFJLElBQUksQ0FBQyxXQUFXLEVBQUUsQ0FBQztZQUN6QyxLQUFLLENBQUMsY0FBYyxFQUFFLENBQUM7WUFDdkIsTUFBTSxVQUFVLEdBQUc7Z0JBQ2pCLElBQUksRUFBRSxJQUFJLENBQUMsZ0JBQWdCLENBQUMsSUFBSSxHQUFHLENBQUMsS0FBSyxDQUFDLE9BQU8sR0FBRyxJQUFJLENBQUMsRUFBRSxDQUFDLGFBQWEsQ0FBQyxVQUFVLENBQUM7Z0JBQ3JGLEdBQUcsRUFBRSxJQUFJLENBQUMsZ0JBQWdCLENBQUMsR0FBRyxHQUFHLENBQUMsS0FBSyxDQUFDLE9BQU8sR0FBRyxJQUFJLENBQUMsRUFBRSxDQUFDLGFBQWEsQ0FBQyxTQUFTLENBQUM7YUFDbkYsQ0FBQztZQUNGLElBQUksSUFBSSxDQUFDLFdBQVcsRUFBRSxDQUFDO2dCQUNyQixJQUFJLENBQUMsS0FBSyxDQUFDLFVBQVUsSUFBSSxVQUFVLENBQUMsSUFBSSxDQUFDO2dCQUN6QyxJQUFJLENBQUMsRUFBRSxDQUFDLGFBQWEsQ0FBQyxTQUFTLElBQUksVUFBVSxDQUFDLEdBQUcsQ0FBQztZQUNwRCxDQUFDO1FBQ0gsQ0FBQztJQUNILENBQUM7SUFFaUMsaUJBQWlCO1FBQ2pELElBQUksQ0FBQyxXQUFXLEdBQUcsS0FBSyxDQUFDO0lBQzNCLENBQUM7a0lBeENVLGtCQUFrQjtzSEFBbEIsa0JBQWtCOzs0RkFBbEIsa0JBQWtCO2tCQUg5QixTQUFTO21CQUFDO29CQUNULFFBQVEsRUFBRSxlQUFlO2lCQUMxQjsrRUFNVSxXQUFXO3NCQUFuQixLQUFLO2dCQUNHLEtBQUs7c0JBQWIsS0FBSztnQkFNTixhQUFhO3NCQURaLFlBQVk7dUJBQUMsYUFBYSxFQUFFLENBQUMsUUFBUSxDQUFDO2dCQWF2QyxhQUFhO3NCQURaLFlBQVk7dUJBQUMsb0JBQW9CLEVBQUUsQ0FBQyxRQUFRLENBQUM7Z0JBZVosaUJBQWlCO3NCQUFsRCxZQUFZO3VCQUFDLGtCQUFrQiIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IERpcmVjdGl2ZSwgRWxlbWVudFJlZiwgSG9zdExpc3RlbmVyLCBJbnB1dCB9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xuXG5cbkBEaXJlY3RpdmUoe1xuICBzZWxlY3RvcjogJ1ttdkdyYWJORHJhZ10nXG59KVxuZXhwb3J0IGNsYXNzIEdyYWJORHJhZ0RpcmVjdGl2ZSB7XG5cbiAgb3JpZ2luYWxQb3NpdGlvbjogeyBsZWZ0OiBudW1iZXI7IHRvcDogbnVtYmVyIH07XG4gIHByaXZhdGUgcG9pbnRlckRvd24gPSBmYWxzZTtcblxuICBASW5wdXQoKSBkcmFnRW5hYmxlZCA9IGZhbHNlO1xuICBASW5wdXQoKSBkcmFnWDogRWxlbWVudDtcblxuICBjb25zdHJ1Y3Rvcihwcml2YXRlIGVsOiBFbGVtZW50UmVmKSB7XG4gIH1cblxuICBASG9zdExpc3RlbmVyKCdwb2ludGVyZG93bicsIFsnJGV2ZW50J10pXG4gIG9uUG9pbnRlckRvd24oZXZlbnQ6IFBvaW50ZXJFdmVudCkge1xuICAgIGlmICh0aGlzLmRyYWdFbmFibGVkKSB7XG4gICAgICBldmVudC5wcmV2ZW50RGVmYXVsdCgpO1xuICAgICAgdGhpcy5wb2ludGVyRG93biA9IHRydWU7XG4gICAgICB0aGlzLm9yaWdpbmFsUG9zaXRpb24gPSB7XG4gICAgICAgIGxlZnQ6IGV2ZW50LmNsaWVudFggKyB0aGlzLmVsLm5hdGl2ZUVsZW1lbnQuc2Nyb2xsTGVmdCxcbiAgICAgICAgdG9wOiBldmVudC5jbGllbnRZICsgdGhpcy5lbC5uYXRpdmVFbGVtZW50LnNjcm9sbFRvcCxcbiAgICAgIH07XG4gICAgfVxuICB9XG5cbiAgQEhvc3RMaXN0ZW5lcignd2luZG93OnBvaW50ZXJtb3ZlJywgWyckZXZlbnQnXSlcbiAgb25Qb2ludGVyTW92ZShldmVudDogUG9pbnRlckV2ZW50KSB7XG4gICAgaWYgKHRoaXMucG9pbnRlckRvd24gJiYgdGhpcy5kcmFnRW5hYmxlZCkge1xuICAgICAgZXZlbnQucHJldmVudERlZmF1bHQoKTtcbiAgICAgIGNvbnN0IHNjcm9sbERpZmYgPSB7XG4gICAgICAgIGxlZnQ6IHRoaXMub3JpZ2luYWxQb3NpdGlvbi5sZWZ0IC0gKGV2ZW50LmNsaWVudFggKyB0aGlzLmVsLm5hdGl2ZUVsZW1lbnQuc2Nyb2xsTGVmdCksXG4gICAgICAgIHRvcDogdGhpcy5vcmlnaW5hbFBvc2l0aW9uLnRvcCAtIChldmVudC5jbGllbnRZICsgdGhpcy5lbC5uYXRpdmVFbGVtZW50LnNjcm9sbFRvcClcbiAgICAgIH07XG4gICAgICBpZiAodGhpcy5kcmFnRW5hYmxlZCkge1xuICAgICAgICB0aGlzLmRyYWdYLnNjcm9sbExlZnQgKz0gc2Nyb2xsRGlmZi5sZWZ0O1xuICAgICAgICB0aGlzLmVsLm5hdGl2ZUVsZW1lbnQuc2Nyb2xsVG9wICs9IHNjcm9sbERpZmYudG9wO1xuICAgICAgfVxuICAgIH1cbiAgfVxuXG4gIEBIb3N0TGlzdGVuZXIoJ3dpbmRvdzpwb2ludGVydXAnKSBvbldpbmRvd1BvaW50ZXJVcCgpIHtcbiAgICB0aGlzLnBvaW50ZXJEb3duID0gZmFsc2U7XG4gIH1cbn1cbiJdfQ==