@hmcts/media-viewer 2.9.5 → 2.10.0

package/assets/all.scss

@@ -1,7 +1,7 @@
 // CDK overlays require a small set of structural styles to work correctly
 // As the component is not yet using Angular Material we have to include the style ourself
 // see https://material.angular.io/cdk/overlay/overview
-@import '~@angular/cdk/overlay-prebuilt';
+@import 'node_modules/@angular/cdk/overlay-prebuilt';
 
 @import 'sass/settings';
 @import "sass/annotation-set";

package/assets/sass/tags.scss

@@ -18,7 +18,7 @@
 }
 
 
-@import "~ngx-chips/core/styles/core/core";
+@import "node_modules/ngx-chips/core/styles/core/core";
 
 $foundation-primary: #1779ba;
 $foundation-primary-dark: darken($foundation-primary, 10%);

package/esm2020/hmcts-media-viewer.mjs

@@ -0,0 +1,5 @@
+/**
+ * Generated bundle index. Do not edit.
+ */
+export * from './public_api';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaG1jdHMtbWVkaWEtdmlld2VyLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vcHJvamVjdHMvbWVkaWEtdmlld2VyL3NyYy9obWN0cy1tZWRpYS12aWV3ZXIudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7O0dBRUc7QUFFSCxjQUFjLGNBQWMsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICogR2VuZXJhdGVkIGJ1bmRsZSBpbmRleC4gRG8gbm90IGVkaXQuXG4gKi9cblxuZXhwb3J0ICogZnJvbSAnLi9wdWJsaWNfYXBpJztcbiJdfQ==

package/esm2020/lib/annotations/annotation-set/annotation-create/box-highlight-create/box-highlight-create.component.mjs

@@ -0,0 +1,116 @@
+import { Component, EventEmitter, Input, Output, ViewChild } from '@angular/core';
+import { v4 as uuid } from 'uuid';
+import * as i0 from "@angular/core";
+import * as i1 from "../../../../toolbar/toolbar.module";
+import * as i2 from "../highlight-create/highlight-create.service";
+export class BoxHighlightCreateComponent {
+    constructor(toolbarEvents, highlightService) {
+        this.toolbarEvents = toolbarEvents;
+        this.highlightService = highlightService;
+        this.saveSelection = new EventEmitter();
+        this.drawStartX = -1;
+        this.drawStartY = -1;
+        this.backgroundColor = 'none';
+        this.subscriptions = [];
+    }
+    ngOnInit() {
+        this.subscriptions = [
+            this.toolbarEvents.drawModeSubject.subscribe(drawMode => {
+                this.defaultHeight = drawMode ? '100%' : '0px';
+                this.defaultWidth = drawMode ? '100%' : '0px';
+            }),
+            this.toolbarEvents.redactWholePage.subscribe(() => {
+                this.wholePage = true;
+            })
+        ];
+    }
+    ngOnDestroy() {
+        this.subscriptions.forEach(subscription => {
+            subscription.unsubscribe();
+        });
+    }
+    initHighlight({ offsetX, offsetY }) {
+        if (this.wholePage) {
+            this.highlightPage();
+            return;
+        }
+        this.position = 'absolute';
+        this.backgroundColor = 'yellow';
+        this.drawStartX = offsetX;
+        this.drawStartY = offsetY;
+        this.display = 'block';
+        this.height = 50;
+        this.width = 50;
+        this.top = this.drawStartY;
+        this.left = this.drawStartX;
+        switch (this.rotate) {
+            case 90:
+                this.top = this.drawStartY - this.height;
+                break;
+            case 180:
+                this.top = this.drawStartY - this.height;
+                this.left = this.drawStartX - this.width;
+                break;
+            case 270:
+                this.left = this.drawStartX - this.width;
+                break;
+        }
+    }
+    updateHighlight({ currentTarget, clientX, clientY }) {
+        const rect = currentTarget.getBoundingClientRect(), offsetX = clientX - rect.left, offsetY = clientY - rect.top;
+        if (this.drawStartX > 0 && this.drawStartY > 0) {
+            this.height = Math.abs(offsetY - this.drawStartY);
+            this.width = Math.abs(offsetX - this.drawStartX);
+            this.top = Math.min(offsetY, this.drawStartY);
+            this.left = Math.min(offsetX, this.drawStartX);
+        }
+    }
+    createHighlight() {
+        if (this.height / this.zoom > 5 || this.width / this.zoom > 5) {
+            let rectangle = this.highlightService
+                .applyRotation(this.pageHeight, this.pageWidth, this.height, this.width, this.top, this.left, this.rotate, this.zoom);
+            rectangle = { id: uuid(), ...rectangle };
+            this.saveSelection.emit({ rectangles: [rectangle], page: this.page });
+            this.resetHighlight();
+        }
+    }
+    resetHighlight() {
+        this.drawStartX = -1;
+        this.drawStartY = -1;
+        this.display = 'none';
+        this.width = 0;
+        this.height = 0;
+        this.wholePage = false;
+    }
+    highlightPage() {
+        this.height = this.pageHeight;
+        this.width = this.pageWidth;
+        this.top = 0;
+        this.left = 0;
+        this.createHighlight();
+    }
+}
+/** @nocollapse */ BoxHighlightCreateComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: BoxHighlightCreateComponent, deps: [{ token: i1.ToolbarEventService }, { token: i2.HighlightCreateService }], target: i0.ɵɵFactoryTarget.Component });
+/** @nocollapse */ BoxHighlightCreateComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "15.2.9", type: BoxHighlightCreateComponent, selector: "mv-box-highlight-create", inputs: { page: "page", pageHeight: "pageHeight", pageWidth: "pageWidth", rotate: "rotate", zoom: "zoom", container: "container" }, outputs: { saveSelection: "saveSelection" }, viewQueries: [{ propertyName: "highlight", first: true, predicate: ["boxHighlight"], descendants: true }], ngImport: i0, template: "<div [style.height]=\"defaultHeight\"\n     [style.width]=\"defaultWidth\"\n     (mousedown)=\"initHighlight($event)\"\n     (mousemove)=\"updateHighlight($event)\"\n     (mouseup)=\"createHighlight()\">\n  <div #boxHighlight\n     class=\"box-highlight\"\n     [style.display]=\"display\"\n     [style.position]=\"position\"\n     [style.background-color]=\"backgroundColor\"\n     [style.height]=\"height ? height + 'px' : '100%'\"\n     [style.width]=\"width ? width + 'px' : '100%'\"\n     [style.top]=\"top + 'px'\"\n     [style.left]=\"left + 'px'\">\n  </div>\n</div>\n" });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: BoxHighlightCreateComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'mv-box-highlight-create', template: "<div [style.height]=\"defaultHeight\"\n     [style.width]=\"defaultWidth\"\n     (mousedown)=\"initHighlight($event)\"\n     (mousemove)=\"updateHighlight($event)\"\n     (mouseup)=\"createHighlight()\">\n  <div #boxHighlight\n     class=\"box-highlight\"\n     [style.display]=\"display\"\n     [style.position]=\"position\"\n     [style.background-color]=\"backgroundColor\"\n     [style.height]=\"height ? height + 'px' : '100%'\"\n     [style.width]=\"width ? width + 'px' : '100%'\"\n     [style.top]=\"top + 'px'\"\n     [style.left]=\"left + 'px'\">\n  </div>\n</div>\n" }]
+        }], ctorParameters: function () { return [{ type: i1.ToolbarEventService }, { type: i2.HighlightCreateService }]; }, propDecorators: { page: [{
+                type: Input
+            }], pageHeight: [{
+                type: Input
+            }], pageWidth: [{
+                type: Input
+            }], rotate: [{
+                type: Input
+            }], zoom: [{
+                type: Input
+            }], container: [{
+                type: Input
+            }], saveSelection: [{
+                type: Output
+            }], highlight: [{
+                type: ViewChild,
+                args: ['boxHighlight', { static: false }]
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"box-highlight-create.component.js","sourceRoot":"","sources":["../../../../../../../../projects/media-viewer/src/lib/annotations/annotation-set/annotation-create/box-highlight-create/box-highlight-create.component.ts","../../../../../../../../projects/media-viewer/src/lib/annotations/annotation-set/annotation-create/box-highlight-create/box-highlight-create.component.html"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAc,YAAY,EAAE,KAAK,EAAqB,MAAM,EAAE,SAAS,EAAE,MAAM,eAAe,CAAC;AACjH,OAAO,EAAE,EAAE,IAAI,IAAI,EAAE,MAAM,MAAM,CAAC;;;;AAUlC,MAAM,OAAO,2BAA2B;IA6BtC,YAA6B,aAAkC,EAC5C,gBAAwC;QAD9B,kBAAa,GAAb,aAAa,CAAqB;QAC5C,qBAAgB,GAAhB,gBAAgB,CAAwB;QArBjD,kBAAa,GAAG,IAAI,YAAY,EAA6C,CAAC;QAIxF,eAAU,GAAG,CAAC,CAAC,CAAC;QAChB,eAAU,GAAG,CAAC,CAAC,CAAC;QAUhB,oBAAe,GAAG,MAAM,CAAC;QAGjB,kBAAa,GAAmB,EAAE,CAAC;IAGoB,CAAC;IAEhE,QAAQ;QACN,IAAI,CAAC,aAAa,GAAG;YACnB,IAAI,CAAC,aAAa,CAAC,eAAe,CAAC,SAAS,CAAC,QAAQ,CAAC,EAAE;gBACtD,IAAI,CAAC,aAAa,GAAG,QAAQ,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,KAAK,CAAC;gBAC/C,IAAI,CAAC,YAAY,GAAG,QAAQ,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,KAAK,CAAC;YAChD,CAAC,CAAC;YACF,IAAI,CAAC,aAAa,CAAC,eAAe,CAAC,SAAS,CAAC,GAAG,EAAE;gBAChD,IAAI,CAAC,SAAS,GAAG,IAAI,CAAC;YACxB,CAAC,CAAC;SACH,CAAC;IACJ,CAAC;IAED,WAAW;QACT,IAAI,CAAC,aAAa,CAAC,OAAO,CAAC,YAAY,CAAC,EAAE;YACxC,YAAY,CAAC,WAAW,EAAE,CAAC;QAC7B,CAAC,CAAC,CAAC;IACL,CAAC;IAED,aAAa,CAAC,EAAE,OAAO,EAAE,OAAO,EAAE;QAChC,IAAI,IAAI,CAAC,SAAS,EAAE;YAClB,IAAI,CAAC,aAAa,EAAE,CAAC;YACrB,OAAO;SACR;QACD,IAAI,CAAC,QAAQ,GAAG,UAAU,CAAC;QAC3B,IAAI,CAAC,eAAe,GAAG,QAAQ,CAAC;QAChC,IAAI,CAAC,UAAU,GAAG,OAAO,CAAC;QAC1B,IAAI,CAAC,UAAU,GAAG,OAAO,CAAC;QAE1B,IAAI,CAAC,OAAO,GAAG,OAAO,CAAC;QACvB,IAAI,CAAC,MAAM,GAAG,EAAE,CAAC;QACjB,IAAI,CAAC,KAAK,GAAG,EAAE,CAAC;QAEhB,IAAI,CAAC,GAAG,GAAG,IAAI,CAAC,UAAU,CAAC;QAC3B,IAAI,CAAC,IAAI,GAAG,IAAI,CAAC,UAAU,CAAC;QAE5B,QAAQ,IAAI,CAAC,MAAM,EAAE;YACnB,KAAK,EAAE;gBACL,IAAI,CAAC,GAAG,GAAG,IAAI,CAAC,UAAU,GAAG,IAAI,CAAC,MAAM,CAAC;gBACzC,MAAM;YACR,KAAK,GAAG;gBACN,IAAI,CAAC,GAAG,GAAG,IAAI,CAAC,UAAU,GAAG,IAAI,CAAC,MAAM,CAAC;gBACzC,IAAI,CAAC,IAAI,GAAG,IAAI,CAAC,UAAU,GAAG,IAAI,CAAC,KAAK,CAAC;gBACzC,MAAM;YACR,KAAK,GAAG;gBACN,IAAI,CAAC,IAAI,GAAG,IAAI,CAAC,UAAU,GAAG,IAAI,CAAC,KAAK,CAAC;gBACzC,MAAM;SACT;IACH,CAAC;IAED,eAAe,CAAC,EAAE,aAAa,EAAE,OAAO,EAAE,OAAO,EAAE;QACjD,MAAM,IAAI,GAAG,aAAa,CAAC,qBAAqB,EAAE,EAChD,OAAO,GAAG,OAAO,GAAG,IAAI,CAAC,IAAI,EAC7B,OAAO,GAAG,OAAO,GAAG,IAAI,CAAC,GAAG,CAAC;QAC/B,IAAI,IAAI,CAAC,UAAU,GAAG,CAAC,IAAI,IAAI,CAAC,UAAU,GAAG,CAAC,EAAE;YAC9C,IAAI,CAAC,MAAM,GAAG,IAAI,CAAC,GAAG,CAAC,OAAO,GAAG,IAAI,CAAC,UAAU,CAAC,CAAC;YAClD,IAAI,CAAC,KAAK,GAAG,IAAI,CAAC,GAAG,CAAC,OAAO,GAAG,IAAI,CAAC,UAAU,CAAC,CAAC;YACjD,IAAI,CAAC,GAAG,GAAG,IAAI,CAAC,GAAG,CAAC,OAAO,EAAE,IAAI,CAAC,UAAU,CAAC,CAAC;YAC9C,IAAI,CAAC,IAAI,GAAG,IAAI,CAAC,GAAG,CAAC,OAAO,EAAE,IAAI,CAAC,UAAU,CAAC,CAAC;SAChD;IACH,CAAC;IAED,eAAe;QACb,IAAI,IAAI,CAAC,MAAM,GAAG,IAAI,CAAC,IAAI,GAAG,CAAC,IAAI,IAAI,CAAC,KAAK,GAAG,IAAI,CAAC,IAAI,GAAG,CAAC,EAAE;YAC7D,IAAI,SAAS,GAAG,IAAI,CAAC,gBAAgB;iBAClC,aAAa,CAAC,IAAI,CAAC,UAAU,EAAE,IAAI,CAAC,SAAS,EAAE,IAAI,CAAC,MAAM,EAAE,IAAI,CAAC,KAAK,EAAE,IAAI,CAAC,GAAG,EAAE,IAAI,CAAC,IAAI,EAAE,IAAI,CAAC,MAAM,EAAE,IAAI,CAAC,IAAI,CAAC,CAAC;YACxH,SAAS,GAAG,EAAE,EAAE,EAAE,IAAI,EAAE,EAAE,GAAG,SAAS,EAAS,CAAC;YAChD,IAAI,CAAC,aAAa,CAAC,IAAI,CAAC,EAAE,UAAU,EAAE,CAAC,SAAS,CAAC,EAAE,IAAI,EAAE,IAAI,CAAC,IAAI,EAAE,CAAC,CAAC;YACtE,IAAI,CAAC,cAAc,EAAE,CAAC;SACvB;IACH,CAAC;IAEO,cAAc;QACpB,IAAI,CAAC,UAAU,GAAG,CAAC,CAAC,CAAC;QACrB,IAAI,CAAC,UAAU,GAAG,CAAC,CAAC,CAAC;QACrB,IAAI,CAAC,OAAO,GAAG,MAAM,CAAC;QACtB,IAAI,CAAC,KAAK,GAAG,CAAC,CAAC;QACf,IAAI,CAAC,MAAM,GAAG,CAAC,CAAC;QAChB,IAAI,CAAC,SAAS,GAAG,KAAK,CAAC;IACzB,CAAC;IAEO,aAAa;QACnB,IAAI,CAAC,MAAM,GAAG,IAAI,CAAC,UAAU,CAAC;QAC9B,IAAI,CAAC,KAAK,GAAG,IAAI,CAAC,SAAS,CAAC;QAC5B,IAAI,CAAC,GAAG,GAAG,CAAC,CAAC;QACb,IAAI,CAAC,IAAI,GAAG,CAAC,CAAC;QACd,IAAI,CAAC,eAAe,EAAE,CAAC;IACzB,CAAC;;2IAtHU,2BAA2B;+HAA3B,2BAA2B,2VCXxC,kkBAgBA;2FDLa,2BAA2B;kBAJvC,SAAS;+BACE,yBAAyB;+IAK1B,IAAI;sBAAZ,KAAK;gBACG,UAAU;sBAAlB,KAAK;gBACG,SAAS;sBAAjB,KAAK;gBACG,MAAM;sBAAd,KAAK;gBACG,IAAI;sBAAZ,KAAK;gBACG,SAAS;sBAAjB,KAAK;gBAEI,aAAa;sBAAtB,MAAM;gBAEuC,SAAS;sBAAtD,SAAS;uBAAC,cAAc,EAAE,EAAE,MAAM,EAAE,KAAK,EAAE","sourcesContent":["import { Component, ElementRef, EventEmitter, Input, OnDestroy, OnInit, Output, ViewChild } from '@angular/core';\nimport { v4 as uuid } from 'uuid';\nimport { Subscription } from 'rxjs';\nimport { ToolbarEventService } from '../../../../toolbar/toolbar.module';\nimport { Rectangle } from '../../annotation-view/rectangle/rectangle.model';\nimport { HighlightCreateService } from '../highlight-create/highlight-create.service';\n\n@Component({\n  selector: 'mv-box-highlight-create',\n  templateUrl: './box-highlight-create.component.html',\n})\nexport class BoxHighlightCreateComponent implements OnInit, OnDestroy {\n\n  @Input() page: number;\n  @Input() pageHeight: number;\n  @Input() pageWidth: number;\n  @Input() rotate: number;\n  @Input() zoom: number;\n  @Input() container: { top: number, left: number };\n\n  @Output() saveSelection = new EventEmitter<{ rectangles: Rectangle[], page: number }>();\n\n  @ViewChild('boxHighlight', { static: false }) highlight: ElementRef;\n\n  drawStartX = -1;\n  drawStartY = -1;\n  top: number;\n  left: number;\n  height: number;\n  width: number;\n  display: string;\n  drawMode: boolean;\n  defaultHeight: string;\n  defaultWidth: string;\n  position: string;\n  backgroundColor = 'none';\n  wholePage: boolean;\n\n  private subscriptions: Subscription[] = [];\n\n  constructor(private readonly toolbarEvents: ToolbarEventService,\n    private readonly highlightService: HighlightCreateService) { }\n\n  ngOnInit(): void {\n    this.subscriptions = [\n      this.toolbarEvents.drawModeSubject.subscribe(drawMode => {\n        this.defaultHeight = drawMode ? '100%' : '0px';\n        this.defaultWidth = drawMode ? '100%' : '0px';\n      }),\n      this.toolbarEvents.redactWholePage.subscribe(() => {\n        this.wholePage = true;\n      })\n    ];\n  }\n\n  ngOnDestroy(): void {\n    this.subscriptions.forEach(subscription => {\n      subscription.unsubscribe();\n    });\n  }\n\n  initHighlight({ offsetX, offsetY }) {\n    if (this.wholePage) {\n      this.highlightPage();\n      return;\n    }\n    this.position = 'absolute';\n    this.backgroundColor = 'yellow';\n    this.drawStartX = offsetX;\n    this.drawStartY = offsetY;\n\n    this.display = 'block';\n    this.height = 50;\n    this.width = 50;\n\n    this.top = this.drawStartY;\n    this.left = this.drawStartX;\n\n    switch (this.rotate) {\n      case 90:\n        this.top = this.drawStartY - this.height;\n        break;\n      case 180:\n        this.top = this.drawStartY - this.height;\n        this.left = this.drawStartX - this.width;\n        break;\n      case 270:\n        this.left = this.drawStartX - this.width;\n        break;\n    }\n  }\n\n  updateHighlight({ currentTarget, clientX, clientY }) {\n    const rect = currentTarget.getBoundingClientRect(),\n      offsetX = clientX - rect.left,\n      offsetY = clientY - rect.top;\n    if (this.drawStartX > 0 && this.drawStartY > 0) {\n      this.height = Math.abs(offsetY - this.drawStartY);\n      this.width = Math.abs(offsetX - this.drawStartX);\n      this.top = Math.min(offsetY, this.drawStartY);\n      this.left = Math.min(offsetX, this.drawStartX);\n    }\n  }\n\n  createHighlight() {\n    if (this.height / this.zoom > 5 || this.width / this.zoom > 5) {\n      let rectangle = this.highlightService\n        .applyRotation(this.pageHeight, this.pageWidth, this.height, this.width, this.top, this.left, this.rotate, this.zoom);\n      rectangle = { id: uuid(), ...rectangle } as any;\n      this.saveSelection.emit({ rectangles: [rectangle], page: this.page });\n      this.resetHighlight();\n    }\n  }\n\n  private resetHighlight() {\n    this.drawStartX = -1;\n    this.drawStartY = -1;\n    this.display = 'none';\n    this.width = 0;\n    this.height = 0;\n    this.wholePage = false;\n  }\n\n  private highlightPage() {\n    this.height = this.pageHeight;\n    this.width = this.pageWidth;\n    this.top = 0;\n    this.left = 0;\n    this.createHighlight();\n  }\n}\n","<div [style.height]=\"defaultHeight\"\n     [style.width]=\"defaultWidth\"\n     (mousedown)=\"initHighlight($event)\"\n     (mousemove)=\"updateHighlight($event)\"\n     (mouseup)=\"createHighlight()\">\n  <div #boxHighlight\n     class=\"box-highlight\"\n     [style.display]=\"display\"\n     [style.position]=\"position\"\n     [style.background-color]=\"backgroundColor\"\n     [style.height]=\"height ? height + 'px' : '100%'\"\n     [style.width]=\"width ? width + 'px' : '100%'\"\n     [style.top]=\"top + 'px'\"\n     [style.left]=\"left + 'px'\">\n  </div>\n</div>\n"]}

package/esm2020/lib/annotations/annotation-set/annotation-create/highlight-create/highlight-create.directive.mjs

@@ -0,0 +1,109 @@
+import { Directive, HostListener } from '@angular/core';
+import { v4 as uuid } from 'uuid';
+import * as fromDocument from '../../../../store/selectors/document.selectors';
+import * as fromAnnotationActions from '../../../../store/actions/annotation.actions';
+import * as i0 from "@angular/core";
+import * as i1 from "../../../../toolbar/toolbar.module";
+import * as i2 from "../../../../viewers/viewer-event.service";
+import * as i3 from "./highlight-create.service";
+import * as i4 from "@ngrx/store";
+export class HighlightCreateDirective {
+    constructor(element, toolbarEvents, viewerEvents, highlightService, store) {
+        this.element = element;
+        this.toolbarEvents = toolbarEvents;
+        this.viewerEvents = viewerEvents;
+        this.highlightService = highlightService;
+        this.store = store;
+    }
+    ngOnInit() {
+        this.$subscription = this.store.select(fromDocument.getPages).subscribe((pages) => {
+            if (pages[1]) {
+                this.allPages = pages;
+            }
+        });
+    }
+    ngOnDestroy() {
+        if (this.$subscription) {
+            this.$subscription.unsubscribe();
+        }
+    }
+    onMouseUp(mouseEvent) {
+        const pageElement = mouseEvent.target.offsetParent.offsetParent;
+        const page = parseInt(pageElement.getAttribute('data-page-number'), 10);
+        if (this.toolbarEvents.highlightModeSubject.getValue()) {
+            const rectangles = this.getRectangles(mouseEvent, page);
+            this.viewerEvents.textSelected({ page, rectangles });
+        }
+    }
+    onPdfViewerClick(event) {
+        this.store.dispatch(new fromAnnotationActions.SelectedAnnotation({
+            annotationId: '',
+            selected: false,
+            editable: false,
+        }));
+        this.viewerEvents.clearCtxToolbar();
+    }
+    getRectangles(event, page) {
+        this.pageHeight = this.allPages[page].styles.height;
+        this.pageWidth = this.allPages[page].styles.width;
+        this.zoom = parseFloat(this.allPages[page].scaleRotation.scale);
+        this.rotate = parseInt(this.allPages[page].scaleRotation.rotation, 10);
+        const selection = window.getSelection();
+        if (selection) {
+            const localElement = event.target;
+            this.removeEnhancedTextModeStyling(localElement);
+            if (selection.rangeCount && !selection.isCollapsed) {
+                const range = selection.getRangeAt(0).cloneRange();
+                const clientRects = range.getClientRects();
+                if (clientRects) {
+                    const parentRect = localElement.parentElement.getBoundingClientRect();
+                    const selectionRectangles = [];
+                    for (let i = 0; i < clientRects.length; i++) {
+                        const selectionRectangle = this.createTextRectangle(clientRects[i], parentRect);
+                        const findSelecttionRectangle = selectionRectangles.find((rect) => rect.width === selectionRectangle.width && rect.x === selectionRectangle.x);
+                        if (!findSelecttionRectangle) {
+                            selectionRectangles.push(selectionRectangle);
+                        }
+                    }
+                    return selectionRectangles;
+                }
+            }
+        }
+    }
+    createTextRectangle(rect, parentRect) {
+        const height = rect.bottom - rect.top;
+        const width = rect.right - rect.left;
+        const top = rect.top - parentRect.top;
+        const left = rect.left - parentRect.left;
+        let rectangle = this.highlightService.applyRotation(this.pageHeight, this.pageWidth, height, width, top, left, this.rotate, this.zoom);
+        rectangle = { id: uuid(), ...rectangle };
+        return rectangle;
+    }
+    removeEnhancedTextModeStyling(element) {
+        if (element.parentElement.children) {
+            for (let i = 0; i < element.parentElement.children.length; i++) {
+                const child = element.parentElement.children[i];
+                child.style.padding = '0';
+                // regex will be targeting the translate style in string
+                // e.g. scaleX(0.969918) translateX(-110.684px) translateY(-105.274px) will become scaleX(0.969918)
+                const translateCSSRegex = /translate[XYZ]\(-?\d*(\.\d+)?(px)?\)/g;
+                child.style.transform = child.style.transform.replace(translateCSSRegex, '').trim();
+            }
+        }
+    }
+}
+/** @nocollapse */ HighlightCreateDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: HighlightCreateDirective, deps: [{ token: i0.ElementRef }, { token: i1.ToolbarEventService }, { token: i2.ViewerEventService }, { token: i3.HighlightCreateService }, { token: i4.Store }], target: i0.ɵɵFactoryTarget.Directive });
+/** @nocollapse */ HighlightCreateDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "15.2.9", type: HighlightCreateDirective, selector: "[mvCreateTextHighlight]", host: { listeners: { "mouseup": "onMouseUp($event)", "mousedown": "onPdfViewerClick($event)" } }, ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: HighlightCreateDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[mvCreateTextHighlight]'
+                }]
+        }], ctorParameters: function () { return [{ type: i0.ElementRef }, { type: i1.ToolbarEventService }, { type: i2.ViewerEventService }, { type: i3.HighlightCreateService }, { type: i4.Store }]; }, propDecorators: { onMouseUp: [{
+                type: HostListener,
+                args: ['mouseup', ['$event']]
+            }], onPdfViewerClick: [{
+                type: HostListener,
+                args: ['mousedown', ['$event']]
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"highlight-create.directive.js","sourceRoot":"","sources":["../../../../../../../../projects/media-viewer/src/lib/annotations/annotation-set/annotation-create/highlight-create/highlight-create.directive.ts"],"names":[],"mappings":"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","sourcesContent":["import { Directive, ElementRef, HostListener, OnDestroy, OnInit } from '@angular/core';\nimport { v4 as uuid } from 'uuid';\nimport { Store } from '@ngrx/store';\nimport { Subscription } from 'rxjs';\n\nimport { Rectangle } from '../../annotation-view/rectangle/rectangle.model';\nimport { ToolbarEventService } from '../../../../toolbar/toolbar.module';\nimport * as fromStore from '../../../../store/reducers/reducers';\nimport * as fromDocument from '../../../../store/selectors/document.selectors';\nimport { ViewerEventService } from '../../../../viewers/viewer-event.service';\nimport * as fromAnnotationActions from '../../../../store/actions/annotation.actions';\nimport { HighlightCreateService } from './highlight-create.service';\n\n@Directive({\n  selector: '[mvCreateTextHighlight]'\n})\nexport class HighlightCreateDirective implements OnInit, OnDestroy {\n  pageHeight: number;\n  pageWidth: number;\n  zoom: number;\n  rotate: number;\n  allPages: object;\n\n  $subscription: Subscription;\n\n  constructor(\n    private element: ElementRef<HTMLElement>,\n    private toolbarEvents: ToolbarEventService,\n    private viewerEvents: ViewerEventService,\n    private highlightService: HighlightCreateService,\n    private store: Store<fromStore.AnnotationSetState>\n  ) { }\n\n  ngOnInit() {\n    this.$subscription = this.store.select(fromDocument.getPages).subscribe((pages) => {\n      if (pages[1]) {\n        this.allPages = pages;\n      }\n    });\n  }\n\n  ngOnDestroy() {\n    if (this.$subscription) {\n      this.$subscription.unsubscribe();\n    }\n  }\n\n  @HostListener('mouseup', ['$event'])\n  onMouseUp(mouseEvent: MouseEvent) {\n    const pageElement = (<HTMLElement>(mouseEvent.target as HTMLElement).offsetParent).offsetParent;\n    const page = parseInt(pageElement.getAttribute('data-page-number'), 10);\n    if (this.toolbarEvents.highlightModeSubject.getValue()) {\n      const rectangles = this.getRectangles(mouseEvent, page);\n      this.viewerEvents.textSelected({ page, rectangles });\n    }\n  }\n\n  @HostListener('mousedown', ['$event'])\n  onPdfViewerClick(event: MouseEvent) {\n    this.store.dispatch(\n      new fromAnnotationActions.SelectedAnnotation({\n        annotationId: '',\n        selected: false,\n        editable: false,\n      })\n    );\n    this.viewerEvents.clearCtxToolbar();\n  }\n\n  private getRectangles(event: MouseEvent, page) {\n    this.pageHeight = this.allPages[page].styles.height;\n    this.pageWidth = this.allPages[page].styles.width;\n    this.zoom = parseFloat(this.allPages[page].scaleRotation.scale);\n    this.rotate = parseInt(this.allPages[page].scaleRotation.rotation, 10);\n    const selection = window.getSelection();\n    if (selection) {\n      const localElement = <HTMLElement>event.target;\n\n      this.removeEnhancedTextModeStyling(localElement);\n\n      if (selection.rangeCount && !selection.isCollapsed) {\n        const range = selection.getRangeAt(0).cloneRange();\n        const clientRects = range.getClientRects();\n\n        if (clientRects) {\n\n          const parentRect = localElement.parentElement.getBoundingClientRect();\n          const selectionRectangles: Rectangle[] = [];\n          for (let i = 0; i < clientRects.length; i++) {\n            const selectionRectangle = this.createTextRectangle(clientRects[i], parentRect);\n            const findSelecttionRectangle = selectionRectangles.find(\n              (rect) => rect.width === selectionRectangle.width && rect.x === selectionRectangle.x\n            );\n            if (!findSelecttionRectangle) {\n              selectionRectangles.push(selectionRectangle);\n            }\n          }\n          return selectionRectangles;\n        }\n      }\n    }\n  }\n\n  private createTextRectangle(rect: any, parentRect: any): Rectangle {\n    const height = rect.bottom - rect.top;\n    const width = rect.right - rect.left;\n    const top = rect.top - parentRect.top;\n    const left = rect.left - parentRect.left;\n\n    let rectangle = this.highlightService.applyRotation(\n      this.pageHeight,\n      this.pageWidth,\n      height,\n      width,\n      top,\n      left,\n      this.rotate,\n      this.zoom\n    );\n    rectangle = { id: uuid(), ...rectangle };\n\n    return rectangle as Rectangle;\n  }\n\n  private removeEnhancedTextModeStyling(element: HTMLElement) {\n    if (element.parentElement.children) {\n      for (let i = 0; i < element.parentElement.children.length; i++) {\n        const child = <HTMLElement>element.parentElement.children[i];\n\n        child.style.padding = '0';\n        // regex will be targeting the translate style in string\n        // e.g. scaleX(0.969918) translateX(-110.684px) translateY(-105.274px) will become scaleX(0.969918)\n        const translateCSSRegex = /translate[XYZ]\\(-?\\d*(\\.\\d+)?(px)?\\)/g;\n        child.style.transform = child.style.transform.replace(translateCSSRegex, '').trim();\n      }\n    }\n  }\n}\n"]}

package/esm2020/lib/annotations/annotation-set/annotation-create/highlight-create/highlight-create.service.mjs

@@ -0,0 +1,75 @@
+import { Injectable } from '@angular/core';
+import { take } from 'rxjs/operators';
+import { select } from '@ngrx/store';
+import { v4 as uuid } from 'uuid';
+import moment from 'moment-timezone';
+import * as fromSelectors from '../../../../store/selectors/annotation.selectors';
+import * as fromActions from '../../../../store/actions/annotation.actions';
+import * as i0 from "@angular/core";
+import * as i1 from "../../../../toolbar/toolbar.module";
+import * as i2 from "@ngrx/store";
+export class HighlightCreateService {
+    constructor(toolBarEvents, store) {
+        this.toolBarEvents = toolBarEvents;
+        this.store = store;
+    }
+    saveAnnotation(rectangles, page) {
+        this.store.pipe(select(fromSelectors.getDocumentIdSetId), take(1)).subscribe(anoSetDocId => {
+            const anno = {
+                id: uuid(),
+                color: 'FFFF00',
+                comments: [],
+                page: page,
+                rectangles: rectangles,
+                type: 'highlight',
+                ...anoSetDocId,
+                createdBy: '',
+                createdByDetails: undefined,
+                createdDate: moment.utc().tz('Europe/London').toISOString(),
+                lastModifiedBy: '',
+                lastModifiedByDetails: undefined,
+                lastModifiedDate: '',
+                tags: [],
+            };
+            this.store.dispatch(new fromActions.SaveAnnotation(anno));
+        });
+    }
+    applyRotation(pageHeight, pageWidth, offsetHeight, offsetWidth, offsetTop, offsetLeft, rotate, zoom) {
+        const { x, y, width, height } = {
+            x: +(offsetLeft / zoom).toFixed(2),
+            y: +(offsetTop / zoom).toFixed(2),
+            width: +(offsetWidth / zoom).toFixed(2),
+            height: +(offsetHeight / zoom).toFixed(2)
+        };
+        const rectangle = { x, y, width, height };
+        switch (rotate) {
+            case 90:
+                rectangle.width = height;
+                rectangle.height = width;
+                rectangle.x = y;
+                rectangle.y = +(pageWidth / zoom - x - width).toFixed(2);
+                break;
+            case 180:
+                rectangle.x = +(pageWidth / zoom - x - width).toFixed(2);
+                rectangle.y = +(pageHeight / zoom - y - height).toFixed(2);
+                break;
+            case 270:
+                rectangle.width = height;
+                rectangle.height = width;
+                rectangle.x = +(pageHeight / zoom - y - height).toFixed(2);
+                rectangle.y = x;
+                break;
+        }
+        return rectangle;
+    }
+    resetHighlight() {
+        window.getSelection().removeAllRanges();
+        this.toolBarEvents.highlightModeSubject.next(false);
+    }
+}
+/** @nocollapse */ HighlightCreateService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: HighlightCreateService, deps: [{ token: i1.ToolbarEventService }, { token: i2.Store }], target: i0.ɵɵFactoryTarget.Injectable });
+/** @nocollapse */ HighlightCreateService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: HighlightCreateService });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: HighlightCreateService, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: i1.ToolbarEventService }, { type: i2.Store }]; } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/annotations/annotation-set/annotation-set.component.mjs

@@ -0,0 +1,50 @@
+import { Component, Input } from '@angular/core';
+import { select } from '@ngrx/store';
+import * as fromActions from '../../store/actions/annotation.actions';
+import * as fromSelectors from '../../store/selectors/annotation.selectors';
+import * as i0 from "@angular/core";
+import * as i1 from "@ngrx/store";
+import * as i2 from "../comment-set/comment/comment.service";
+import * as i3 from "@angular/common";
+import * as i4 from "./annotation-view/annotation-view.component";
+export class AnnotationSetComponent {
+    constructor(store, commentService) {
+        this.store = store;
+        this.commentService = commentService;
+        this.annotations = [];
+    }
+    ngOnInit() {
+        this.selectedAnnotation$ = this.store.pipe(select(fromSelectors.getSelectedAnnotation));
+    }
+    onAnnotationUpdate(annotation) {
+        this.store.dispatch(new fromActions.SaveAnnotation(annotation));
+    }
+    onAnnotationDelete(annotation) {
+        if (annotation.comments.length > 0) {
+            this.commentService.updateUnsavedCommentsStatus(annotation, false);
+        }
+        this.store.dispatch(new fromActions.DeleteAnnotation(annotation.id));
+    }
+    selectAnnotation(selectedAnnotation) {
+        this.store.dispatch(new fromActions.SelectedAnnotation(selectedAnnotation));
+    }
+}
+/** @nocollapse */ AnnotationSetComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: AnnotationSetComponent, deps: [{ token: i1.Store }, { token: i2.CommentService }], target: i0.ɵɵFactoryTarget.Component });
+/** @nocollapse */ AnnotationSetComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "15.2.9", type: AnnotationSetComponent, selector: "mv-annotation-set", inputs: { page: "page", annotations: "annotations", zoom: "zoom", rotate: "rotate", pageHeight: "pageHeight", pageWidth: "pageWidth" }, ngImport: i0, template: "<ng-container *ngFor=\"let annotation of annotations\">\n  <mv-annotation [annotation]=\"annotation\"\n                 [zoom]=\"zoom\"\n                 [rotate]=\"rotate\"\n                 [selectedAnnoId]=\"selectedAnnotation$ | async\"\n                 [pageHeight]=\"pageHeight\"\n                 [pageWidth]=\"pageWidth\"\n                 (update)=\"onAnnotationUpdate($event)\"\n                 (delete)=\"onAnnotationDelete($event)\"\n                 (annotationClick)=\"selectAnnotation($event)\">\n  </mv-annotation>\n</ng-container>\n", dependencies: [{ kind: "directive", type: i3.NgForOf, selector: "[ngFor][ngForOf]", inputs: ["ngForOf", "ngForTrackBy", "ngForTemplate"] }, { kind: "component", type: i4.AnnotationViewComponent, selector: "mv-annotation", inputs: ["annotation", "zoom", "rotate", "selectedAnnoId", "pageHeight", "pageWidth"], outputs: ["update", "delete", "annotationClick"] }, { kind: "pipe", type: i3.AsyncPipe, name: "async" }] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: AnnotationSetComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'mv-annotation-set', template: "<ng-container *ngFor=\"let annotation of annotations\">\n  <mv-annotation [annotation]=\"annotation\"\n                 [zoom]=\"zoom\"\n                 [rotate]=\"rotate\"\n                 [selectedAnnoId]=\"selectedAnnotation$ | async\"\n                 [pageHeight]=\"pageHeight\"\n                 [pageWidth]=\"pageWidth\"\n                 (update)=\"onAnnotationUpdate($event)\"\n                 (delete)=\"onAnnotationDelete($event)\"\n                 (annotationClick)=\"selectAnnotation($event)\">\n  </mv-annotation>\n</ng-container>\n" }]
+        }], ctorParameters: function () { return [{ type: i1.Store }, { type: i2.CommentService }]; }, propDecorators: { page: [{
+                type: Input
+            }], annotations: [{
+                type: Input
+            }], zoom: [{
+                type: Input
+            }], rotate: [{
+                type: Input
+            }], pageHeight: [{
+                type: Input
+            }], pageWidth: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/annotations/annotation-set/annotation-view/annotation-view.component.mjs

@@ -0,0 +1,94 @@
+import { Component, EventEmitter, Input, Output, ViewChild } from '@angular/core';
+import { v4 as uuid } from 'uuid';
+import moment from 'moment-timezone';
+import * as fromActions from '../../../store/actions/annotation.actions';
+import * as i0 from "@angular/core";
+import * as i1 from "../../../toolbar/toolbar-event.service";
+import * as i2 from "@ngrx/store";
+import * as i3 from "@angular/common";
+import * as i4 from "./rectangle/rectangle.component";
+import * as i5 from "../ctx-toolbar/ctx-toolbar.component";
+export class AnnotationViewComponent {
+    set annotation(value) {
+        this.anno = { ...value };
+    }
+    set selectedAnnoId(selectedId) {
+        if (selectedId) {
+            const id = this.anno.id || this.anno.redactionId; // todo make it unique
+            this.selected = selectedId.annotationId ? (selectedId.annotationId === id) : false;
+        }
+    }
+    constructor(toolbarEvents, store) {
+        this.toolbarEvents = toolbarEvents;
+        this.store = store;
+        this.update = new EventEmitter();
+        this.delete = new EventEmitter();
+        this.annotationClick = new EventEmitter();
+    }
+    onSelect() {
+        const annotationId = this.anno.id || this.anno.redactionId;
+        this.annotationClick.emit({ annotationId, editable: false, selected: true });
+    }
+    onRectangleUpdate(rectangle) {
+        const annotation = { ...this.anno };
+        annotation.rectangles = annotation.rectangles.filter(r => r.id !== rectangle.id);
+        annotation.rectangles.push(rectangle);
+        this.update.emit(annotation);
+    }
+    deleteHighlight() {
+        this.delete.emit(this.anno);
+    }
+    addOrEditComment() {
+        if (this.anno.comments.length === 0) {
+            const comment = {
+                annotationId: this.anno.id,
+                content: '',
+                createdBy: this.anno.createdBy,
+                createdByDetails: undefined,
+                createdDate: moment.utc().tz('Europe/London').toISOString(),
+                id: uuid(),
+                lastModifiedBy: '',
+                lastModifiedByDetails: undefined,
+                lastModifiedDate: '',
+                tags: [],
+                page: null,
+                pages: {},
+                pageHeight: null,
+                selected: false,
+                editable: false
+            };
+            this.store.dispatch(new fromActions.AddOrEditComment(comment));
+        }
+        this.selected = true;
+        this.annotationClick.emit({ annotationId: this.anno.id, editable: true, selected: true });
+        this.toolbarEvents.toggleCommentsPanel(true);
+    }
+}
+/** @nocollapse */ AnnotationViewComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: AnnotationViewComponent, deps: [{ token: i1.ToolbarEventService }, { token: i2.Store }], target: i0.ɵɵFactoryTarget.Component });
+/** @nocollapse */ AnnotationViewComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "15.2.9", type: AnnotationViewComponent, selector: "mv-annotation", inputs: { annotation: "annotation", zoom: "zoom", rotate: "rotate", selectedAnnoId: "selectedAnnoId", pageHeight: "pageHeight", pageWidth: "pageWidth" }, outputs: { update: "update", delete: "delete", annotationClick: "annotationClick" }, viewQueries: [{ propertyName: "container", first: true, predicate: ["container"], descendants: true }], ngImport: i0, template: "<div #container [tabindex]=\"anno.id\">\n  <mv-ctx-toolbar *ngIf=\"selected\"\n                  [canDelete]=\"true\" [canComment]=\"true\"\n                  [rectangles]=\"anno.rectangles\"\n                  [zoom]=\"zoom\"\n                  [rotate]=\"rotate\"\n                  [pageHeight]=\"pageHeight\"\n                  [pageWidth]=\"pageWidth\"\n                  (deleteHighlightEvent)=\"deleteHighlight()\"\n                  (addOrEditCommentEvent)=\"addOrEditComment()\">\n  </mv-ctx-toolbar>\n  <ng-container *ngFor=\"let rectangle of anno.rectangles\">\n    <mv-anno-rectangle\n      (selectEvent)=\"onSelect()\"\n      (updateEvent)=\"onRectangleUpdate($event)\"\n      [selected]=\"selected\"\n      [zoom]=\"zoom\"\n      [rotate]=\"rotate\"\n      [pageHeight]=\"pageHeight\"\n      [pageWidth]=\"pageWidth\"\n      [editable]=\"anno.rectangles.length <= 1\"\n      [annoRect]=\"rectangle\"\n      [color]=\"anno.color\">\n    </mv-anno-rectangle>\n  </ng-container>\n</div>\n", dependencies: [{ kind: "directive", type: i3.NgForOf, selector: "[ngFor][ngForOf]", inputs: ["ngForOf", "ngForTrackBy", "ngForTemplate"] }, { kind: "directive", type: i3.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { kind: "component", type: i4.RectangleComponent, selector: "mv-anno-rectangle", inputs: ["color", "zoom", "rotate", "editable", "pageHeight", "pageWidth", "annoRect", "selected"], outputs: ["selectEvent", "updateEvent"] }, { kind: "component", type: i5.CtxToolbarComponent, selector: "mv-ctx-toolbar", inputs: ["zoom", "rotate", "pageHeight", "pageWidth", "canHighlight", "canBookmark", "canComment", "canDelete", "rectangles"], outputs: ["createHighlightEvent", "deleteHighlightEvent", "addOrEditCommentEvent", "createBookmarkEvent"] }] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: AnnotationViewComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'mv-annotation', template: "<div #container [tabindex]=\"anno.id\">\n  <mv-ctx-toolbar *ngIf=\"selected\"\n                  [canDelete]=\"true\" [canComment]=\"true\"\n                  [rectangles]=\"anno.rectangles\"\n                  [zoom]=\"zoom\"\n                  [rotate]=\"rotate\"\n                  [pageHeight]=\"pageHeight\"\n                  [pageWidth]=\"pageWidth\"\n                  (deleteHighlightEvent)=\"deleteHighlight()\"\n                  (addOrEditCommentEvent)=\"addOrEditComment()\">\n  </mv-ctx-toolbar>\n  <ng-container *ngFor=\"let rectangle of anno.rectangles\">\n    <mv-anno-rectangle\n      (selectEvent)=\"onSelect()\"\n      (updateEvent)=\"onRectangleUpdate($event)\"\n      [selected]=\"selected\"\n      [zoom]=\"zoom\"\n      [rotate]=\"rotate\"\n      [pageHeight]=\"pageHeight\"\n      [pageWidth]=\"pageWidth\"\n      [editable]=\"anno.rectangles.length <= 1\"\n      [annoRect]=\"rectangle\"\n      [color]=\"anno.color\">\n    </mv-anno-rectangle>\n  </ng-container>\n</div>\n" }]
+        }], ctorParameters: function () { return [{ type: i1.ToolbarEventService }, { type: i2.Store }]; }, propDecorators: { annotation: [{
+                type: Input
+            }], zoom: [{
+                type: Input
+            }], rotate: [{
+                type: Input
+            }], selectedAnnoId: [{
+                type: Input
+            }], pageHeight: [{
+                type: Input
+            }], pageWidth: [{
+                type: Input
+            }], update: [{
+                type: Output
+            }], delete: [{
+                type: Output
+            }], annotationClick: [{
+                type: Output
+            }], container: [{
+                type: ViewChild,
+                args: ['container', { static: false }]
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"annotation-view.component.js","sourceRoot":"","sources":["../../../../../../../projects/media-viewer/src/lib/annotations/annotation-set/annotation-view/annotation-view.component.ts","../../../../../../../projects/media-viewer/src/lib/annotations/annotation-set/annotation-view/annotation-view.component.html"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,YAAY,EAAE,KAAK,EAAE,MAAM,EAAE,SAAS,EAAc,MAAM,eAAe,CAAC;AAC9F,OAAO,EAAE,EAAE,IAAI,IAAI,EAAE,MAAM,MAAM,CAAC;AAGlC,OAAO,MAAM,MAAM,iBAAiB,CAAC;AAGrC,OAAO,KAAK,WAAW,MAAM,2CAA2C,CAAC;;;;;;;AASzE,MAAM,OAAO,uBAAuB;IAElC,IAAa,UAAU,CAAC,KAAK;QAC3B,IAAI,CAAC,IAAI,GAAG,EAAE,GAAG,KAAK,EAAE,CAAC;IAC3B,CAAC;IAKD,IAAa,cAAc,CAAC,UAAoC;QAC9D,IAAI,UAAU,EAAE;YACd,MAAM,EAAE,GAAG,IAAI,CAAC,IAAI,CAAC,EAAE,IAAI,IAAI,CAAC,IAAI,CAAC,WAAW,CAAC,CAAC,sBAAsB;YACxE,IAAI,CAAC,QAAQ,GAAG,UAAU,CAAC,YAAY,CAAC,CAAC,CAAC,CAAC,UAAU,CAAC,YAAY,KAAK,EAAE,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC;SACpF;IACH,CAAC;IASD,YACmB,aAAkC,EAC3C,KAA0C;QADjC,kBAAa,GAAb,aAAa,CAAqB;QAC3C,UAAK,GAAL,KAAK,CAAqC;QAR1C,WAAM,GAAG,IAAI,YAAY,EAAc,CAAC;QACxC,WAAM,GAAG,IAAI,YAAY,EAAc,CAAC;QACxC,oBAAe,GAAG,IAAI,YAAY,EAAuB,CAAC;IAOhE,CAAC;IAEE,QAAQ;QACb,MAAM,YAAY,GAAG,IAAI,CAAC,IAAI,CAAC,EAAE,IAAI,IAAI,CAAC,IAAI,CAAC,WAAW,CAAC;QAC3D,IAAI,CAAC,eAAe,CAAC,IAAI,CAAC,EAAE,YAAY,EAAE,QAAQ,EAAE,KAAK,EAAE,QAAQ,EAAE,IAAI,EAAE,CAAC,CAAC;IAC/E,CAAC;IAEM,iBAAiB,CAAC,SAAoB;QAC3C,MAAM,UAAU,GAAG,EAAE,GAAG,IAAI,CAAC,IAAI,EAAE,CAAC;QACpC,UAAU,CAAC,UAAU,GAAG,UAAU,CAAC,UAAU,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,EAAE,KAAK,SAAS,CAAC,EAAE,CAAC,CAAC;QACjF,UAAU,CAAC,UAAU,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC;QACtC,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,UAAU,CAAC,CAAC;IAC/B,CAAC;IAEM,eAAe;QACpB,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;IAC9B,CAAC;IAEM,gBAAgB;QACrB,IAAI,IAAI,CAAC,IAAI,CAAC,QAAQ,CAAC,MAAM,KAAK,CAAC,EAAE;YACnC,MAAM,OAAO,GAAY;gBACvB,YAAY,EAAE,IAAI,CAAC,IAAI,CAAC,EAAE;gBAC1B,OAAO,EAAE,EAAE;gBACX,SAAS,EAAE,IAAI,CAAC,IAAI,CAAC,SAAS;gBAC9B,gBAAgB,EAAE,SAAS;gBAC3B,WAAW,EAAE,MAAM,CAAC,GAAG,EAAE,CAAC,EAAE,CAAC,eAAe,CAAC,CAAC,WAAW,EAAE;gBAC3D,EAAE,EAAE,IAAI,EAAE;gBACV,cAAc,EAAE,EAAE;gBAClB,qBAAqB,EAAE,SAAS;gBAChC,gBAAgB,EAAE,EAAE;gBACpB,IAAI,EAAE,EAAE;gBACR,IAAI,EAAE,IAAI;gBACV,KAAK,EAAE,EAAE;gBACT,UAAU,EAAE,IAAI;gBAChB,QAAQ,EAAE,KAAK;gBACf,QAAQ,EAAE,KAAK;aAChB,CAAC;YACF,IAAI,CAAC,KAAK,CAAC,QAAQ,CAAC,IAAI,WAAW,CAAC,gBAAgB,CAAC,OAAO,CAAC,CAAC,CAAC;SAEhE;QACD,IAAI,CAAC,QAAQ,GAAG,IAAI,CAAC;QACrB,IAAI,CAAC,eAAe,CAAC,IAAI,CAAC,EAAE,YAAY,EAAE,IAAI,CAAC,IAAI,CAAC,EAAE,EAAE,QAAQ,EAAE,IAAI,EAAE,QAAQ,EAAE,IAAI,EAAE,CAAC,CAAC;QAC1F,IAAI,CAAC,aAAa,CAAC,mBAAmB,CAAC,IAAI,CAAC,CAAC;IAC/C,CAAC;;uIArEU,uBAAuB;2HAAvB,uBAAuB,4YChBpC,y+BA0BA;2FDVa,uBAAuB;kBAJnC,SAAS;+BACE,eAAe;8HAKZ,UAAU;sBAAtB,KAAK;gBAKG,IAAI;sBAAZ,KAAK;gBACG,MAAM;sBAAd,KAAK;gBACO,cAAc;sBAA1B,KAAK;gBAMG,UAAU;sBAAlB,KAAK;gBACG,SAAS;sBAAjB,KAAK;gBACI,MAAM;sBAAf,MAAM;gBACG,MAAM;sBAAf,MAAM;gBACG,eAAe;sBAAxB,MAAM;gBAEoC,SAAS;sBAAnD,SAAS;uBAAC,WAAW,EAAE,EAAE,MAAM,EAAE,KAAK,EAAE","sourcesContent":["import { Component, EventEmitter, Input, Output, ViewChild, ElementRef } from '@angular/core';\nimport { v4 as uuid } from 'uuid';\nimport { Annotation } from './annotation.model';\nimport { Rectangle } from './rectangle/rectangle.model';\nimport moment from 'moment-timezone';\nimport { Store } from '@ngrx/store';\nimport * as fromStore from '../../../store/reducers/reducers';\nimport * as fromActions from '../../../store/actions/annotation.actions';\nimport { SelectionAnnotation } from '../../models/event-select.model';\nimport { ToolbarEventService } from '../../../toolbar/toolbar-event.service';\nimport { Comment } from '../../comment-set/comment/comment.model';\n\n@Component({\n  selector: 'mv-annotation',\n  templateUrl: './annotation-view.component.html'\n})\nexport class AnnotationViewComponent {  // todo rename this to selection vew c\n\n  @Input() set annotation(value) {\n    this.anno = { ...value };\n  }\n  anno: Annotation;\n  selected: boolean;\n  @Input() zoom: number;\n  @Input() rotate: number;\n  @Input() set selectedAnnoId(selectedId: { annotationId: string }) {\n    if (selectedId) {\n      const id = this.anno.id || this.anno.redactionId; // todo make it unique\n      this.selected = selectedId.annotationId ? (selectedId.annotationId === id) : false;\n    }\n  }\n  @Input() pageHeight: number;\n  @Input() pageWidth: number;\n  @Output() update = new EventEmitter<Annotation>();\n  @Output() delete = new EventEmitter<Annotation>();\n  @Output() annotationClick = new EventEmitter<SelectionAnnotation>();\n\n  @ViewChild('container', { static: false }) container: ElementRef;\n\n  constructor(\n    private readonly toolbarEvents: ToolbarEventService,\n    private store: Store<fromStore.AnnotationSetState>\n  ) { }\n\n  public onSelect() {\n    const annotationId = this.anno.id || this.anno.redactionId;\n    this.annotationClick.emit({ annotationId, editable: false, selected: true });\n  }\n\n  public onRectangleUpdate(rectangle: Rectangle) {\n    const annotation = { ...this.anno };\n    annotation.rectangles = annotation.rectangles.filter(r => r.id !== rectangle.id);\n    annotation.rectangles.push(rectangle);\n    this.update.emit(annotation);\n  }\n\n  public deleteHighlight() {\n    this.delete.emit(this.anno);\n  }\n\n  public addOrEditComment() {\n    if (this.anno.comments.length === 0) {\n      const comment: Comment = {\n        annotationId: this.anno.id,\n        content: '',\n        createdBy: this.anno.createdBy,\n        createdByDetails: undefined,\n        createdDate: moment.utc().tz('Europe/London').toISOString(),\n        id: uuid(),\n        lastModifiedBy: '',\n        lastModifiedByDetails: undefined,\n        lastModifiedDate: '',\n        tags: [],\n        page: null,\n        pages: {},\n        pageHeight: null,\n        selected: false,\n        editable: false\n      };\n      this.store.dispatch(new fromActions.AddOrEditComment(comment));\n\n    }\n    this.selected = true;\n    this.annotationClick.emit({ annotationId: this.anno.id, editable: true, selected: true });\n    this.toolbarEvents.toggleCommentsPanel(true);\n  }\n}\n","<div #container [tabindex]=\"anno.id\">\n  <mv-ctx-toolbar *ngIf=\"selected\"\n                  [canDelete]=\"true\" [canComment]=\"true\"\n                  [rectangles]=\"anno.rectangles\"\n                  [zoom]=\"zoom\"\n                  [rotate]=\"rotate\"\n                  [pageHeight]=\"pageHeight\"\n                  [pageWidth]=\"pageWidth\"\n                  (deleteHighlightEvent)=\"deleteHighlight()\"\n                  (addOrEditCommentEvent)=\"addOrEditComment()\">\n  </mv-ctx-toolbar>\n  <ng-container *ngFor=\"let rectangle of anno.rectangles\">\n    <mv-anno-rectangle\n      (selectEvent)=\"onSelect()\"\n      (updateEvent)=\"onRectangleUpdate($event)\"\n      [selected]=\"selected\"\n      [zoom]=\"zoom\"\n      [rotate]=\"rotate\"\n      [pageHeight]=\"pageHeight\"\n      [pageWidth]=\"pageWidth\"\n      [editable]=\"anno.rectangles.length <= 1\"\n      [annoRect]=\"rectangle\"\n      [color]=\"anno.color\">\n    </mv-anno-rectangle>\n  </ng-container>\n</div>\n"]}