@ngutil/aria 0.0.71 → 0.0.73

package/gestures/gesture-drag.d.ts

@@ -2,19 +2,19 @@ import { Observable } from "rxjs";
 import { Mutable } from "utility-types";
 import { Position } from "@ngutil/style";
 import { Gesture, GestureCaptureState, GestureOptions } from "./gesture";
-import { GestureEvent } from "./gesture-event";
-export interface GestureDragEvent extends GestureEvent<"gesture-drag"> {
+import { GestureDetail } from "./gesture-event";
+export interface GestureDragDetail extends GestureDetail<"gesture-drag"> {
     moveBy: Position;
 }
 export type GestureDragOptions = GestureOptions<GestureDragImpl>;
-export declare class GestureDragImpl extends Gesture<GestureDragEvent> {
+export declare class GestureDragImpl<T extends GestureDragDetail = GestureDragDetail> extends Gesture<T> {
     readonly horizontal?: boolean;
     readonly vertical?: boolean;
     constructor(options?: GestureDragOptions);
-    capture(events: Observable<GestureEvent>): Observable<GestureCaptureState>;
-    handle(events: Observable<GestureEvent>): Observable<Mutable<GestureDragEvent>>;
+    capture(events: Observable<GestureDetail>): Observable<GestureCaptureState>;
+    handle(events: Observable<GestureDetail>): Observable<Mutable<T>>;
 }
-export declare function gestureDrag(options?: GestureDragOptions): GestureDragImpl;
-export declare const GestureDarg: GestureDragImpl;
-export declare const GestureDargHorizontal: GestureDragImpl;
-export declare const GestureDargVertical: GestureDragImpl;
+export declare function gestureDrag(options?: GestureDragOptions): GestureDragImpl<GestureDragDetail>;
+export declare const GestureDarg: GestureDragImpl<GestureDragDetail>;
+export declare const GestureDargHorizontal: GestureDragImpl<GestureDragDetail>;
+export declare const GestureDargVertical: GestureDragImpl<GestureDragDetail>;

package/gestures/gesture-event.d.ts

@@ -1,9 +1,10 @@
 import { Position } from "@ngutil/style";
-export type GestureDomEvent<T extends GestureEvent> = T extends GestureEvent<infer N> ? CustomEvent<T> & {
+export type GestureEvent<T extends GestureDetail> = T extends GestureDetail<infer N> ? CustomEvent<T> & {
     type: N;
 } : never;
-export interface GestureEvent<T extends string = string> {
-    readonly type: T;
+declare const PHANTOM: unique symbol;
+export interface GestureDetail<T extends string = string> {
+    readonly [PHANTOM]: T;
     readonly origin: GestureOrigin;
     readonly target: HTMLElement;
     readonly pointerType: GesturePointerType;
@@ -42,3 +43,4 @@ export interface GestureListenerConfig {
 export declare const Listeners: {
     [key: string]: GestureListenerConfig;
 };
+export {};

package/gestures/gesture-longtap.d.ts

@@ -1,12 +1,12 @@
 import { Observable } from "rxjs";
 import { Gesture, GestureCaptureState, GestureOptions } from "./gesture";
-import { GestureEvent } from "./gesture-event";
-export type GestureLongtapEvent = GestureEvent<"gesture-longtap">;
-export type GestureLongtapOptions = GestureOptions<GestureLongTapImpl>;
-export declare class GestureLongTapImpl extends Gesture<GestureLongtapEvent> {
-    constructor(options?: GestureLongtapOptions);
-    capture(events: Observable<GestureEvent>): Observable<GestureCaptureState>;
-    handle(events: Observable<GestureEvent>): Observable<import("utility-types").Mutable<GestureLongtapEvent>>;
+import { GestureDetail } from "./gesture-event";
+export type GestureLongTapDetail = GestureDetail<"gesture-longtap">;
+export type GestureLongTapOptions = GestureOptions<GestureLongTapImpl>;
+export declare class GestureLongTapImpl<T extends GestureLongTapDetail = GestureLongTapDetail> extends Gesture<T> {
+    constructor(options?: GestureLongTapOptions);
+    capture(events: Observable<GestureDetail>): Observable<GestureCaptureState>;
+    handle(events: Observable<GestureDetail>): Observable<import("utility-types").Mutable<T>>;
 }
-export declare function gestureLongTap(options?: GestureLongtapOptions): GestureLongTapImpl;
-export declare const GestureLongTap: GestureLongTapImpl;
+export declare function gestureLongTap(options?: GestureLongTapOptions): GestureLongTapImpl<GestureLongTapDetail>;
+export declare const GestureLongTap: GestureLongTapImpl<GestureLongTapDetail>;

package/gestures/gesture-tap.d.ts

@@ -1,12 +1,12 @@
 import { Observable } from "rxjs";
 import { Gesture, GestureCaptureState, GestureOptions } from "./gesture";
-import { GestureEvent } from "./gesture-event";
-export type GestureTapEvent = GestureEvent<"gesture-tap">;
+import { GestureDetail } from "./gesture-event";
+export type GestureTapDetail = GestureDetail<"gesture-tap">;
 export type GestureTapOptions = GestureOptions<GestureTapImpl>;
-export declare class GestureTapImpl extends Gesture<GestureTapEvent> {
+export declare class GestureTapImpl<T extends GestureTapDetail = GestureTapDetail> extends Gesture<T> {
     constructor(options?: GestureTapOptions);
-    capture(events: Observable<GestureEvent>): Observable<GestureCaptureState>;
-    handle(events: Observable<GestureEvent>): Observable<import("utility-types").Mutable<GestureTapEvent>>;
+    capture(events: Observable<GestureDetail>): Observable<GestureCaptureState>;
+    handle(events: Observable<GestureDetail>): Observable<import("utility-types").Mutable<T>>;
 }
-export declare function gestureTap(options?: GestureTapOptions): GestureTapImpl;
-export declare const GestureTap: GestureTapImpl;
+export declare function gestureTap(options?: GestureTapOptions): GestureTapImpl<GestureTapDetail>;
+export declare const GestureTap: GestureTapImpl<GestureTapDetail>;

package/gestures/gesture.d.ts

@@ -1,6 +1,6 @@
 import { Observable } from "rxjs";
 import { FunctionKeys, Mutable } from "utility-types";
-import { GestureEvent, GesturePointerType } from "./gesture-event";
+import { GestureDetail, GesturePointerType } from "./gesture-event";
 export declare const enum GestureCaptureState {
     Unchecked = 0,
     Pending = 1,
@@ -8,28 +8,69 @@ export declare const enum GestureCaptureState {
     Maybe = 3,
     Instant = 4
 }
-type _GestureOptions = Partial<Omit<Gesture<any>, "filterListeners" | "name" | FunctionKeys<Gesture<any>>>>;
+type _GestureOptions = Partial<Omit<Gesture<any>, "originTypes" | "name" | FunctionKeys<Gesture<any>>>>;
 export type GestureOptions<T extends object> = Partial<Omit<T, keyof Gesture<any> | FunctionKeys<T>>> & _GestureOptions;
-export declare abstract class Gesture<T extends GestureEvent = GestureEvent> {
+export declare abstract class Gesture<T extends GestureDetail = GestureDetail> {
     readonly name: string;
+    /**
+     * Gestures that depends on move distance, like drag, use this option
+     */
     readonly distanceInclusion = 10;
+    /**
+     * Gestures thet dependnso on time frame, like longtap, use this option
+     */
     readonly timeWithin = 300;
+    /**
+     * The priority of the gesture
+     */
     readonly priority = 0;
+    /**
+     * Should the gesture include the scroll distance
+     */
     readonly includeScrollDistance: boolean;
-    readonly filterPointerTypes: Array<GesturePointerType>;
-    readonly filterMouseButtons: Array<number>;
-    readonly filterListeners: Array<keyof DocumentEventMap>;
-    constructor(name: string, listeners: Array<keyof DocumentEventMap>, options?: _GestureOptions);
+    /**
+     * The pointer types of the gesture
+     */
+    readonly pointerTypes: Array<GesturePointerType>;
+    /**
+     * The number of pointers of the gesture can handle
+     */
+    readonly pointerCount: number;
+    /**
+     * The mouse buttons of the gesture (1 = left, 2 = middle, 3 = right)
+     */
+    readonly mouseButtons: Array<number>;
+    /**
+     * The event types of the gesture can handle
+     */
+    readonly originTypes: Array<string>;
+    constructor(name: string, options?: _GestureOptions);
     /**
      * Test if the gesture should be captured.
+     * The given events is filterde by {@see Gesture#shouldCapture}
      * ! important, dont rely on this object state, because not always create a new object
+     * @param events events to check
      */
-    abstract capture(events: Observable<GestureEvent>): Observable<GestureCaptureState>;
+    abstract capture(events: Observable<GestureDetail>): Observable<GestureCaptureState>;
     /**
-     * Transform input event, to gesture event
+     * 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: Observable<GestureDetail>): Observable<Mutable<T>>;
+    /**
+     * Should this gesture capture the event?
+     * @param event event to check
+     * @returns true if the gesture should capture the event, false otherwise
+     */
+    shouldCapture(event: GestureDetail): boolean;
+    /**
+     * 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
      */
-    handle(events: Observable<GestureEvent>): Observable<Mutable<T>>;
-    filterByEvent: <T_1 extends GestureEvent>(event: T_1) => event is T_1;
+    isRelevantEvent(event: GestureDetail): boolean;
 }
 export {};

package/gestures/gesture.service.d.ts

@@ -1,7 +1,7 @@
 import { Observable } from "rxjs";
 import { ElementInput } from "@ngutil/common";
 import { Gesture } from "./gesture";
-import { GestureDomEvent } from "./gesture-event";
+import { GestureEvent } from "./gesture-event";
 import * as i0 from "@angular/core";
 type GesturesToEventsType<T extends Array<Gesture>> = T extends Array<infer G> ? (G extends Gesture<infer E> ? E : never) : never;
 type GestureEventDiscriminator<T> = T extends {
@@ -10,12 +10,11 @@ type GestureEventDiscriminator<T> = T extends {
     type: N;
 } & T : never;
 export type GestureWatchReturns<T extends Array<Gesture>> = Observable<GestureEventDiscriminator<GesturesToEventsType<T>>>;
-export type GestureListenReturns<T extends Array<Gesture>> = Observable<GestureDomEvent<GesturesToEventsType<T>>>;
+export type GestureListenReturns<T extends Array<Gesture>> = Observable<GestureEvent<GesturesToEventsType<T>>>;
 export declare class GestureService {
     #private;
     constructor();
     listen<T extends Array<Gesture>>(el: ElementInput, ...gestures: T): GestureListenReturns<T>;
-    watch<T extends Array<Gesture>>(el: ElementInput, ...gestures: T): GestureWatchReturns<T>;
     static ɵfac: i0.ɵɵFactoryDeclaration<GestureService, never>;
     static ɵprov: i0.ɵɵInjectableDeclaration<GestureService>;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ngutil/aria",
-  "version": "0.0.71",
+  "version": "0.0.73",
   "peerDependencies": {
     "@angular/cdk": "18.2.6",
     "@angular/common": "18.2.6",
@@ -9,8 +9,8 @@
     "rxjs": "^7.8.1",
     "tabbable": "^6.2.0",
     "utility-types": "^3.11.0",
-    "@ngutil/style": "0.0.71",
-    "@ngutil/common": "0.0.71"
+    "@ngutil/common": "0.0.73",
+    "@ngutil/style": "0.0.73"
   },
   "publishConfig": {
     "access": "public",