tango-app-ui-analyse-trax 4.0.21 → 4.0.22

package/esm2022/lib/components/flags-info/drag-scroll.directive.mjs

@@ -0,0 +1,123 @@
+import { Directive, EventEmitter, Output } from '@angular/core';
+import * as i0 from "@angular/core";
+// Sideways scrolling by mouse for a strip whose scrollbar is hidden: a plain wheel turn scrolls it
+// sideways (trackpads already do), and it can be dragged with the left button. At either end the
+// wheel is handed back to the page. Listeners run outside Angular, so scrolling doesn't run change
+// detection per frame; scrollStart fires once per burst of scrolling, inside Angular.
+export class DragScrollDirective {
+    host;
+    zone;
+    scrollStart = new EventEmitter();
+    dragStartX = 0;
+    dragStartLeft = 0;
+    dragging = false;
+    scrolling = false;
+    scrollIdle = null;
+    constructor(host, zone) {
+        this.host = host;
+        this.zone = zone;
+    }
+    ngOnInit() {
+        const el = this.host.nativeElement;
+        this.zone.runOutsideAngular(() => {
+            el.addEventListener('wheel', this.onWheel, { passive: false });
+            el.addEventListener('pointerdown', this.onPointerDown);
+            el.addEventListener('pointerenter', this.onPointerEnter);
+            el.addEventListener('scroll', this.onScroll, { passive: true });
+        });
+    }
+    ngOnDestroy() {
+        const el = this.host.nativeElement;
+        el.removeEventListener('wheel', this.onWheel);
+        el.removeEventListener('pointerdown', this.onPointerDown);
+        el.removeEventListener('pointerenter', this.onPointerEnter);
+        el.removeEventListener('scroll', this.onScroll);
+        this.endDrag();
+        clearTimeout(this.scrollIdle);
+    }
+    get maxScroll() {
+        const el = this.host.nativeElement;
+        return el.scrollWidth - el.clientWidth;
+    }
+    // Grab cursor only while there is something to scroll to.
+    onPointerEnter = () => {
+        this.host.nativeElement.classList.toggle('drag-scroll-ready', this.maxScroll > 0);
+    };
+    onWheel = (event) => {
+        const el = this.host.nativeElement;
+        const max = this.maxScroll;
+        if (max <= 0 || event.ctrlKey || Math.abs(event.deltaX) >= Math.abs(event.deltaY)) {
+            return;
+        }
+        const unit = event.deltaMode === 1 ? 16 : event.deltaMode === 2 ? el.clientWidth : 1;
+        const delta = event.deltaY * unit;
+        if ((delta < 0 && el.scrollLeft <= 0) || (delta > 0 && el.scrollLeft >= max - 1)) {
+            return;
+        }
+        event.preventDefault();
+        el.scrollLeft += delta;
+    };
+    onPointerDown = (event) => {
+        if (event.pointerType !== 'mouse' || event.button !== 0 || this.maxScroll <= 0) {
+            return;
+        }
+        const el = this.host.nativeElement;
+        this.dragStartX = event.clientX;
+        this.dragStartLeft = el.scrollLeft;
+        this.dragging = false;
+        el.addEventListener('pointermove', this.onPointerMove);
+        el.addEventListener('pointerup', this.onPointerUp);
+        el.addEventListener('pointercancel', this.onPointerUp);
+    };
+    // A few pixels of slack so a plain click never nudges the strip.
+    onPointerMove = (event) => {
+        const el = this.host.nativeElement;
+        const dx = event.clientX - this.dragStartX;
+        if (!this.dragging) {
+            if (Math.abs(dx) < 4) {
+                return;
+            }
+            this.dragging = true;
+            el.setPointerCapture(event.pointerId);
+            el.classList.add('drag-scroll-active');
+        }
+        el.scrollLeft = this.dragStartLeft - dx;
+    };
+    onPointerUp = (event) => {
+        const el = this.host.nativeElement;
+        if (el.hasPointerCapture(event.pointerId)) {
+            el.releasePointerCapture(event.pointerId);
+        }
+        this.endDrag();
+    };
+    endDrag() {
+        const el = this.host.nativeElement;
+        el.removeEventListener('pointermove', this.onPointerMove);
+        el.removeEventListener('pointerup', this.onPointerUp);
+        el.removeEventListener('pointercancel', this.onPointerUp);
+        el.classList.remove('drag-scroll-active');
+        this.dragging = false;
+    }
+    onScroll = () => {
+        if (!this.scrolling) {
+            this.scrolling = true;
+            if (this.scrollStart.observed) {
+                this.zone.run(() => this.scrollStart.emit());
+            }
+        }
+        clearTimeout(this.scrollIdle);
+        this.scrollIdle = setTimeout(() => (this.scrolling = false), 150);
+    };
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: DragScrollDirective, deps: [{ token: i0.ElementRef }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Directive });
+    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "17.3.12", type: DragScrollDirective, isStandalone: true, selector: "[libDragScroll]", outputs: { scrollStart: "scrollStart" }, ngImport: i0 });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: DragScrollDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[libDragScroll]',
+                    standalone: true,
+                }]
+        }], ctorParameters: () => [{ type: i0.ElementRef }, { type: i0.NgZone }], propDecorators: { scrollStart: [{
+                type: Output
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"drag-scroll.directive.js","sourceRoot":"","sources":["../../../../../../projects/tango-analyse-trax/src/lib/components/flags-info/drag-scroll.directive.ts"],"names":[],"mappings":"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","sourcesContent":["import { Directive, ElementRef, EventEmitter, NgZone, OnDestroy, OnInit, Output } from '@angular/core';\r\n\r\n// Sideways scrolling by mouse for a strip whose scrollbar is hidden: a plain wheel turn scrolls it\r\n// sideways (trackpads already do), and it can be dragged with the left button. At either end the\r\n// wheel is handed back to the page. Listeners run outside Angular, so scrolling doesn't run change\r\n// detection per frame; scrollStart fires once per burst of scrolling, inside Angular.\r\n@Directive({\r\n  selector: '[libDragScroll]',\r\n  standalone: true,\r\n})\r\nexport class DragScrollDirective implements OnInit, OnDestroy {\r\n  @Output() scrollStart = new EventEmitter<void>()\r\n\r\n  private dragStartX = 0\r\n  private dragStartLeft = 0\r\n  private dragging = false\r\n  private scrolling = false\r\n  private scrollIdle: any = null\r\n\r\n  constructor(private host: ElementRef<HTMLElement>, private zone: NgZone) {}\r\n\r\n  ngOnInit(): void {\r\n    const el = this.host.nativeElement\r\n    this.zone.runOutsideAngular(() => {\r\n      el.addEventListener('wheel', this.onWheel, { passive: false })\r\n      el.addEventListener('pointerdown', this.onPointerDown)\r\n      el.addEventListener('pointerenter', this.onPointerEnter)\r\n      el.addEventListener('scroll', this.onScroll, { passive: true })\r\n    })\r\n  }\r\n\r\n  ngOnDestroy(): void {\r\n    const el = this.host.nativeElement\r\n    el.removeEventListener('wheel', this.onWheel)\r\n    el.removeEventListener('pointerdown', this.onPointerDown)\r\n    el.removeEventListener('pointerenter', this.onPointerEnter)\r\n    el.removeEventListener('scroll', this.onScroll)\r\n    this.endDrag()\r\n    clearTimeout(this.scrollIdle)\r\n  }\r\n\r\n  private get maxScroll(): number {\r\n    const el = this.host.nativeElement\r\n    return el.scrollWidth - el.clientWidth\r\n  }\r\n\r\n  // Grab cursor only while there is something to scroll to.\r\n  private onPointerEnter = (): void => {\r\n    this.host.nativeElement.classList.toggle('drag-scroll-ready', this.maxScroll > 0)\r\n  }\r\n\r\n  private onWheel = (event: WheelEvent): void => {\r\n    const el = this.host.nativeElement\r\n    const max = this.maxScroll\r\n    if (max <= 0 || event.ctrlKey || Math.abs(event.deltaX) >= Math.abs(event.deltaY)) {\r\n      return\r\n    }\r\n    const unit = event.deltaMode === 1 ? 16 : event.deltaMode === 2 ? el.clientWidth : 1\r\n    const delta = event.deltaY * unit\r\n    if ((delta < 0 && el.scrollLeft <= 0) || (delta > 0 && el.scrollLeft >= max - 1)) {\r\n      return\r\n    }\r\n    event.preventDefault()\r\n    el.scrollLeft += delta\r\n  }\r\n\r\n  private onPointerDown = (event: PointerEvent): void => {\r\n    if (event.pointerType !== 'mouse' || event.button !== 0 || this.maxScroll <= 0) {\r\n      return\r\n    }\r\n    const el = this.host.nativeElement\r\n    this.dragStartX = event.clientX\r\n    this.dragStartLeft = el.scrollLeft\r\n    this.dragging = false\r\n    el.addEventListener('pointermove', this.onPointerMove)\r\n    el.addEventListener('pointerup', this.onPointerUp)\r\n    el.addEventListener('pointercancel', this.onPointerUp)\r\n  }\r\n\r\n  // A few pixels of slack so a plain click never nudges the strip.\r\n  private onPointerMove = (event: PointerEvent): void => {\r\n    const el = this.host.nativeElement\r\n    const dx = event.clientX - this.dragStartX\r\n    if (!this.dragging) {\r\n      if (Math.abs(dx) < 4) {\r\n        return\r\n      }\r\n      this.dragging = true\r\n      el.setPointerCapture(event.pointerId)\r\n      el.classList.add('drag-scroll-active')\r\n    }\r\n    el.scrollLeft = this.dragStartLeft - dx\r\n  }\r\n\r\n  private onPointerUp = (event: PointerEvent): void => {\r\n    const el = this.host.nativeElement\r\n    if (el.hasPointerCapture(event.pointerId)) {\r\n      el.releasePointerCapture(event.pointerId)\r\n    }\r\n    this.endDrag()\r\n  }\r\n\r\n  private endDrag(): void {\r\n    const el = this.host.nativeElement\r\n    el.removeEventListener('pointermove', this.onPointerMove)\r\n    el.removeEventListener('pointerup', this.onPointerUp)\r\n    el.removeEventListener('pointercancel', this.onPointerUp)\r\n    el.classList.remove('drag-scroll-active')\r\n    this.dragging = false\r\n  }\r\n\r\n  private onScroll = (): void => {\r\n    if (!this.scrolling) {\r\n      this.scrolling = true\r\n      if (this.scrollStart.observed) {\r\n        this.zone.run(() => this.scrollStart.emit())\r\n      }\r\n    }\r\n    clearTimeout(this.scrollIdle)\r\n    this.scrollIdle = setTimeout(() => (this.scrolling = false), 150)\r\n  }\r\n}\r\n"]}