@ngutil/aria 0.0.70 → 0.0.71

package/esm2022/gestures/gesture-drag.mjs

@@ -0,0 +1,93 @@
+import { map, tap } from "rxjs";
+import { Gesture } from "./gesture";
+const DRAG_LISTENERS = [
+    "mousedown",
+    "mousemove",
+    "mouseup",
+    "touchstart",
+    "touchmove",
+    "touchend",
+    "touchcancel"
+];
+export 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;
+}
+export function gestureDrag(options) {
+    return new GestureDragImpl(options);
+}
+export const GestureDarg = gestureDrag();
+export const GestureDargHorizontal = gestureDrag({ horizontal: true, vertical: false });
+export const GestureDargVertical = gestureDrag({ horizontal: false, vertical: true });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"gesture-drag.js","sourceRoot":"","sources":["../../../../../packages/aria/src/gestures/gesture-drag.ts"],"names":[],"mappings":"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","sourcesContent":["import { map, Observable, tap } from \"rxjs\"\n\nimport { Mutable } from \"utility-types\"\n\nimport { Position } from \"@ngutil/style\"\n\nimport { Gesture, GestureCaptureState, GestureOptions } from \"./gesture\"\nimport { GestureEvent } from \"./gesture-event\"\n\nexport interface GestureDragEvent extends GestureEvent<\"gesture-drag\"> {\n    moveBy: Position\n}\n\nexport type GestureDragOptions = GestureOptions<GestureDragImpl>\n\nconst DRAG_LISTENERS: Gesture<any>[\"filterListeners\"] = [\n    \"mousedown\",\n    \"mousemove\",\n    \"mouseup\",\n    \"touchstart\",\n    \"touchmove\",\n    \"touchend\",\n    \"touchcancel\"\n]\n\nexport class GestureDragImpl extends Gesture<GestureDragEvent> {\n    readonly horizontal?: boolean\n    readonly vertical?: boolean\n\n    constructor(options?: GestureDragOptions) {\n        super(\"gesture-drag\", DRAG_LISTENERS, { includeScrollDistance: true, ...options })\n\n        if (this.horizontal == null && this.vertical == null) {\n            this.horizontal = true\n            this.vertical = true\n        }\n    }\n\n    override capture(events: Observable<GestureEvent>): Observable<GestureCaptureState> {\n        return events.pipe(\n            map(state => {\n                if (state.pointers.length !== 1) {\n                    return GestureCaptureState.Skip\n                }\n\n                if (Math.abs(state.pointers[0].distance.x) > this.distanceInclusion) {\n                    return this.horizontal ? GestureCaptureState.Maybe : GestureCaptureState.Skip\n                }\n\n                if (Math.abs(state.pointers[0].distance.y) > this.distanceInclusion) {\n                    return this.vertical ? GestureCaptureState.Maybe : GestureCaptureState.Skip\n                }\n                return GestureCaptureState.Pending\n            })\n        )\n    }\n\n    override handle(events: Observable<GestureEvent>) {\n        const updater =\n            this.horizontal && this.vertical\n                ? updateAnyDirection\n                : this.horizontal\n                  ? updateHorizontalOnly\n                  : updateVerticalOnly\n\n        return super.handle(events).pipe(tap(updater))\n    }\n}\n\ntype UpdaterFn = (event: Mutable<GestureDragEvent>) => void\n\nfunction updateVerticalOnly(event: Mutable<GestureDragEvent>) {\n    const pointer = event.pointers[0]\n    pointer.distance.x = 0\n    pointer.direction.x = 0\n    pointer.current.x = pointer.start.x\n    updateEvent(event, updateByScrollDistanceVertical)\n}\n\nfunction updateHorizontalOnly(event: Mutable<GestureDragEvent>) {\n    console.log(\"updateHorizontalOnly\")\n    const pointer = event.pointers[0]\n    pointer.distance.y = 0\n    pointer.direction.y = 0\n    pointer.current.y = pointer.start.y\n    updateEvent(event, updateByScrollDistanceHorizontal)\n}\n\nfunction updateAnyDirection(event: Mutable<GestureDragEvent>) {\n    updateEvent(event, updateByScrollDistanceBoth)\n}\n\nfunction updateEvent(event: Mutable<GestureDragEvent>, scrollUpdate: UpdaterFn) {\n    event.moveBy = { ...event.pointers[0].distance }\n    scrollUpdate(event)\n}\n\nfunction updateByScrollDistanceVertical(event: Mutable<GestureDragEvent>) {\n    const sd = event.scrollDistance\n    if (sd == null) {\n        return\n    }\n    event.moveBy.y += sd.y\n}\n\nfunction updateByScrollDistanceHorizontal(event: Mutable<GestureDragEvent>) {\n    const sd = event.scrollDistance\n    if (sd == null) {\n        return\n    }\n    event.moveBy.x += sd.x\n}\n\nfunction updateByScrollDistanceBoth(event: Mutable<GestureDragEvent>) {\n    const sd = event.scrollDistance\n    if (sd == null) {\n        return\n    }\n    event.moveBy.x += sd.x\n    event.moveBy.y += sd.y\n}\n\nexport function gestureDrag(options?: GestureDragOptions) {\n    return new GestureDragImpl(options)\n}\n\nexport const GestureDarg = gestureDrag()\nexport const GestureDargHorizontal = gestureDrag({ horizontal: true, vertical: false })\nexport const GestureDargVertical = gestureDrag({ horizontal: false, vertical: true })\n"]}

package/esm2022/gestures/gesture-event.mjs

@@ -0,0 +1,44 @@
+export const Listeners = {
+    mousedown: {
+        pointerType: "mouse" /* GesturePointerType.Mouse */,
+        phase: "start" /* GesturePhase.Start */,
+        options: { capture: true, passive: false }
+    },
+    mousemove: {
+        pointerType: "mouse" /* GesturePointerType.Mouse */,
+        phase: "moving" /* GesturePhase.Moving */,
+        options: { capture: true, passive: false }
+    },
+    mouseup: {
+        pointerType: "mouse" /* GesturePointerType.Mouse */,
+        phase: "end" /* GesturePhase.End */,
+        options: { capture: true, passive: false }
+    },
+    touchstart: {
+        pointerType: "touch" /* GesturePointerType.Touch */,
+        phase: "start" /* GesturePhase.Start */,
+        options: { capture: true, passive: false }
+    },
+    touchmove: {
+        pointerType: "touch" /* GesturePointerType.Touch */,
+        phase: "moving" /* GesturePhase.Moving */,
+        options: { capture: true, passive: false }
+    },
+    touchend: {
+        pointerType: "touch" /* GesturePointerType.Touch */,
+        phase: "end" /* GesturePhase.End */,
+        options: { capture: true, passive: false }
+    },
+    touchcancel: {
+        pointerType: "touch" /* GesturePointerType.Touch */,
+        phase: "end" /* GesturePhase.End */,
+        options: { capture: true, passive: false }
+    }
+    // ,
+    // contextmenu: {
+    //     pointerType: GesturePointerType.Mouse,
+    //     phase: GesturePhase.Start,
+    //     options: { capture: true, passive: false }
+    // }
+};
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/gestures/gesture-longtap.mjs

@@ -0,0 +1,36 @@
+import { combineLatest, filter, map, startWith, timer } from "rxjs";
+import { Gesture } from "./gesture";
+export class GestureLongTapImpl extends Gesture {
+    constructor(options) {
+        super("gesture-longtap", ["touchstart", "touchmove", "touchend", "touchcancel"], {
+            filterPointerTypes: ["touch" /* GesturePointerType.Touch */],
+            ...options
+        });
+    }
+    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 (event.phase === "end" /* GesturePhase.End */ && event.elapsed > this.timeWithin) {
+                return 2 /* GestureCaptureState.Skip */;
+            }
+            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 2 /* GestureCaptureState.Skip */;
+            }
+        }));
+    }
+    handle(events) {
+        return super.handle(events.pipe(filter(event => event.phase === "start" /* GesturePhase.Start */ || event.phase === "end" /* GesturePhase.End */)));
+    }
+}
+export function gestureLongTap(options) {
+    return new GestureLongTapImpl(options);
+}
+export const GestureLongTap = gestureLongTap();
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/gestures/gesture-tap.mjs

@@ -0,0 +1,33 @@
+import { filter, map } from "rxjs";
+import { Gesture } from "./gesture";
+export 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 */)));
+    }
+}
+export function gestureTap(options) {
+    return new GestureTapImpl(options);
+}
+export const GestureTap = gestureTap();
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/gestures/gesture.mjs

@@ -0,0 +1,29 @@
+import { tap } from "rxjs";
+import { Listeners } from "./gesture-event";
+export 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)));
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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