@hmcts/media-viewer 4.1.8 → 4.1.9-exui-1580

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

@@ -0,0 +1,354 @@
+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;
+        // Don't auto-initialize cursor - let it appear on first arrow key press
+        // This prevents the Enter key from the button click triggering startTextSelection
+    }
+    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) {
+            // we use window dimensions because we're using fixed positioning
+            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;
+        // get end position using caret APIs
+        // caretPositionFromPoint is standard but not supported in all browsers
+        // caretRangeFromPoint is older and supported in more browsers
+        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;
+            }
+            // use setBaseAndExtent to handle selection direction with precise offsets
+            // to ensure the selection always starts from the original start point
+            // and extends to the exact character position at the cursor
+            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    // Don't auto-initialize cursor - let it appear on first arrow key press\n    // This prevents the Enter key from the button click triggering startTextSelection\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      // we use window dimensions because we're using fixed positioning\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    // get end position using caret APIs\n    // caretPositionFromPoint is standard but not supported in all browsers\n    // caretRangeFromPoint is older and supported in more browsers\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      // use setBaseAndExtent to handle selection direction with precise offsets\n      // to ensure the selection always starts from the original start point\n      // and extends to the exact character position at the cursor\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-view/annotation-view.component.mjs

@@ -64,7 +64,7 @@ export class AnnotationViewComponent {
         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"] }] }); }
+    /** @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,

package/esm2022/lib/annotations/annotation-set/ctx-toolbar/ctx-toolbar.component.mjs

@@ -1,4 +1,4 @@
-import { Component, EventEmitter, Input, Output } from '@angular/core';
+import { Component, EventEmitter, HostListener, Input, Output, ViewChild } from '@angular/core';
 import * as i0 from "@angular/core";
 import * as i1 from "@angular/common";
 export class CtxToolbarComponent {
@@ -7,6 +7,7 @@ export class CtxToolbarComponent {
         this.deleteHighlightEvent = new EventEmitter();
         this.addOrEditCommentEvent = new EventEmitter();
         this.createBookmarkEvent = new EventEmitter();
+        this.cancelEvent = new EventEmitter();
         this.defaultHeight = 70;
         this.defaultWidth = 300;
     }
@@ -15,6 +16,14 @@ export class CtxToolbarComponent {
         this.top = this.popupTop();
         this.left = this.popupLeft();
     }
+    onEscapeKey(event) {
+        if (this.rectangle) {
+            event.stopPropagation();
+            event.preventDefault();
+            this.rectangle = undefined;
+            this.cancelEvent.emit();
+        }
+    }
     set rectangles(rectangles) {
         if (rectangles) {
             this._rectangles = rectangles;
@@ -83,13 +92,25 @@ export class CtxToolbarComponent {
             return popupLeft;
         }
     }
+    focusToolbar() {
+        if (this.toolbarContainer?.nativeElement) {
+            const firstButton = this.toolbarContainer.nativeElement.querySelector('button');
+            if (firstButton) {
+                setTimeout(() => firstButton.focus(), 0);
+                return;
+            }
+        }
+    }
     /** @nocollapse */ static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: CtxToolbarComponent, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
-    /** @nocollapse */ static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "18.2.13", type: CtxToolbarComponent, selector: "mv-ctx-toolbar", inputs: { zoom: "zoom", rotate: "rotate", pageHeight: "pageHeight", pageWidth: "pageWidth", canHighlight: "canHighlight", canBookmark: "canBookmark", canComment: "canComment", canDelete: "canDelete", rectangles: "rectangles" }, outputs: { createHighlightEvent: "createHighlightEvent", deleteHighlightEvent: "deleteHighlightEvent", addOrEditCommentEvent: "addOrEditCommentEvent", createBookmarkEvent: "createBookmarkEvent" }, usesOnChanges: true, ngImport: i0, template: "<div class=\"toolbar\" *ngIf=\"rectangle\"\n     [style.top.px]=\"top\"\n     [style.left.px]=\"left\">\n  <button *ngIf=\"canHighlight\"\n          type=\"button\" title=\"Highlight\"\n          class=\"aui__toolbar-button aui__toolbar-button--comments contextual-btn leftButton aui__toolbar-button-highlight\"\n          (mousedown)=\"createHighlight()\">\n    <span>Highlight</span>\n  </button>\n  <button *ngIf=\"canDelete\"\n          type=\"button\" title=\"Delete\"\n          class=\"aui__toolbar-button aui__toolbar-button--comments contextual-btn leftButton\"\n          (mousedown)=\"deleteHighlight()\">\n    <span>Remove</span>\n  </button>\n  <button *ngIf=\"canComment\"\n          type=\"button\" title=\"Comment\"\n          class=\"aui__toolbar-button aui__toolbar-button--comments contextual-btn rightButton aui__toolbar-button-comment\"\n          (mousedown)=\"addOrEditComment()\">\n    <span>Comment</span></button>\n  <button *ngIf=\"canBookmark\"\n          type=\"button\" title=\"Bookmark\"\n          class=\"aui__toolbar-button aui__toolbar-button--comments contextual-btn rightButton aui__toolbar-button-bookmark\"\n          id=\"bookmarkButton\"\n          (mousedown)=\"createBookmark()\">\n    <span>Bookmark</span></button>\n  <div class=\"arrow-down\">\n    <div class=\"inner-triangle\"></div>\n  </div>\n</div>\n", dependencies: [{ kind: "directive", type: i1.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }] }); }
+    /** @nocollapse */ static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "18.2.13", type: CtxToolbarComponent, selector: "mv-ctx-toolbar", inputs: { zoom: "zoom", rotate: "rotate", pageHeight: "pageHeight", pageWidth: "pageWidth", canHighlight: "canHighlight", canBookmark: "canBookmark", canComment: "canComment", canDelete: "canDelete", rectangles: "rectangles" }, outputs: { createHighlightEvent: "createHighlightEvent", deleteHighlightEvent: "deleteHighlightEvent", addOrEditCommentEvent: "addOrEditCommentEvent", createBookmarkEvent: "createBookmarkEvent", cancelEvent: "cancelEvent" }, host: { listeners: { "document:keydown.escape": "onEscapeKey($event)" } }, viewQueries: [{ propertyName: "toolbarContainer", first: true, predicate: ["toolbarContainer"], descendants: true }], usesOnChanges: true, ngImport: i0, template: "<div #toolbarContainer class=\"toolbar\" *ngIf=\"rectangle\"\n     [style.top.px]=\"top\"\n     [style.left.px]=\"left\">\n  <button *ngIf=\"canHighlight\"\n          type=\"button\" title=\"Highlight\"\n          class=\"aui__toolbar-button aui__toolbar-button--comments contextual-btn leftButton aui__toolbar-button-highlight\"\n          (mousedown)=\"createHighlight()\"\n          (keydown.enter)=\"createHighlight()\">\n    <span>Highlight</span>\n  </button>\n  <button *ngIf=\"canDelete\"\n          type=\"button\" title=\"Delete\"\n          class=\"aui__toolbar-button aui__toolbar-button--comments contextual-btn leftButton\"\n          (mousedown)=\"deleteHighlight()\"\n          (keydown.enter)=\"deleteHighlight()\">\n    <span>Remove</span>\n  </button>\n  <button *ngIf=\"canComment\"\n          type=\"button\" title=\"Comment\"\n          class=\"aui__toolbar-button aui__toolbar-button--comments contextual-btn rightButton aui__toolbar-button-comment\"\n          (mousedown)=\"addOrEditComment()\"\n          (keydown.enter)=\"addOrEditComment()\">\n    <span>Comment</span></button>\n  <button *ngIf=\"canBookmark\"\n          type=\"button\" title=\"Bookmark\"\n          class=\"aui__toolbar-button aui__toolbar-button--comments contextual-btn rightButton aui__toolbar-button-bookmark\"\n          id=\"bookmarkButton\"\n          (mousedown)=\"createBookmark()\"\n          (keydown.enter)=\"createBookmark()\">\n    <span>Bookmark</span></button>\n  <div class=\"arrow-down\">\n    <div class=\"inner-triangle\"></div>\n  </div>\n</div>\n", dependencies: [{ kind: "directive", type: i1.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }] }); }
 }
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: CtxToolbarComponent, decorators: [{
             type: Component,
-            args: [{ selector: 'mv-ctx-toolbar', template: "<div class=\"toolbar\" *ngIf=\"rectangle\"\n     [style.top.px]=\"top\"\n     [style.left.px]=\"left\">\n  <button *ngIf=\"canHighlight\"\n          type=\"button\" title=\"Highlight\"\n          class=\"aui__toolbar-button aui__toolbar-button--comments contextual-btn leftButton aui__toolbar-button-highlight\"\n          (mousedown)=\"createHighlight()\">\n    <span>Highlight</span>\n  </button>\n  <button *ngIf=\"canDelete\"\n          type=\"button\" title=\"Delete\"\n          class=\"aui__toolbar-button aui__toolbar-button--comments contextual-btn leftButton\"\n          (mousedown)=\"deleteHighlight()\">\n    <span>Remove</span>\n  </button>\n  <button *ngIf=\"canComment\"\n          type=\"button\" title=\"Comment\"\n          class=\"aui__toolbar-button aui__toolbar-button--comments contextual-btn rightButton aui__toolbar-button-comment\"\n          (mousedown)=\"addOrEditComment()\">\n    <span>Comment</span></button>\n  <button *ngIf=\"canBookmark\"\n          type=\"button\" title=\"Bookmark\"\n          class=\"aui__toolbar-button aui__toolbar-button--comments contextual-btn rightButton aui__toolbar-button-bookmark\"\n          id=\"bookmarkButton\"\n          (mousedown)=\"createBookmark()\">\n    <span>Bookmark</span></button>\n  <div class=\"arrow-down\">\n    <div class=\"inner-triangle\"></div>\n  </div>\n</div>\n" }]
-        }], ctorParameters: () => [], propDecorators: { zoom: [{
+            args: [{ selector: 'mv-ctx-toolbar', template: "<div #toolbarContainer class=\"toolbar\" *ngIf=\"rectangle\"\n     [style.top.px]=\"top\"\n     [style.left.px]=\"left\">\n  <button *ngIf=\"canHighlight\"\n          type=\"button\" title=\"Highlight\"\n          class=\"aui__toolbar-button aui__toolbar-button--comments contextual-btn leftButton aui__toolbar-button-highlight\"\n          (mousedown)=\"createHighlight()\"\n          (keydown.enter)=\"createHighlight()\">\n    <span>Highlight</span>\n  </button>\n  <button *ngIf=\"canDelete\"\n          type=\"button\" title=\"Delete\"\n          class=\"aui__toolbar-button aui__toolbar-button--comments contextual-btn leftButton\"\n          (mousedown)=\"deleteHighlight()\"\n          (keydown.enter)=\"deleteHighlight()\">\n    <span>Remove</span>\n  </button>\n  <button *ngIf=\"canComment\"\n          type=\"button\" title=\"Comment\"\n          class=\"aui__toolbar-button aui__toolbar-button--comments contextual-btn rightButton aui__toolbar-button-comment\"\n          (mousedown)=\"addOrEditComment()\"\n          (keydown.enter)=\"addOrEditComment()\">\n    <span>Comment</span></button>\n  <button *ngIf=\"canBookmark\"\n          type=\"button\" title=\"Bookmark\"\n          class=\"aui__toolbar-button aui__toolbar-button--comments contextual-btn rightButton aui__toolbar-button-bookmark\"\n          id=\"bookmarkButton\"\n          (mousedown)=\"createBookmark()\"\n          (keydown.enter)=\"createBookmark()\">\n    <span>Bookmark</span></button>\n  <div class=\"arrow-down\">\n    <div class=\"inner-triangle\"></div>\n  </div>\n</div>\n" }]
+        }], ctorParameters: () => [], propDecorators: { toolbarContainer: [{
+                type: ViewChild,
+                args: ['toolbarContainer', { static: false }]
+            }], zoom: [{
                 type: Input
             }], rotate: [{
                 type: Input
@@ -113,7 +134,12 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImpo
                 type: Output
             }], createBookmarkEvent: [{
                 type: Output
+            }], cancelEvent: [{
+                type: Output
+            }], onEscapeKey: [{
+                type: HostListener,
+                args: ['document:keydown.escape', ['$event']]
             }], rectangles: [{
                 type: Input
             }] } });
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"ctx-toolbar.component.js","sourceRoot":"","sources":["../../../../../../../projects/media-viewer/src/lib/annotations/annotation-set/ctx-toolbar/ctx-toolbar.component.ts","../../../../../../../projects/media-viewer/src/lib/annotations/annotation-set/ctx-toolbar/ctx-toolbar.component.html"],"names":[],"mappings":"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","sourcesContent":["import {\n  ChangeDetectionStrategy,\n  Component,\n  EventEmitter,\n  Input,\n  OnChanges,\n  Output,\n  SimpleChanges\n} from '@angular/core';\nimport { Rectangle } from '../annotation-view/rectangle/rectangle.model';\n\n@Component({\n  selector: 'mv-ctx-toolbar',\n  templateUrl: './ctx-toolbar.component.html'\n})\nexport class CtxToolbarComponent implements OnChanges {\n\n  readonly defaultHeight;\n  readonly defaultWidth;\n\n  @Input() zoom;\n  @Input() rotate;\n  @Input() pageHeight: number;\n  @Input() pageWidth: number;\n\n  @Input() canHighlight: boolean;\n  @Input() canBookmark: boolean;\n  @Input() canComment: boolean;\n  @Input() canDelete: boolean;\n\n  @Output() createHighlightEvent = new EventEmitter();\n  @Output() deleteHighlightEvent = new EventEmitter();\n  @Output() addOrEditCommentEvent = new EventEmitter();\n  @Output() createBookmarkEvent = new EventEmitter<Rectangle>();\n\n  rectangle: Rectangle;\n  _rectangles: Rectangle[];\n  top: number;\n  left: number;\n\n  constructor() {\n    this.defaultHeight = 70;\n    this.defaultWidth = 300;\n  }\n\n  ngOnChanges(changes: SimpleChanges) {\n    this.setRectangle();\n    this.top = this.popupTop();\n    this.left = this.popupLeft();\n  }\n\n  @Input() set rectangles(rectangles: Rectangle[]) {\n    if (rectangles) {\n      this._rectangles = rectangles;\n      this.setRectangle();\n    }\n  }\n\n  get rectangles() {\n    return this._rectangles;\n  }\n\n  createHighlight() {\n    this.createHighlightEvent.emit();\n    this.rectangle = undefined;\n  }\n\n  deleteHighlight() {\n    this.deleteHighlightEvent.emit();\n  }\n\n  addOrEditComment() {\n    this.addOrEditCommentEvent.emit();\n    setTimeout(() => {\n      // This hack to wait until the element is rendered seems to be unreliable,\n      if (!location.hash) {\n        document.getElementById('viewerContainer')?.scrollBy(0, 1);\n      }\n    }, 20);\n  }\n\n  createBookmark() {\n    this.createBookmarkEvent.emit(this.rectangle);\n    this.rectangle = undefined;\n  }\n\n  setRectangle() {\n    const rectangle = this.rectangles\n      .reduce((prev, current) => prev.y < current.y ? prev : current);\n    this.rectangle =  { ...rectangle };\n    switch (this.rotate) {\n      case 90:\n        this.rectangle.width = rectangle.height;\n        this.rectangle.height = rectangle.width;\n        this.rectangle.x = (this.pageWidth / this.zoom) - rectangle.y - rectangle.height;\n        this.rectangle.y = rectangle.x;\n        break;\n      case 180:\n        this.rectangle.x = (this.pageWidth / this.zoom) - rectangle.x - rectangle.width;\n        this.rectangle.y = (this.pageHeight / this.zoom) - rectangle.y - rectangle.height;\n        break;\n      case 270:\n        this.rectangle.width = rectangle.height;\n        this.rectangle.height = rectangle.width;\n        this.rectangle.x = rectangle.y;\n        this.rectangle.y = (this.pageHeight / this.zoom) - rectangle.x - rectangle.width;\n        break;\n    }\n  }\n\n  popupTop() {\n    const popupTop = this.rectangle.y * this.zoom - this.defaultHeight;\n    return popupTop <= 0 ? this.defaultHeight : popupTop;\n  }\n\n  popupLeft() {\n    const popupLeft = (this.rectangle.x + (this.rectangle.width / 2)) * this.zoom - (this.defaultWidth / 2);\n    if (popupLeft <= 0) {\n      return 0;\n    } else if (popupLeft >= this.pageWidth - this.defaultWidth) {\n      return this.pageWidth - this.defaultWidth;\n    } else {\n      return popupLeft;\n    }\n  }\n}\n","<div class=\"toolbar\" *ngIf=\"rectangle\"\n     [style.top.px]=\"top\"\n     [style.left.px]=\"left\">\n  <button *ngIf=\"canHighlight\"\n          type=\"button\" title=\"Highlight\"\n          class=\"aui__toolbar-button aui__toolbar-button--comments contextual-btn leftButton aui__toolbar-button-highlight\"\n          (mousedown)=\"createHighlight()\">\n    <span>Highlight</span>\n  </button>\n  <button *ngIf=\"canDelete\"\n          type=\"button\" title=\"Delete\"\n          class=\"aui__toolbar-button aui__toolbar-button--comments contextual-btn leftButton\"\n          (mousedown)=\"deleteHighlight()\">\n    <span>Remove</span>\n  </button>\n  <button *ngIf=\"canComment\"\n          type=\"button\" title=\"Comment\"\n          class=\"aui__toolbar-button aui__toolbar-button--comments contextual-btn rightButton aui__toolbar-button-comment\"\n          (mousedown)=\"addOrEditComment()\">\n    <span>Comment</span></button>\n  <button *ngIf=\"canBookmark\"\n          type=\"button\" title=\"Bookmark\"\n          class=\"aui__toolbar-button aui__toolbar-button--comments contextual-btn rightButton aui__toolbar-button-bookmark\"\n          id=\"bookmarkButton\"\n          (mousedown)=\"createBookmark()\">\n    <span>Bookmark</span></button>\n  <div class=\"arrow-down\">\n    <div class=\"inner-triangle\"></div>\n  </div>\n</div>\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"ctx-toolbar.component.js","sourceRoot":"","sources":["../../../../../../../projects/media-viewer/src/lib/annotations/annotation-set/ctx-toolbar/ctx-toolbar.component.ts","../../../../../../../projects/media-viewer/src/lib/annotations/annotation-set/ctx-toolbar/ctx-toolbar.component.html"],"names":[],"mappings":"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","sourcesContent":["import {\n  ChangeDetectionStrategy,\n  Component,\n  ElementRef,\n  EventEmitter,\n  HostListener,\n  Input,\n  OnChanges,\n  Output,\n  SimpleChanges,\n  ViewChild\n} from '@angular/core';\nimport { Rectangle } from '../annotation-view/rectangle/rectangle.model';\n\n@Component({\n  selector: 'mv-ctx-toolbar',\n  templateUrl: './ctx-toolbar.component.html'\n})\nexport class CtxToolbarComponent implements OnChanges {\n\n  readonly defaultHeight;\n  readonly defaultWidth;\n\n  @ViewChild('toolbarContainer', { static: false }) toolbarContainer: ElementRef<HTMLDivElement>;\n\n  @Input() zoom;\n  @Input() rotate;\n  @Input() pageHeight: number;\n  @Input() pageWidth: number;\n\n  @Input() canHighlight: boolean;\n  @Input() canBookmark: boolean;\n  @Input() canComment: boolean;\n  @Input() canDelete: boolean;\n\n  @Output() createHighlightEvent = new EventEmitter();\n  @Output() deleteHighlightEvent = new EventEmitter();\n  @Output() addOrEditCommentEvent = new EventEmitter();\n  @Output() createBookmarkEvent = new EventEmitter<Rectangle>();\n  @Output() cancelEvent = new EventEmitter();\n\n  rectangle: Rectangle;\n  _rectangles: Rectangle[];\n  top: number;\n  left: number;\n\n  constructor() {\n    this.defaultHeight = 70;\n    this.defaultWidth = 300;\n  }\n\n  ngOnChanges(changes: SimpleChanges) {\n    this.setRectangle();\n    this.top = this.popupTop();\n    this.left = this.popupLeft();\n  }\n\n  @HostListener('document:keydown.escape', ['$event'])\n  onEscapeKey(event: KeyboardEvent) {\n    if (this.rectangle) {\n      event.stopPropagation();\n      event.preventDefault();\n      this.rectangle = undefined;\n      this.cancelEvent.emit();\n    }\n  }\n\n  @Input() set rectangles(rectangles: Rectangle[]) {\n    if (rectangles) {\n      this._rectangles = rectangles;\n      this.setRectangle();\n    }\n  }\n\n  get rectangles() {\n    return this._rectangles;\n  }\n\n  createHighlight() {\n    this.createHighlightEvent.emit();\n    this.rectangle = undefined;\n  }\n\n  deleteHighlight() {\n    this.deleteHighlightEvent.emit();\n  }\n\n  addOrEditComment() {\n    this.addOrEditCommentEvent.emit();\n    setTimeout(() => {\n      // This hack to wait until the element is rendered seems to be unreliable,\n      if (!location.hash) {\n        document.getElementById('viewerContainer')?.scrollBy(0, 1);\n      }\n    }, 20);\n  }\n\n  createBookmark() {\n    this.createBookmarkEvent.emit(this.rectangle);\n    this.rectangle = undefined;\n  }\n\n  setRectangle() {\n    const rectangle = this.rectangles\n      .reduce((prev, current) => prev.y < current.y ? prev : current);\n    this.rectangle =  { ...rectangle };\n    switch (this.rotate) {\n      case 90:\n        this.rectangle.width = rectangle.height;\n        this.rectangle.height = rectangle.width;\n        this.rectangle.x = (this.pageWidth / this.zoom) - rectangle.y - rectangle.height;\n        this.rectangle.y = rectangle.x;\n        break;\n      case 180:\n        this.rectangle.x = (this.pageWidth / this.zoom) - rectangle.x - rectangle.width;\n        this.rectangle.y = (this.pageHeight / this.zoom) - rectangle.y - rectangle.height;\n        break;\n      case 270:\n        this.rectangle.width = rectangle.height;\n        this.rectangle.height = rectangle.width;\n        this.rectangle.x = rectangle.y;\n        this.rectangle.y = (this.pageHeight / this.zoom) - rectangle.x - rectangle.width;\n        break;\n    }\n  }\n\n  popupTop() {\n    const popupTop = this.rectangle.y * this.zoom - this.defaultHeight;\n    return popupTop <= 0 ? this.defaultHeight : popupTop;\n  }\n\n  popupLeft() {\n    const popupLeft = (this.rectangle.x + (this.rectangle.width / 2)) * this.zoom - (this.defaultWidth / 2);\n    if (popupLeft <= 0) {\n      return 0;\n    } else if (popupLeft >= this.pageWidth - this.defaultWidth) {\n      return this.pageWidth - this.defaultWidth;\n    } else {\n      return popupLeft;\n    }\n  }\n\n  focusToolbar(): void {\n    if (this.toolbarContainer?.nativeElement) {\n      const firstButton = this.toolbarContainer.nativeElement.querySelector('button');\n      \n      if (firstButton) {\n        setTimeout(() => firstButton.focus(), 0);\n        return;\n      } \n    }\n  }\n}\n","<div #toolbarContainer class=\"toolbar\" *ngIf=\"rectangle\"\n     [style.top.px]=\"top\"\n     [style.left.px]=\"left\">\n  <button *ngIf=\"canHighlight\"\n          type=\"button\" title=\"Highlight\"\n          class=\"aui__toolbar-button aui__toolbar-button--comments contextual-btn leftButton aui__toolbar-button-highlight\"\n          (mousedown)=\"createHighlight()\"\n          (keydown.enter)=\"createHighlight()\">\n    <span>Highlight</span>\n  </button>\n  <button *ngIf=\"canDelete\"\n          type=\"button\" title=\"Delete\"\n          class=\"aui__toolbar-button aui__toolbar-button--comments contextual-btn leftButton\"\n          (mousedown)=\"deleteHighlight()\"\n          (keydown.enter)=\"deleteHighlight()\">\n    <span>Remove</span>\n  </button>\n  <button *ngIf=\"canComment\"\n          type=\"button\" title=\"Comment\"\n          class=\"aui__toolbar-button aui__toolbar-button--comments contextual-btn rightButton aui__toolbar-button-comment\"\n          (mousedown)=\"addOrEditComment()\"\n          (keydown.enter)=\"addOrEditComment()\">\n    <span>Comment</span></button>\n  <button *ngIf=\"canBookmark\"\n          type=\"button\" title=\"Bookmark\"\n          class=\"aui__toolbar-button aui__toolbar-button--comments contextual-btn rightButton aui__toolbar-button-bookmark\"\n          id=\"bookmarkButton\"\n          (mousedown)=\"createBookmark()\"\n          (keydown.enter)=\"createBookmark()\">\n    <span>Bookmark</span></button>\n  <div class=\"arrow-down\">\n    <div class=\"inner-triangle\"></div>\n  </div>\n</div>\n"]}