@ngutil/aria 0.0.69 → 0.0.71

package/fesm2022/ngutil-aria.mjs

@@ -1,12 +1,12 @@
 import { DOCUMENT } from '@angular/common';
 import * as i0 from '@angular/core';
 import { inject, NgZone, Injectable, Inject, ElementRef, effect, Directive, input, computed, signal, untracked, NgModule } from '@angular/core';
-import { merge, fromEvent, map, share, filter, shareReplay, startWith, throttleTime, switchMap, timer, take, distinctUntilChanged, combineLatest, BehaviorSubject, of, debounceTime, Observable, EMPTY, from, tap, concatMap, scan, takeWhile, finalize, Subject, animationFrames } from 'rxjs';
+import { merge, fromEvent, map, share, filter, shareReplay, startWith, throttleTime, switchMap, timer, take, distinctUntilChanged, combineLatest, BehaviorSubject, of, debounceTime, Observable, EMPTY, from, tap, Subject, connect, scan, takeWhile, finalize, animationFrames } from 'rxjs';
 import { FocusTrapFactory } from '@angular/cdk/a11y';
 import { takeUntilDestroyed, toSignal } from '@angular/core/rxjs-interop';
 import { focusable, isFocusable } from 'tabbable';
-import { coerceElement, Destructible, isElementInput, deepClone, coerceBoolAttr } from '@ngutil/common';
-import { flatten, clamp } from 'lodash';
+import { coerceElement, Destructible, isElementInput, __zone_symbol__, isFalsy, isTruthy, deepClone, coerceBoolAttr } from '@ngutil/common';
+import { clamp } from 'lodash-es';
 
 const EVENT_OPTIONS$1 = {
     capture: true,
@@ -356,167 +356,463 @@ function eventToKeystroke(event) {
     };
 }
 
-function stateToEvent(state, type) {
-    return {
-        type: type,
-        origin: state.origin,
-        target: state.target,
-        pointerType: state.pointerType,
-        phase: state.phase,
-        pointers: state.pointers
-    };
-}
 const Listeners = {
     mousedown: {
-        target: "element" /* ListenerTarget.Element */,
         pointerType: "mouse" /* GesturePointerType.Mouse */,
         phase: "start" /* GesturePhase.Start */,
         options: { capture: true, passive: false }
     },
     mousemove: {
-        target: "document" /* ListenerTarget.Document */,
         pointerType: "mouse" /* GesturePointerType.Mouse */,
         phase: "moving" /* GesturePhase.Moving */,
         options: { capture: true, passive: false }
     },
     mouseup: {
-        target: "document" /* ListenerTarget.Document */,
         pointerType: "mouse" /* GesturePointerType.Mouse */,
         phase: "end" /* GesturePhase.End */,
-        options: { capture: true, passive: true }
+        options: { capture: true, passive: false }
     },
     touchstart: {
-        target: "element" /* ListenerTarget.Element */,
         pointerType: "touch" /* GesturePointerType.Touch */,
         phase: "start" /* GesturePhase.Start */,
         options: { capture: true, passive: false }
     },
     touchmove: {
-        target: "document" /* ListenerTarget.Document */,
         pointerType: "touch" /* GesturePointerType.Touch */,
         phase: "moving" /* GesturePhase.Moving */,
         options: { capture: true, passive: false }
     },
     touchend: {
-        target: "document" /* ListenerTarget.Document */,
         pointerType: "touch" /* GesturePointerType.Touch */,
         phase: "end" /* GesturePhase.End */,
         options: { capture: true, passive: false }
     },
     touchcancel: {
-        target: "document" /* ListenerTarget.Document */,
         pointerType: "touch" /* GesturePointerType.Touch */,
         phase: "end" /* GesturePhase.End */,
-        options: { capture: true, passive: true }
+        options: { capture: true, passive: false }
     }
+    // ,
+    // contextmenu: {
+    //     pointerType: GesturePointerType.Mouse,
+    //     phase: GesturePhase.Start,
+    //     options: { capture: true, passive: false }
+    // }
 };
 
-const TypeMap = {
-    ["start" /* GesturePhase.Start */]: "dragging-start",
-    ["moving" /* GesturePhase.Moving */]: "dragging-move",
-    ["end" /* GesturePhase.End */]: "dragging-end"
-};
-const Dragging = {
-    name: "dragging",
-    listeners: ["mousedown", "mousemove", "mouseup", "touchstart", "touchmove", "touchend", "touchcancel"],
-    priority: 0,
-    handler: events => events.pipe(filter(state => !state.pending || state.pending.length === 0), tap(state => state.preventDefault()), map(state => stateToEvent(state, TypeMap[state.phase])))
-};
+class Gesture {
+    constructor(name, listeners, options = {}) {
+        this.name = name;
+        // TODO maybe global option
+        this.distanceInclusion = 10;
+        // TODO maybe global option
+        this.timeWithin = 300;
+        this.priority = 0;
+        this.includeScrollDistance = false;
+        this.filterPointerTypes = ["mouse" /* GesturePointerType.Mouse */, "touch" /* GesturePointerType.Touch */];
+        this.filterMouseButtons = [0];
+        this.filterByEvent = (event) => this.filterPointerTypes.includes(event.pointerType) &&
+            // this.filterListeners.includes(event.origin.type as any) &&
+            (event.pointerType !== "mouse" /* GesturePointerType.Mouse */ ||
+                (event.origin instanceof MouseEvent && this.filterMouseButtons.includes(event.origin.button)));
+        Object.assign(this, options);
+        this.filterListeners = listeners.filter(v => this.filterPointerTypes.includes(Listeners[v].pointerType));
+    }
+    /**
+     * Transform input event, to gesture event
+     * ! important, dont rely on this object state, because not always create a new object
+     */
+    handle(events) {
+        return events.pipe(tap(event => (event.type = this.name)));
+    }
+}
 
-class GesturesService {
-    #document = inject(DOCUMENT);
-    #zone = inject(NgZone);
-    #listeners = new Map();
-    watch(el, ...gestures) {
-        return this.#zone.runOutsideAngular(() => {
-            const listeners = flatten(gestures.map(v => v.listeners || []));
-            const { trigger, watch } = this.#getListeners(coerceElement(el), listeners);
-            let pointerType;
-            return trigger.pipe(filter(state => {
-                if (pointerType == null) {
-                    pointerType = state.pointerType;
-                }
-                return pointerType === state.pointerType;
-            }), concatMap(v => this.#zone.runOutsideAngular(() => {
-                const watching = watch[pointerType].pipe(startWith(v), scan((state, curr) => updatePointers({ ...state, ...curr }), {}), takeWhile(state => state.phase !== "end" /* GesturePhase.End */, true), share());
-                return merge(...gestures.map(v => v.handler(watching)));
-            })));
+const DRAG_LISTENERS = [
+    "mousedown",
+    "mousemove",
+    "mouseup",
+    "touchstart",
+    "touchmove",
+    "touchend",
+    "touchcancel"
+];
+class GestureDragImpl extends Gesture {
+    constructor(options) {
+        super("gesture-drag", DRAG_LISTENERS, { includeScrollDistance: true, ...options });
+        if (this.horizontal == null && this.vertical == null) {
+            this.horizontal = true;
+            this.vertical = true;
+        }
+    }
+    capture(events) {
+        return events.pipe(map(state => {
+            if (state.pointers.length !== 1) {
+                return 2 /* GestureCaptureState.Skip */;
+            }
+            if (Math.abs(state.pointers[0].distance.x) > this.distanceInclusion) {
+                return this.horizontal ? 3 /* GestureCaptureState.Maybe */ : 2 /* GestureCaptureState.Skip */;
+            }
+            if (Math.abs(state.pointers[0].distance.y) > this.distanceInclusion) {
+                return this.vertical ? 3 /* GestureCaptureState.Maybe */ : 2 /* GestureCaptureState.Skip */;
+            }
+            return 1 /* GestureCaptureState.Pending */;
+        }));
+    }
+    handle(events) {
+        const updater = this.horizontal && this.vertical
+            ? updateAnyDirection
+            : this.horizontal
+                ? updateHorizontalOnly
+                : updateVerticalOnly;
+        return super.handle(events).pipe(tap(updater));
+    }
+}
+function updateVerticalOnly(event) {
+    const pointer = event.pointers[0];
+    pointer.distance.x = 0;
+    pointer.direction.x = 0;
+    pointer.current.x = pointer.start.x;
+    updateEvent(event, updateByScrollDistanceVertical);
+}
+function updateHorizontalOnly(event) {
+    console.log("updateHorizontalOnly");
+    const pointer = event.pointers[0];
+    pointer.distance.y = 0;
+    pointer.direction.y = 0;
+    pointer.current.y = pointer.start.y;
+    updateEvent(event, updateByScrollDistanceHorizontal);
+}
+function updateAnyDirection(event) {
+    updateEvent(event, updateByScrollDistanceBoth);
+}
+function updateEvent(event, scrollUpdate) {
+    event.moveBy = { ...event.pointers[0].distance };
+    scrollUpdate(event);
+}
+function updateByScrollDistanceVertical(event) {
+    const sd = event.scrollDistance;
+    if (sd == null) {
+        return;
+    }
+    event.moveBy.y += sd.y;
+}
+function updateByScrollDistanceHorizontal(event) {
+    const sd = event.scrollDistance;
+    if (sd == null) {
+        return;
+    }
+    event.moveBy.x += sd.x;
+}
+function updateByScrollDistanceBoth(event) {
+    const sd = event.scrollDistance;
+    if (sd == null) {
+        return;
+    }
+    event.moveBy.x += sd.x;
+    event.moveBy.y += sd.y;
+}
+function gestureDrag(options) {
+    return new GestureDragImpl(options);
+}
+const GestureDarg = gestureDrag();
+const GestureDargHorizontal = gestureDrag({ horizontal: true, vertical: false });
+const GestureDargVertical = gestureDrag({ horizontal: false, vertical: true });
+
+class GestureLongTapImpl extends Gesture {
+    constructor(options) {
+        super("gesture-longtap", ["touchstart", "touchmove", "touchend", "touchcancel"], {
+            filterPointerTypes: ["touch" /* GesturePointerType.Touch */],
+            ...options
         });
     }
-    #getListeners(inputEl, listeners) {
-        const triggers = [];
-        const watches = {};
-        for (const name of listeners) {
-            const conf = Listeners[name];
-            const container = conf.phase === "start" /* GesturePhase.Start */
-                ? triggers
-                : (watches[conf.pointerType] = watches[conf.pointerType] || []);
-            if (container.indexOf(name) === -1) {
-                container.push(name);
+    capture(events) {
+        return combineLatest({ timeWithin: timer(this.timeWithin).pipe(startWith(null)), event: events }).pipe(map(({ timeWithin, event }) => {
+            if (event.pointers.length !== 1 || event.elapsed > this.timeWithin) {
+                return 2 /* GestureCaptureState.Skip */;
             }
-        }
-        if (triggers.length === 0) {
-            throw Error("Missing start events");
-        }
-        const observable = (names) => {
-            if (names.length === 0) {
-                return of();
+            if (event.phase === "end" /* GesturePhase.End */ && event.elapsed > this.timeWithin) {
+                return 2 /* GestureCaptureState.Skip */;
             }
-            else if (names.length === 1) {
-                return this.#getListener(inputEl, names[0]);
+            const distance = event.pointers[0].distance;
+            if (Math.abs(distance.x) < this.distanceInclusion && Math.abs(distance.y) < this.distanceInclusion) {
+                // maybe is ok event.phase === GesturePhase.End
+                return timeWithin !== null ? 4 /* GestureCaptureState.Instant */ : 1 /* GestureCaptureState.Pending */;
             }
             else {
-                return merge(...names.map(v => this.#getListener(inputEl, v)));
+                return 2 /* GestureCaptureState.Skip */;
             }
-        };
-        return {
-            trigger: observable(triggers),
-            watch: {
-                ["mouse" /* GesturePointerType.Mouse */]: observable(watches["mouse" /* GesturePointerType.Mouse */]),
-                ["touch" /* GesturePointerType.Touch */]: observable(watches["touch" /* GesturePointerType.Touch */])
+        }));
+    }
+    handle(events) {
+        return super.handle(events.pipe(filter(event => event.phase === "start" /* GesturePhase.Start */ || event.phase === "end" /* GesturePhase.End */)));
+    }
+}
+function gestureLongTap(options) {
+    return new GestureLongTapImpl(options);
+}
+const GestureLongTap = gestureLongTap();
+
+class GestureTapImpl extends Gesture {
+    constructor(options) {
+        super("gesture-tap", ["touchstart", "touchmove", "touchend", "touchcancel", "mousedown", "mousemove", "mouseup"], {
+            filterPointerTypes: ["mouse" /* GesturePointerType.Mouse */, "touch" /* GesturePointerType.Touch */],
+            ...options
+        });
+    }
+    // TODO
+    capture(events) {
+        return events.pipe(map(event => {
+            if (event.pointers.length !== 1) {
+                return 2 /* GestureCaptureState.Skip */;
             }
-        };
+            const distance = event.pointers[0].distance;
+            if (Math.abs(distance.x) < this.distanceInclusion && Math.abs(distance.y) < this.distanceInclusion) {
+                return event.phase === "end" /* GesturePhase.End */ ? 4 /* GestureCaptureState.Instant */ : 1 /* GestureCaptureState.Pending */;
+            }
+            else {
+                return 2 /* GestureCaptureState.Skip */;
+            }
+        }));
+    }
+    handle(events) {
+        return super.handle(events.pipe(filter(event => event.phase === "start" /* GesturePhase.Start */ || event.phase === "end" /* GesturePhase.End */)));
     }
-    #getListener(inputEl, name) {
-        return this.#zone.runOutsideAngular(() => {
-            const target = Listeners[name].target;
-            const targetObj = target === "document" ? this.#document : inputEl;
-            let targetListeners = this.#listeners.get(targetObj);
-            if (targetListeners == null) {
-                targetListeners = new Map();
-                this.#listeners.set(targetObj, targetListeners);
+}
+function gestureTap(options) {
+    return new GestureTapImpl(options);
+}
+const GestureTap = gestureTap();
+
+const ADD_EVENT_LISTENER = __zone_symbol__("addEventListener");
+const REMOVE_EVENT_LISTENER = __zone_symbol__("removeEventListener");
+const DISPATCH_EVENT = __zone_symbol__("dispatchEvent");
+const SCROLL_LISTENER_OPTIONS = { passive: true };
+class GestureService {
+    #zone = inject(NgZone);
+    #document = inject(DOCUMENT);
+    #watchers = [];
+    #trigger = new Subject();
+    #moving = merge(...Object.keys(Listeners)
+        .filter(name => Listeners[name].phase === "moving" /* GesturePhase.Moving */)
+        .map(name => this.#listen(name, Listeners[name]))).pipe(share());
+    #end = merge(...Object.keys(Listeners)
+        .filter(name => Listeners[name].phase === "end" /* GesturePhase.End */)
+        .map(name => this.#listen(name, Listeners[name]))).pipe(share());
+    #eventStream = merge(this.#moving, this.#end).pipe(share());
+    #begin = new Observable((dst) => {
+        let pointerType;
+        return this.#trigger
+            .pipe(filter(event => {
+            if (pointerType == null) {
+                pointerType = event.pointerType;
             }
-            let listener = targetListeners.get(name);
-            if (listener == null) {
-                const { phase, pointerType, options } = Listeners[name];
-                const passive = options?.passive;
-                listener = fromEvent(targetObj, name, options).pipe(finalize(() => {
-                    targetListeners.delete(name);
-                }), map(origin => ({
-                    origin,
-                    phase,
-                    pointerType,
-                    preventDefault: passive === false ? origin.preventDefault.bind(origin) : noop
-                })));
-                if (phase === "start" /* GesturePhase.Start */) {
-                    listener = listener.pipe(tap(state => {
-                        ;
-                        state.target = state.origin.target;
-                    }));
+            return event.pointerType === pointerType;
+        }), connect(events => merge(events, 
+        // reset pointerType on end, after 200ms, because touchend is maybe followed by a mouse event
+        this.#end.pipe(debounceTime(200), tap(() => {
+            pointerType = undefined;
+            this.#enableTouchAction();
+        }), filter(() => false)))), 
+        // Select active watchers
+        map(event => {
+            const eventTarget = event.target;
+            let includeScrollDistance = false;
+            const gestures = this.#watchers
+                .filter(({ gesture, el }) => gesture.filterByEvent(event) &&
+                (el === eventTarget || ("contains" in el && el.contains(eventTarget))))
+                .reduce((gestures, { gesture }) => {
+                if (!gestures.has(gesture)) {
+                    includeScrollDistance = includeScrollDistance || gesture.includeScrollDistance;
+                    gestures.set(gesture, 0 /* GestureCaptureState.Unchecked */);
                 }
-                listener = listener.pipe(share());
-                targetListeners.set(name, listener);
+                return gestures;
+            }, new Map());
+            return { startEvent: event, gestures, includeScrollDistance };
+        }), filter(({ gestures }) => gestures.size > 0), tap(this.#disableTouchAction)
+        // finalize(() => console.log("FINALIZE BEGIN"))
+        )
+            .subscribe(dst);
+    });
+    #gesture = this.#begin.pipe(switchMap(({ startEvent, gestures, includeScrollDistance }) => {
+        const pointerType = startEvent.pointerType;
+        const startAt = startEvent.origin.timeStamp;
+        const dispatchEvent = startEvent.target[DISPATCH_EVENT].bind(startEvent.target);
+        const eventStreamInit = this.#eventStream.pipe(startWith(startEvent), filter(event => event.pointerType === pointerType));
+        const eventStreamSource = !includeScrollDistance
+            ? eventStreamInit
+            : combineLatest([
+                eventStreamInit,
+                this.#scrollDistance(startEvent.target).pipe(startWith({ x: 0, y: 0 }))
+            ]).pipe(map(([src, distance]) => {
+                ;
+                src.scrollDistance = distance;
+                return src;
+            }));
+        const eventStream = eventStreamSource.pipe(scan((state, curr) => updatePointers({
+            ...state,
+            ...curr,
+            elapsed: curr.origin.timeStamp - startAt
+        }), startEvent), takeWhile(event => event.phase !== "end" /* GesturePhase.End */, true), 
+        // finalize(() => console.log("FINALIZE WATCH")),
+        share());
+        const captureState = eventStream.pipe(connect(src => {
+            const state = { events: [], gestures, includeScrollDistance };
+            return merge(src.pipe(tap(event => state.events.push(event))), ...Array.from(gestures.keys()).map(gesture => gesture.capture(src.pipe(filter(gesture.filterByEvent))).pipe(takeWhile(result => result !== 2 /* GestureCaptureState.Skip */, true), tap(result => gestures.set(gesture, result))))).pipe(map(() => state));
+        })
+        // ,finalize(() => console.log("FINALIZE CAPTURE"))
+        );
+        const selectGesture = captureState.pipe(map(state => {
+            const partitions = {};
+            for (const [gesture, captureState] of state.gestures) {
+                const partition = (partitions[captureState] ??= []);
+                partition.push(gesture);
             }
-            return listener;
-        });
+            if (partitions[4 /* GestureCaptureState.Instant */] != null) {
+                return {
+                    gesture: partitions[4 /* GestureCaptureState.Instant */].sort(sortByPripority)[0],
+                    events: state.events
+                };
+            }
+            // while not all gestures return from Gesture.capture
+            if (partitions[0 /* GestureCaptureState.Unchecked */] != null) {
+                return null;
+            }
+            // while has pending, the capture is continued
+            if (partitions[1 /* GestureCaptureState.Pending */] != null) {
+                return null;
+            }
+            // no pendig & has maybe
+            if (partitions[3 /* GestureCaptureState.Maybe */] != null) {
+                return {
+                    gesture: partitions[3 /* GestureCaptureState.Maybe */].sort(sortByPripority)[0],
+                    events: state.events
+                };
+            }
+            // no pending & no maybe & no terminate
+            // so, nothign matched
+            return { events: state.events };
+        }), takeWhile(isFalsy, true), filter(isTruthy), takeWhile(v => v.gesture != null, false)
+        // finalize(() => console.log("FINALIZE SELECT"))
+        );
+        return selectGesture.pipe(switchMap(({ events, gesture }) => gesture.handle(eventStream.pipe(startWith(...events), filter(gesture.filterByEvent))).pipe(takeWhile(v => v.phase !== "end" /* GesturePhase.End */, true), tap((e) => dispatchEvent(new CustomEvent(e.type, { detail: e, bubbles: true, cancelable: true })))
+        // finalize(() => console.log("GESTURE FINALIZE")),
+        )), 
+        // finalize(() => console.log("FINALIZE RESULT")),
+        finalize(this.#enableTouchAction));
+    }), share());
+    constructor() {
+        const triggers = merge(...Object.keys(Listeners)
+            .filter(name => Listeners[name].phase === "start" /* GesturePhase.Start */)
+            .map(name => this.#listen(name, Listeners[name])));
+        triggers.pipe(takeUntilDestroyed()).subscribe(this.#trigger);
+    }
+    listen(el, ...gestures) {
+        return new Observable((dst) => this.#zone.runOutsideAngular(() => {
+            const element = coerceElement(el);
+            const next = dst.next.bind(dst);
+            for (const gesture of gestures) {
+                element[ADD_EVENT_LISTENER](gesture.name, next);
+                dst.add(element[REMOVE_EVENT_LISTENER].bind(element, gesture.name, next));
+            }
+            dst.add(this.watch(element, ...gestures).subscribe());
+        }));
     }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.6", ngImport: i0, type: GesturesService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
-    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.6", ngImport: i0, type: GesturesService, providedIn: "root" }); }
+    watch(el, ...gestures) {
+        return new Observable((dst) => this.#zone.runOutsideAngular(() => {
+            const element = coerceElement(el);
+            const watchers = gestures.map(gesture => {
+                return { gesture, el: element };
+            });
+            this.#add(watchers);
+            dst.add(this.#gesture.subscribe(dst));
+            return () => {
+                this.#remove(watchers);
+            };
+        }));
+    }
+    #add(watchers) {
+        this.#watchers = this.#watchers.concat(watchers);
+    }
+    #remove(watchers) {
+        this.#watchers = this.#watchers.filter(v => !watchers.includes(v));
+    }
+    #listen(name, config) {
+        const { phase, pointerType, options } = config;
+        const toResult = phase === "start" /* GesturePhase.Start */
+            ? (origin) => ({
+                origin,
+                phase,
+                pointerType,
+                target: origin.target
+            })
+            : (origin) => {
+                if (origin.cancelable) {
+                    origin.preventDefault();
+                }
+                return { origin, phase, pointerType };
+            };
+        return new Observable((dst) => this.#zone.runOutsideAngular(() => {
+            const listener = (origin) => {
+                if (origin.defaultPrevented) {
+                    return;
+                }
+                dst.next(toResult(origin));
+            };
+            // console.log("addEventListener", name)
+            this.#document[ADD_EVENT_LISTENER](name, listener, options);
+            return () => {
+                // console.log("removeEventListener", name)
+                this.#document[REMOVE_EVENT_LISTENER](name, listener, options);
+            };
+        }));
+    }
+    #scrollDistance(element) {
+        const scrollPosition = () => {
+            let x = 0;
+            let y = 0;
+            let p = element;
+            do {
+                x += p.scrollLeft ?? 0;
+                y += p.scrollTop ?? 0;
+                p = p.parentNode;
+            } while (p != null);
+            return { x, y };
+        };
+        return new Observable((dst) => this.#zone.runOutsideAngular(() => {
+            const initial = scrollPosition();
+            const listener = () => {
+                const current = scrollPosition();
+                dst.next({ x: current.x - initial.x, y: current.y - initial.y });
+            };
+            this.#document[ADD_EVENT_LISTENER]("scroll", listener, SCROLL_LISTENER_OPTIONS);
+            return () => {
+                this.#document[REMOVE_EVENT_LISTENER]("scroll", listener, SCROLL_LISTENER_OPTIONS);
+            };
+        }));
+    }
+    #lastTouchAction;
+    #disableTouchAction = () => {
+        if (this.#lastTouchAction == null) {
+            this.#lastTouchAction = window.getComputedStyle(this.#document.body).touchAction;
+            this.#document.body.style.touchAction = "none";
+        }
+    };
+    #enableTouchAction = () => {
+        if (this.#lastTouchAction != null) {
+            this.#document.body.style.touchAction = this.#lastTouchAction;
+            this.#lastTouchAction = undefined;
+        }
+    };
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.6", ngImport: i0, type: GestureService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.6", ngImport: i0, type: GestureService, providedIn: "root" }); }
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.6", ngImport: i0, type: GesturesService, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.6", ngImport: i0, type: GestureService, decorators: [{
             type: Injectable,
             args: [{ providedIn: "root" }]
-        }] });
+        }], ctorParameters: () => [] });
+function sortByPripority(a, b) {
+    return b.priority - a.priority;
+}
 function pointersFromEvent(event) {
     if (event instanceof MouseEvent) {
         return [
@@ -558,9 +854,6 @@ function updatePointers(state) {
 function direction(prev, curr) {
     return curr > prev ? 1 : curr < prev ? -1 : 0;
 }
-// const svc = new GesturesService()
-// const w = svc.watch(document.createElement("div"), DragAndDrop)
-function noop() { }
 
 const COMPILE_CACHE = {};
 function compile(selector) {
@@ -1217,5 +1510,5 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.6", ngImpor
  * Generated bundle index. Do not edit.
  */
 
-export { AbstractUiState, ActivityService, BusyDirective, DisabledDirective, Dragging, FocusService, FocusState, FocusTrap, Focusable, GesturesService, KeystrokeService, Listeners, NOTSET, ProgressSegmentRef, ProgressState, ReadonlyDirective, UiState, UiStateModule, stateToEvent };
+export { AbstractUiState, ActivityService, BusyDirective, DisabledDirective, FocusService, FocusState, FocusTrap, Focusable, Gesture, GestureDarg, GestureDargHorizontal, GestureDargVertical, GestureDragImpl, GestureLongTap, GestureLongTapImpl, GestureService, GestureTap, GestureTapImpl, KeystrokeService, Listeners, NOTSET, ProgressSegmentRef, ProgressState, ReadonlyDirective, UiState, UiStateModule, gestureDrag, gestureLongTap, gestureTap };
 //# sourceMappingURL=ngutil-aria.mjs.map