@ngutil/aria 0.0.70 → 0.0.72

package/esm2022/gestures/gesture-drag.mjs

@@ -0,0 +1,80 @@
+import { map, tap } from "rxjs";
+import { Gesture } from "./gesture";
+export class GestureDragImpl extends Gesture {
+    constructor(options) {
+        super("gesture-drag", { includeScrollDistance: true, ...options });
+        if (this.horizontal == null && this.vertical == null) {
+            this.horizontal = true;
+            this.vertical = true;
+        }
+    }
+    capture(events) {
+        return events.pipe(map(state => {
+            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) {
+    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":"AAAA,OAAO,EAAE,GAAG,EAAc,GAAG,EAAE,MAAM,MAAM,CAAA;AAM3C,OAAO,EAAE,OAAO,EAAuC,MAAM,WAAW,CAAA;AASxE,MAAM,OAAO,eAAgB,SAAQ,OAA0B;IAI3D,YAAY,OAA4B;QACpC,KAAK,CAAC,cAAc,EAAE,EAAE,qBAAqB,EAAE,IAAI,EAAE,GAAG,OAAO,EAAE,CAAC,CAAA;QAElE,IAAI,IAAI,CAAC,UAAU,IAAI,IAAI,IAAI,IAAI,CAAC,QAAQ,IAAI,IAAI,EAAE,CAAC;YACnD,IAAI,CAAC,UAAU,GAAG,IAAI,CAAA;YACtB,IAAI,CAAC,QAAQ,GAAG,IAAI,CAAA;QACxB,CAAC;IACL,CAAC;IAEQ,OAAO,CAAC,MAAiC;QAC9C,OAAO,MAAM,CAAC,IAAI,CACd,GAAG,CAAC,KAAK,CAAC,EAAE;YACR,IAAI,IAAI,CAAC,GAAG,CAAC,KAAK,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC,QAAQ,CAAC,CAAC,CAAC,GAAG,IAAI,CAAC,iBAAiB,EAAE,CAAC;gBAClE,OAAO,IAAI,CAAC,UAAU,CAAC,CAAC,mCAA2B,CAAC,iCAAyB,CAAA;YACjF,CAAC;YAED,IAAI,IAAI,CAAC,GAAG,CAAC,KAAK,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC,QAAQ,CAAC,CAAC,CAAC,GAAG,IAAI,CAAC,iBAAiB,EAAE,CAAC;gBAClE,OAAO,IAAI,CAAC,QAAQ,CAAC,CAAC,mCAA2B,CAAC,iCAAyB,CAAA;YAC/E,CAAC;YACD,2CAAkC;QACtC,CAAC,CAAC,CACL,CAAA;IACL,CAAC;IAEQ,MAAM,CAAC,MAAiC;QAC7C,MAAM,OAAO,GACT,IAAI,CAAC,UAAU,IAAI,IAAI,CAAC,QAAQ;YAC5B,CAAC,CAAC,kBAAkB;YACpB,CAAC,CAAC,IAAI,CAAC,UAAU;gBACf,CAAC,CAAC,oBAAoB;gBACtB,CAAC,CAAC,kBAAkB,CAAA;QAE9B,OAAO,KAAK,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,OAAO,CAAC,CAAC,CAAA;IAClD,CAAC;CACJ;AAID,SAAS,kBAAkB,CAAC,KAAiC;IACzD,MAAM,OAAO,GAAG,KAAK,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAA;IACjC,OAAO,CAAC,QAAQ,CAAC,CAAC,GAAG,CAAC,CAAA;IACtB,OAAO,CAAC,SAAS,CAAC,CAAC,GAAG,CAAC,CAAA;IACvB,OAAO,CAAC,OAAO,CAAC,CAAC,GAAG,OAAO,CAAC,KAAK,CAAC,CAAC,CAAA;IACnC,WAAW,CAAC,KAAK,EAAE,8BAA8B,CAAC,CAAA;AACtD,CAAC;AAED,SAAS,oBAAoB,CAAC,KAAiC;IAC3D,MAAM,OAAO,GAAG,KAAK,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAA;IACjC,OAAO,CAAC,QAAQ,CAAC,CAAC,GAAG,CAAC,CAAA;IACtB,OAAO,CAAC,SAAS,CAAC,CAAC,GAAG,CAAC,CAAA;IACvB,OAAO,CAAC,OAAO,CAAC,CAAC,GAAG,OAAO,CAAC,KAAK,CAAC,CAAC,CAAA;IACnC,WAAW,CAAC,KAAK,EAAE,gCAAgC,CAAC,CAAA;AACxD,CAAC;AAED,SAAS,kBAAkB,CAAC,KAAiC;IACzD,WAAW,CAAC,KAAK,EAAE,0BAA0B,CAAC,CAAA;AAClD,CAAC;AAED,SAAS,WAAW,CAAC,KAAiC,EAAE,YAAuB;IAC3E,KAAK,CAAC,MAAM,GAAG,EAAE,GAAG,KAAK,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC,QAAQ,EAAE,CAAA;IAChD,YAAY,CAAC,KAAK,CAAC,CAAA;AACvB,CAAC;AAED,SAAS,8BAA8B,CAAC,KAAiC;IACrE,MAAM,EAAE,GAAG,KAAK,CAAC,cAAc,CAAA;IAC/B,IAAI,EAAE,IAAI,IAAI,EAAE,CAAC;QACb,OAAM;IACV,CAAC;IACD,KAAK,CAAC,MAAM,CAAC,CAAC,IAAI,EAAE,CAAC,CAAC,CAAA;AAC1B,CAAC;AAED,SAAS,gCAAgC,CAAC,KAAiC;IACvE,MAAM,EAAE,GAAG,KAAK,CAAC,cAAc,CAAA;IAC/B,IAAI,EAAE,IAAI,IAAI,EAAE,CAAC;QACb,OAAM;IACV,CAAC;IACD,KAAK,CAAC,MAAM,CAAC,CAAC,IAAI,EAAE,CAAC,CAAC,CAAA;AAC1B,CAAC;AAED,SAAS,0BAA0B,CAAC,KAAiC;IACjE,MAAM,EAAE,GAAG,KAAK,CAAC,cAAc,CAAA;IAC/B,IAAI,EAAE,IAAI,IAAI,EAAE,CAAC;QACb,OAAM;IACV,CAAC;IACD,KAAK,CAAC,MAAM,CAAC,CAAC,IAAI,EAAE,CAAC,CAAC,CAAA;IACtB,KAAK,CAAC,MAAM,CAAC,CAAC,IAAI,EAAE,CAAC,CAAC,CAAA;AAC1B,CAAC;AAED,MAAM,UAAU,WAAW,CAAC,OAA4B;IACpD,OAAO,IAAI,eAAe,CAAC,OAAO,CAAC,CAAA;AACvC,CAAC;AAED,MAAM,CAAC,MAAM,WAAW,GAAG,WAAW,EAAE,CAAA;AACxC,MAAM,CAAC,MAAM,qBAAqB,GAAG,WAAW,CAAC,EAAE,UAAU,EAAE,IAAI,EAAE,QAAQ,EAAE,KAAK,EAAE,CAAC,CAAA;AACvF,MAAM,CAAC,MAAM,mBAAmB,GAAG,WAAW,CAAC,EAAE,UAAU,EAAE,KAAK,EAAE,QAAQ,EAAE,IAAI,EAAE,CAAC,CAAA","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 { GestureDetail } from \"./gesture-event\"\n\nexport interface GestureDragDetail extends GestureDetail<\"gesture-drag\"> {\n    moveBy: Position\n}\n\nexport type GestureDragOptions = GestureOptions<GestureDragImpl>\n\nexport class GestureDragImpl extends Gesture<GestureDragDetail> {\n    readonly horizontal?: boolean\n    readonly vertical?: boolean\n\n    constructor(options?: GestureDragOptions) {\n        super(\"gesture-drag\", { 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<GestureDetail>): Observable<GestureCaptureState> {\n        return events.pipe(\n            map(state => {\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<GestureDetail>) {\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<GestureDragDetail>) => void\n\nfunction updateVerticalOnly(event: Mutable<GestureDragDetail>) {\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<GestureDragDetail>) {\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<GestureDragDetail>) {\n    updateEvent(event, updateByScrollDistanceBoth)\n}\n\nfunction updateEvent(event: Mutable<GestureDragDetail>, scrollUpdate: UpdaterFn) {\n    event.moveBy = { ...event.pointers[0].distance }\n    scrollUpdate(event)\n}\n\nfunction updateByScrollDistanceVertical(event: Mutable<GestureDragDetail>) {\n    const sd = event.scrollDistance\n    if (sd == null) {\n        return\n    }\n    event.moveBy.y += sd.y\n}\n\nfunction updateByScrollDistanceHorizontal(event: Mutable<GestureDragDetail>) {\n    const sd = event.scrollDistance\n    if (sd == null) {\n        return\n    }\n    event.moveBy.x += sd.x\n}\n\nfunction updateByScrollDistanceBoth(event: Mutable<GestureDragDetail>) {\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,45 @@
+const PHANTOM = Symbol("phantom");
+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,33 @@
+import { combineLatest, filter, map, startWith, timer } from "rxjs";
+import { Gesture } from "./gesture";
+export class GestureLongTapImpl extends Gesture {
+    constructor(options) {
+        super("gesture-longtap", { pointerTypes: ["touch" /* GesturePointerType.Touch */], ...options });
+    }
+    capture(events) {
+        return combineLatest({ timeWithin: timer(this.timeWithin).pipe(startWith(null)), event: events }).pipe(map(({ timeWithin, event }) => {
+            if (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,36 @@
+import { filter, map } from "rxjs";
+import { Gesture } from "./gesture";
+export class GestureTapImpl extends Gesture {
+    constructor(options) {
+        super("gesture-tap", options);
+    }
+    capture(events) {
+        return events.pipe(map(event => {
+            const distance = event.pointers[0].distance;
+            if (Math.abs(distance.x) < this.distanceInclusion && Math.abs(distance.y) < this.distanceInclusion) {
+                // TODO
+                // if (event.phase === GesturePhase.End) {
+                //     if (event.target === event.origin.target || event.target.contains(event.origin.target)) {
+                //         return GestureCaptureState.Instant
+                //     } else {
+                //         return GestureCaptureState.Skip
+                //     }
+                // } else {
+                //     return GestureCaptureState.Pending
+                // }
+                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,67 @@
+import { Listeners } from "./gesture-event";
+export class Gesture {
+    constructor(name, options = {}) {
+        this.name = name;
+        /**
+         * Gestures that depends on move distance, like drag, use this option
+         */
+        this.distanceInclusion = 10;
+        /**
+         * Gestures thet dependnso on time frame, like longtap, use this option
+         */
+        this.timeWithin = 300;
+        /**
+         * The priority of the gesture
+         */
+        this.priority = 0;
+        /**
+         * Should the gesture include the scroll distance
+         */
+        this.includeScrollDistance = false;
+        /**
+         * The pointer types of the gesture
+         */
+        this.pointerTypes = ["mouse" /* GesturePointerType.Mouse */, "touch" /* GesturePointerType.Touch */];
+        /**
+         * The number of pointers of the gesture can handle
+         */
+        this.pointerCount = 1;
+        /**
+         * The mouse buttons of the gesture (1 = left, 2 = middle, 3 = right)
+         */
+        this.mouseButtons = [0];
+        Object.assign(this, options);
+        this.originTypes = Object.keys(Listeners).filter(v => this.pointerTypes.includes(Listeners[v].pointerType));
+    }
+    /**
+     * Transform input event, to gesture event.
+     * The given events is filterde by {@see Gesture#isRelevantEvent}
+     * ! important, dont rely on this object state, because not always create a new object
+     * @param events events to transform or filter or leave as is
+     */
+    handle(events) {
+        return events;
+    }
+    /**
+     * Should this gesture capture the event?
+     * @param event event to check
+     * @returns true if the gesture should capture the event, false otherwise
+     */
+    shouldCapture(event) {
+        return this.isRelevantEvent(event);
+    }
+    /**
+     * Test if the event is relevant to the gesture.
+     * The event is relevant if
+     * @param event event to check
+     * @returns true if the event is relevant, false otherwise
+     */
+    isRelevantEvent(event) {
+        return (this.pointerTypes.includes(event.pointerType) &&
+            this.pointerCount === event.pointers.length &&
+            this.originTypes.includes(event.origin.type) &&
+            (event.pointerType !== "mouse" /* GesturePointerType.Mouse */ ||
+                (event.origin instanceof MouseEvent && this.mouseButtons.includes(event.origin.button))));
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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