@hmcts/media-viewer 4.1.9-cme-776-angular-20 → 4.1.9-exui-1580-1

package/esm2022/lib/annotations/annotation-set/annotation-create/highlight-create/keyboard-text-highlight.directive.mjs

@@ -0,0 +1,345 @@
+import { Directive, EventEmitter, HostListener, Input, Output } from '@angular/core';
+import * as i0 from "@angular/core";
+export class KeyboardTextHighlightDirective {
+    set enabled(value) {
+        const wasEnabled = this._enabled;
+        this._enabled = value;
+    }
+    get enabled() {
+        return this._enabled;
+    }
+    static { this.lastInteractionWasKeyboard = false; }
+    constructor(elementRef) {
+        this.elementRef = elementRef;
+        this._enabled = false;
+        this.incrementSmall = 5;
+        this.incrementMedium = 10;
+        this.incrementLarge = 20;
+        this.selectionStarted = new EventEmitter();
+        this.selectionUpdated = new EventEmitter();
+        this.selectionConfirmed = new EventEmitter();
+        this.selectionCancelled = new EventEmitter();
+        this.cursorPositionChanged = new EventEmitter();
+        this.selectionCursorPositionChanged = new EventEmitter();
+        this.isSelecting = false;
+        this.showCursor = false;
+        this.lastValidEndNode = null;
+        this.lastValidEndOffset = 0;
+        if (typeof window !== 'undefined') {
+            window.addEventListener('keydown', KeyboardTextHighlightDirective.onGlobalKeyDown, { capture: true });
+            window.addEventListener('mousedown', KeyboardTextHighlightDirective.onGlobalMouseDown, { capture: true });
+        }
+    }
+    static onGlobalKeyDown() {
+        KeyboardTextHighlightDirective.lastInteractionWasKeyboard = true;
+    }
+    static onGlobalMouseDown() {
+        KeyboardTextHighlightDirective.lastInteractionWasKeyboard = false;
+    }
+    ngOnDestroy() {
+        this.cleanup();
+    }
+    onKeyDown(event) {
+        if (!this.enabled) {
+            return;
+        }
+        if (event.key === 'Enter') {
+            event.preventDefault();
+            event.stopPropagation();
+            if (!this.isSelecting) {
+                this.startTextSelection();
+            }
+            else {
+                this.confirmTextSelection();
+            }
+            return;
+        }
+        if (event.key === 'Escape') {
+            event.preventDefault();
+            event.stopPropagation();
+            if (this.isSelecting) {
+                this.cancelTextSelection();
+            }
+            else if (this.showCursor) {
+                this.hideCursor();
+            }
+            return;
+        }
+        if (['ArrowUp', 'ArrowDown', 'ArrowLeft', 'ArrowRight'].includes(event.key)) {
+            event.preventDefault();
+            event.stopPropagation();
+            if (this.isSelecting) {
+                this.expandTextSelection(event);
+            }
+            else {
+                this.moveCursor(event);
+            }
+        }
+    }
+    onBlur() {
+        if (this.showCursor && !this.isSelecting) {
+            this.hideCursor();
+        }
+    }
+    moveCursor(event) {
+        const increment = event.shiftKey ? this.incrementLarge : this.incrementMedium;
+        if (!this.showCursor) {
+            const viewportWidth = window.innerWidth;
+            const viewportHeight = window.innerHeight;
+            this.cursorX = viewportWidth / 2;
+            this.cursorY = viewportHeight / 2;
+            this.showCursor = true;
+            this.emitCursorPosition();
+            return;
+        }
+        const viewportWidth = window.innerWidth;
+        const viewportHeight = window.innerHeight;
+        switch (event.key) {
+            case 'ArrowUp':
+                this.cursorY = Math.max(0, this.cursorY - increment);
+                break;
+            case 'ArrowDown':
+                this.cursorY = Math.min(viewportHeight, this.cursorY + increment);
+                break;
+            case 'ArrowLeft':
+                this.cursorX = Math.max(0, this.cursorX - increment);
+                break;
+            case 'ArrowRight':
+                this.cursorX = Math.min(viewportWidth, this.cursorX + increment);
+                break;
+        }
+        this.emitCursorPosition();
+    }
+    startTextSelection() {
+        if (this.showCursor) {
+            this.selectionStartX = this.cursorX;
+            this.selectionStartY = this.cursorY;
+            this.selectionEndX = this.cursorX;
+            this.selectionEndY = this.cursorY;
+            this.showCursor = false;
+            this.emitCursorPosition();
+        }
+        else {
+            // default to center
+            this.selectionStartX = window.innerWidth / 2;
+            this.selectionStartY = window.innerHeight / 2;
+            this.selectionEndX = this.selectionStartX;
+            this.selectionEndY = this.selectionStartY;
+        }
+        this.isSelecting = true;
+        this.currentPage = this.getCurrentPageNumber();
+        this.lastValidEndNode = null;
+        this.lastValidEndOffset = 0;
+        this.selectionCursorPositionChanged.emit({
+            x: this.selectionEndX,
+            y: this.selectionEndY,
+            visible: true
+        });
+        this.createTextSelectionAtPoint(this.selectionStartX, this.selectionStartY);
+        this.selectionStarted.emit();
+    }
+    expandTextSelection(event) {
+        const increment = event.shiftKey ? this.incrementLarge : this.incrementSmall;
+        const viewportWidth = window.innerWidth;
+        const viewportHeight = window.innerHeight;
+        switch (event.key) {
+            case 'ArrowRight':
+                this.selectionEndX = Math.min(viewportWidth, this.selectionEndX + increment);
+                break;
+            case 'ArrowLeft':
+                this.selectionEndX = Math.max(0, this.selectionEndX - increment);
+                break;
+            case 'ArrowDown':
+                this.selectionEndY = Math.min(viewportHeight, this.selectionEndY + increment);
+                break;
+            case 'ArrowUp':
+                this.selectionEndY = Math.max(0, this.selectionEndY - increment);
+                break;
+        }
+        this.selectionCursorPositionChanged.emit({
+            x: this.selectionEndX,
+            y: this.selectionEndY,
+            visible: true
+        });
+        this.updateTextSelection();
+        this.emitSelectionUpdated();
+    }
+    createTextSelectionAtPoint(viewportX, viewportY) {
+        const selection = window.getSelection();
+        // get precise caret position at the coordinates
+        // caretPositionFromPoint is standard but not supported in all browsers
+        // caretRangeFromPoint is older and supported in more browsers
+        let range = null;
+        if (document.caretPositionFromPoint) {
+            const caretPosition = document.caretPositionFromPoint(viewportX, viewportY);
+            if (caretPosition) {
+                range = document.createRange();
+                range.setStart(caretPosition.offsetNode, caretPosition.offset);
+                range.collapse(true);
+            }
+        }
+        else if (document.caretRangeFromPoint) {
+            range = document.caretRangeFromPoint(viewportX, viewportY);
+        }
+        if (range) {
+            selection.removeAllRanges();
+            selection.addRange(range);
+        }
+    }
+    updateTextSelection() {
+        const selection = window.getSelection();
+        if (!selection || selection.rangeCount === 0) {
+            return;
+        }
+        const range = selection.getRangeAt(0);
+        const startNode = range.startContainer;
+        const startOffset = range.startOffset;
+        let endNode = null;
+        let endOffset = 0;
+        if (document.caretPositionFromPoint) {
+            const caretPosition = document.caretPositionFromPoint(this.selectionEndX, this.selectionEndY);
+            if (caretPosition) {
+                endNode = caretPosition.offsetNode;
+                endOffset = caretPosition.offset;
+            }
+        }
+        else if (document.caretRangeFromPoint) {
+            const caretRange = document.caretRangeFromPoint(this.selectionEndX, this.selectionEndY);
+            if (caretRange) {
+                endNode = caretRange.startContainer;
+                endOffset = caretRange.startOffset;
+            }
+        }
+        if (endNode) {
+            const range = document.createRange();
+            range.setStart(startNode, startOffset);
+            range.setEnd(endNode, endOffset);
+            const isBackward = range.collapsed && (startNode !== endNode || endOffset < startOffset);
+            const comparison = startNode.compareDocumentPosition(endNode);
+            const endBeforeStart = (comparison & Node.DOCUMENT_POSITION_PRECEDING) !== 0;
+            if (isBackward || endBeforeStart) {
+                if (this.lastValidEndNode) {
+                    endNode = this.lastValidEndNode;
+                    endOffset = this.lastValidEndOffset;
+                }
+                else {
+                    endNode = startNode;
+                    endOffset = startOffset;
+                }
+            }
+            else {
+                this.lastValidEndNode = endNode;
+                this.lastValidEndOffset = endOffset;
+            }
+            selection.setBaseAndExtent(startNode, startOffset, endNode, endOffset);
+        }
+    }
+    confirmTextSelection() {
+        this.selectionConfirmed.emit();
+        this.selectionCursorPositionChanged.emit({
+            x: this.selectionEndX,
+            y: this.selectionEndY,
+            visible: false
+        });
+        this.cleanup();
+    }
+    cancelTextSelection() {
+        const selection = window.getSelection();
+        if (selection) {
+            selection.removeAllRanges();
+        }
+        this.selectionCancelled.emit();
+        this.selectionCursorPositionChanged.emit({
+            x: this.selectionEndX,
+            y: this.selectionEndY,
+            visible: false
+        });
+        this.cleanup();
+    }
+    hideCursor() {
+        this.showCursor = false;
+        this.emitCursorPosition();
+    }
+    cleanup() {
+        this.isSelecting = false;
+        this.showCursor = false;
+        this.cursorX = undefined;
+        this.cursorY = undefined;
+        this.selectionStartX = undefined;
+        this.selectionStartY = undefined;
+        this.selectionEndX = undefined;
+        this.selectionEndY = undefined;
+        this.currentPage = undefined;
+        this.lastValidEndNode = null;
+        this.lastValidEndOffset = 0;
+    }
+    getCurrentPageNumber() {
+        let currentElement = this.elementRef.nativeElement;
+        while (currentElement && currentElement.offsetParent) {
+            currentElement = currentElement.offsetParent;
+            if (currentElement.getAttribute) {
+                const page = parseInt(currentElement.getAttribute('data-page-number'), 10);
+                if (page) {
+                    return page;
+                }
+            }
+        }
+        return 1;
+    }
+    emitCursorPosition() {
+        const position = {
+            x: this.cursorX,
+            y: this.cursorY,
+            visible: this.showCursor
+        };
+        this.cursorPositionChanged.emit(position);
+    }
+    emitSelectionUpdated() {
+        this.selectionUpdated.emit({
+            page: this.currentPage,
+            startX: this.selectionStartX,
+            startY: this.selectionStartY,
+            endX: this.selectionEndX,
+            endY: this.selectionEndY
+        });
+    }
+    reset() {
+        this.cleanup();
+        this.emitCursorPosition();
+    }
+    /** @nocollapse */ static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: KeyboardTextHighlightDirective, deps: [{ token: i0.ElementRef }], target: i0.ɵɵFactoryTarget.Directive }); }
+    /** @nocollapse */ static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "18.2.13", type: KeyboardTextHighlightDirective, selector: "[mvKeyboardTextHighlight]", inputs: { enabled: "enabled", incrementSmall: "incrementSmall", incrementMedium: "incrementMedium", incrementLarge: "incrementLarge" }, outputs: { selectionStarted: "selectionStarted", selectionUpdated: "selectionUpdated", selectionConfirmed: "selectionConfirmed", selectionCancelled: "selectionCancelled", cursorPositionChanged: "cursorPositionChanged", selectionCursorPositionChanged: "selectionCursorPositionChanged" }, host: { listeners: { "keydown": "onKeyDown($event)", "blur": "onBlur()" } }, ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: KeyboardTextHighlightDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[mvKeyboardTextHighlight]'
+                }]
+        }], ctorParameters: () => [{ type: i0.ElementRef }], propDecorators: { enabled: [{
+                type: Input
+            }], incrementSmall: [{
+                type: Input
+            }], incrementMedium: [{
+                type: Input
+            }], incrementLarge: [{
+                type: Input
+            }], selectionStarted: [{
+                type: Output
+            }], selectionUpdated: [{
+                type: Output
+            }], selectionConfirmed: [{
+                type: Output
+            }], selectionCancelled: [{
+                type: Output
+            }], cursorPositionChanged: [{
+                type: Output
+            }], selectionCursorPositionChanged: [{
+                type: Output
+            }], onKeyDown: [{
+                type: HostListener,
+                args: ['keydown', ['$event']]
+            }], onBlur: [{
+                type: HostListener,
+                args: ['blur']
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"keyboard-text-highlight.directive.js","sourceRoot":"","sources":["../../../../../../../../projects/media-viewer/src/lib/annotations/annotation-set/annotation-create/highlight-create/keyboard-text-highlight.directive.ts"],"names":[],"mappings":"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","sourcesContent":["import { Directive, ElementRef, EventEmitter, HostListener, Input, OnDestroy, Output } from '@angular/core';\n\nexport interface KeyboardTextHighlightEvent {\n  page: number;\n  startX: number;\n  startY: number;\n  endX: number;\n  endY: number;\n}\n\nexport interface CursorPosition {\n  x: number;\n  y: number;\n  visible: boolean;\n}\n\n@Directive({\n  selector: '[mvKeyboardTextHighlight]'\n})\nexport class KeyboardTextHighlightDirective implements OnDestroy {\n\n  @Input() set enabled(value: boolean) {\n    const wasEnabled = this._enabled;\n    this._enabled = value;\n  }\n  get enabled(): boolean {\n    return this._enabled;\n  }\n  private _enabled = false;\n\n  @Input() incrementSmall = 5;\n  @Input() incrementMedium = 10;\n  @Input() incrementLarge = 20;\n\n  @Output() selectionStarted = new EventEmitter<void>();\n  @Output() selectionUpdated = new EventEmitter<KeyboardTextHighlightEvent>();\n  @Output() selectionConfirmed = new EventEmitter<void>();\n  @Output() selectionCancelled = new EventEmitter<void>();\n  @Output() cursorPositionChanged = new EventEmitter<CursorPosition>();\n  @Output() selectionCursorPositionChanged = new EventEmitter<CursorPosition>();\n\n  private isSelecting = false;\n  private cursorX: number;\n  private cursorY: number;\n  private showCursor = false;\n  private selectionStartX: number;\n  private selectionStartY: number;\n  private selectionEndX: number;\n  private selectionEndY: number;\n  private currentPage: number;\n  private lastValidEndNode: Node | null = null;\n  private lastValidEndOffset: number = 0;\n  private static lastInteractionWasKeyboard = false;\n\n  constructor(private elementRef: ElementRef<HTMLElement>) {\n    if (typeof window !== 'undefined') {\n      window.addEventListener('keydown', KeyboardTextHighlightDirective.onGlobalKeyDown, { capture: true });\n      window.addEventListener('mousedown', KeyboardTextHighlightDirective.onGlobalMouseDown, { capture: true });\n    }\n  }\n\n  private static onGlobalKeyDown(): void {\n    KeyboardTextHighlightDirective.lastInteractionWasKeyboard = true;\n  }\n\n  private static onGlobalMouseDown(): void {\n    KeyboardTextHighlightDirective.lastInteractionWasKeyboard = false;\n  }\n\n  ngOnDestroy(): void {\n    this.cleanup();\n  }\n\n  @HostListener('keydown', ['$event'])\n  onKeyDown(event: KeyboardEvent): void {\n    if (!this.enabled) {\n      return;\n    }\n\n    if (event.key === 'Enter') {\n      event.preventDefault();\n      event.stopPropagation();\n\n      if (!this.isSelecting) {\n        this.startTextSelection();\n      } else {\n        this.confirmTextSelection();\n      }\n      return;\n    }\n\n    if (event.key === 'Escape') {\n      event.preventDefault();\n      event.stopPropagation();\n\n      if (this.isSelecting) {\n        this.cancelTextSelection();\n      } else if (this.showCursor) {\n        this.hideCursor();\n      }\n      return;\n    }\n\n    if (['ArrowUp', 'ArrowDown', 'ArrowLeft', 'ArrowRight'].includes(event.key)) {\n      event.preventDefault();\n      event.stopPropagation();\n\n      if (this.isSelecting) {\n        this.expandTextSelection(event);\n      } else {\n        this.moveCursor(event);\n      }\n    }\n  }\n\n  @HostListener('blur')\n  onBlur(): void {\n    if (this.showCursor && !this.isSelecting) {\n      this.hideCursor();\n    }\n  }\n\n  private moveCursor(event: KeyboardEvent): void {\n    const increment = event.shiftKey ? this.incrementLarge : this.incrementMedium;\n\n    if (!this.showCursor) {\n      const viewportWidth = window.innerWidth;\n      const viewportHeight = window.innerHeight;\n\n      this.cursorX = viewportWidth / 2;\n      this.cursorY = viewportHeight / 2;\n      this.showCursor = true;\n\n      this.emitCursorPosition();\n      return;\n    }\n\n    const viewportWidth = window.innerWidth;\n    const viewportHeight = window.innerHeight;\n\n    switch (event.key) {\n      case 'ArrowUp':\n        this.cursorY = Math.max(0, this.cursorY - increment);\n        break;\n      case 'ArrowDown':\n        this.cursorY = Math.min(viewportHeight, this.cursorY + increment);\n        break;\n      case 'ArrowLeft':\n        this.cursorX = Math.max(0, this.cursorX - increment);\n        break;\n      case 'ArrowRight':\n        this.cursorX = Math.min(viewportWidth, this.cursorX + increment);\n        break;\n    }\n\n    this.emitCursorPosition();\n  }\n\n  private startTextSelection(): void {\n    if (this.showCursor) {\n      this.selectionStartX = this.cursorX;\n      this.selectionStartY = this.cursorY;\n      this.selectionEndX = this.cursorX;\n      this.selectionEndY = this.cursorY;\n      this.showCursor = false;\n      this.emitCursorPosition();\n    } else {\n      // default to center\n      this.selectionStartX = window.innerWidth / 2;\n      this.selectionStartY = window.innerHeight / 2;\n      this.selectionEndX = this.selectionStartX;\n      this.selectionEndY = this.selectionStartY;\n    }\n\n    this.isSelecting = true;\n    this.currentPage = this.getCurrentPageNumber();\n    this.lastValidEndNode = null;\n    this.lastValidEndOffset = 0;\n\n    this.selectionCursorPositionChanged.emit({\n      x: this.selectionEndX,\n      y: this.selectionEndY,\n      visible: true\n    });\n\n    this.createTextSelectionAtPoint(this.selectionStartX, this.selectionStartY);\n\n    this.selectionStarted.emit();\n  }\n\n  private expandTextSelection(event: KeyboardEvent): void {\n    const increment = event.shiftKey ? this.incrementLarge : this.incrementSmall;\n\n    const viewportWidth = window.innerWidth;\n    const viewportHeight = window.innerHeight;\n\n    switch (event.key) {\n      case 'ArrowRight':\n        this.selectionEndX = Math.min(viewportWidth, this.selectionEndX + increment);\n        break;\n      case 'ArrowLeft':\n        this.selectionEndX = Math.max(0, this.selectionEndX - increment);\n        break;\n      case 'ArrowDown':\n        this.selectionEndY = Math.min(viewportHeight, this.selectionEndY + increment);\n        break;\n      case 'ArrowUp':\n        this.selectionEndY = Math.max(0, this.selectionEndY - increment);\n        break;\n    }\n\n    this.selectionCursorPositionChanged.emit({\n      x: this.selectionEndX,\n      y: this.selectionEndY,\n      visible: true\n    });\n\n    this.updateTextSelection();\n\n    this.emitSelectionUpdated();\n  }\n\n  private createTextSelectionAtPoint(viewportX: number, viewportY: number): void {\n    const selection = window.getSelection();\n\n    // get precise caret position at the coordinates\n    // caretPositionFromPoint is standard but not supported in all browsers\n    // caretRangeFromPoint is older and supported in more browsers\n    let range: Range | null = null;\n\n    if ((document as any).caretPositionFromPoint) {\n      const caretPosition = (document as any).caretPositionFromPoint(viewportX, viewportY);\n      if (caretPosition) {\n        range = document.createRange();\n        range.setStart(caretPosition.offsetNode, caretPosition.offset);\n        range.collapse(true);\n      }\n    } else if ((document as any).caretRangeFromPoint) {\n      range = (document as any).caretRangeFromPoint(viewportX, viewportY);\n    }\n\n    if (range) {\n      selection.removeAllRanges();\n      selection.addRange(range);\n    }\n  }\n\n  private updateTextSelection(): void {\n    const selection = window.getSelection();\n    if (!selection || selection.rangeCount === 0) {\n      return;\n    }\n\n    const range = selection.getRangeAt(0);\n    const startNode = range.startContainer;\n    const startOffset = range.startOffset;\n\n    let endNode: Node | null = null;\n    let endOffset = 0;\n\n    if ((document as any).caretPositionFromPoint) {\n      const caretPosition = (document as any).caretPositionFromPoint(this.selectionEndX, this.selectionEndY);\n      if (caretPosition) {\n        endNode = caretPosition.offsetNode;\n        endOffset = caretPosition.offset;\n      }\n    } else if ((document as any).caretRangeFromPoint) {\n      const caretRange = (document as any).caretRangeFromPoint(this.selectionEndX, this.selectionEndY);\n      if (caretRange) {\n        endNode = caretRange.startContainer;\n        endOffset = caretRange.startOffset;\n      }\n    }\n\n    if (endNode) {\n      const range = document.createRange();\n      range.setStart(startNode, startOffset);\n      range.setEnd(endNode, endOffset);\n\n      const isBackward = range.collapsed && (startNode !== endNode || endOffset < startOffset);\n      const comparison = startNode.compareDocumentPosition(endNode);\n      const endBeforeStart = (comparison & Node.DOCUMENT_POSITION_PRECEDING) !== 0;\n\n      if (isBackward || endBeforeStart) {\n        if (this.lastValidEndNode) {\n          endNode = this.lastValidEndNode;\n          endOffset = this.lastValidEndOffset;\n        } else {\n          endNode = startNode;\n          endOffset = startOffset;\n        }\n      } else {\n        this.lastValidEndNode = endNode;\n        this.lastValidEndOffset = endOffset;\n      }\n\n      selection.setBaseAndExtent(\n        startNode,\n        startOffset,\n        endNode,\n        endOffset\n      );\n    }\n  }\n\n  private confirmTextSelection(): void {\n    this.selectionConfirmed.emit();\n    this.selectionCursorPositionChanged.emit({\n      x: this.selectionEndX,\n      y: this.selectionEndY,\n      visible: false\n    });\n    this.cleanup();\n  }\n\n  private cancelTextSelection(): void {\n    const selection = window.getSelection();\n    if (selection) {\n      selection.removeAllRanges();\n    }\n\n    this.selectionCancelled.emit();\n    this.selectionCursorPositionChanged.emit({\n      x: this.selectionEndX,\n      y: this.selectionEndY,\n      visible: false\n    });\n    this.cleanup();\n  }\n\n  private hideCursor(): void {\n    this.showCursor = false;\n    this.emitCursorPosition();\n  }\n\n  private cleanup(): void {\n    this.isSelecting = false;\n    this.showCursor = false;\n    this.cursorX = undefined;\n    this.cursorY = undefined;\n    this.selectionStartX = undefined;\n    this.selectionStartY = undefined;\n    this.selectionEndX = undefined;\n    this.selectionEndY = undefined;\n    this.currentPage = undefined;\n    this.lastValidEndNode = null;\n    this.lastValidEndOffset = 0;\n  }\n\n  private getCurrentPageNumber(): number {\n    let currentElement = this.elementRef.nativeElement;\n    while (currentElement && currentElement.offsetParent) {\n      currentElement = currentElement.offsetParent as HTMLElement;\n      if (currentElement.getAttribute) {\n        const page = parseInt(currentElement.getAttribute('data-page-number'), 10);\n        if (page) {\n          return page;\n        }\n      }\n    }\n    return 1;\n  }\n\n  private emitCursorPosition(): void {\n    const position = {\n      x: this.cursorX,\n      y: this.cursorY,\n      visible: this.showCursor\n    };\n    this.cursorPositionChanged.emit(position);\n  }\n\n  private emitSelectionUpdated(): void {\n    this.selectionUpdated.emit({\n      page: this.currentPage,\n      startX: this.selectionStartX,\n      startY: this.selectionStartY,\n      endX: this.selectionEndX,\n      endY: this.selectionEndY\n    });\n  }\n\n  public reset(): void {\n    this.cleanup();\n    this.emitCursorPosition();\n  }\n}"]}

package/esm2022/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 */ static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: AnnotationSetComponent, deps: [{ token: i1.Store }, { token: i2.CommentService }], target: i0.ɵɵFactoryTarget.Component }); }
+    /** @nocollapse */ static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "18.2.13", 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: "18.2.13", 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: () => [{ 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/esm2022/lib/annotations/annotation-set/annotation-set.model.mjs

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYW5ub3RhdGlvbi1zZXQubW9kZWwuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9tZWRpYS12aWV3ZXIvc3JjL2xpYi9hbm5vdGF0aW9ucy9hbm5vdGF0aW9uLXNldC9hbm5vdGF0aW9uLXNldC5tb2RlbC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgQXBpUGVyc2lzdGVkIH0gZnJvbSAnLi4vbW9kZWxzL2FwaS1wZXJzaXN0ZWQubW9kZWwnO1xuaW1wb3J0IHsgQW5ub3RhdGlvbiB9IGZyb20gJy4vYW5ub3RhdGlvbi12aWV3L2Fubm90YXRpb24ubW9kZWwnO1xuXG5leHBvcnQgaW50ZXJmYWNlIEFubm90YXRpb25TZXQgZXh0ZW5kcyBBcGlQZXJzaXN0ZWQge1xuICBkb2N1bWVudElkOiBzdHJpbmc7XG4gIGFubm90YXRpb25zOiBBbm5vdGF0aW9uW107XG59XG4iXX0=

package/esm2022/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 */ static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: AnnotationViewComponent, deps: [{ token: i1.ToolbarEventService }, { token: i2.Store }], target: i0.ɵɵFactoryTarget.Component }); }
+    /** @nocollapse */ static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "18.2.13", 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", "cancelEvent"] }] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", 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: () => [{ 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,CAAC;YACf,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;QACrF,CAAC;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,CAAC;YACpC,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;QAEjE,CAAC;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;kIArEU,uBAAuB;sHAAvB,uBAAuB,4YChBpC,y+BA0BA;;4FDVa,uBAAuB;kBAJnC,SAAS;+BACE,eAAe;4GAKZ,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"]}

package/esm2022/lib/annotations/annotation-set/annotation-view/annotation.model.mjs

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYW5ub3RhdGlvbi5tb2RlbC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL21lZGlhLXZpZXdlci9zcmMvbGliL2Fubm90YXRpb25zL2Fubm90YXRpb24tc2V0L2Fubm90YXRpb24tdmlldy9hbm5vdGF0aW9uLm1vZGVsLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiIiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBBcGlQZXJzaXN0ZWQgfSBmcm9tICcuLi8uLi9tb2RlbHMvYXBpLXBlcnNpc3RlZC5tb2RlbCc7XG5pbXBvcnQgeyBSZWN0YW5nbGUgfSBmcm9tICcuL3JlY3RhbmdsZS9yZWN0YW5nbGUubW9kZWwnO1xuaW1wb3J0IHsgQ29tbWVudCB9IGZyb20gJy4uLy4uL2NvbW1lbnQtc2V0L2NvbW1lbnQvY29tbWVudC5tb2RlbCc7XG5pbXBvcnQge1RhZ3NNb2RlbH0gZnJvbSAnLi4vLi4vbW9kZWxzL3RhZ3MubW9kZWwnO1xuXG5leHBvcnQgaW50ZXJmYWNlIEFubm90YXRpb24gZXh0ZW5kcyBBcGlQZXJzaXN0ZWQge1xuICBhbm5vdGF0aW9uU2V0SWQ/OiBzdHJpbmc7XG4gIGFubm90YXRpb25JZD86IHN0cmluZztcbiAgcGFnZT86IG51bWJlcjtcbiAgY29sb3I/OiBzdHJpbmc7XG4gIGNvbW1lbnRzPzogQ29tbWVudFtdO1xuICByZWN0YW5nbGVzPzogUmVjdGFuZ2xlW107XG4gIHR5cGU/OiBzdHJpbmc7XG4gIHRhZ3M6IFRhZ3NNb2RlbFtdO1xuICByZWRhY3Rpb25JZD86IHN0cmluZztcbn1cbiJdfQ==