npm - gesturx - Versions diffs - 1.0.0 → 1.1.0 - Mend

gesturx 1.0.0 → 1.1.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (63) hide show

package/README.md +17 -1
package/dist/core/index.d.ts +4 -0
package/dist/core/manager.d.ts +15 -0
package/dist/core/pan/PanRecognizer.d.ts +19 -0
package/dist/core/pinch/PinchRecognizer.d.ts +29 -0
package/dist/core/recognizer/Recognizer.d.ts +21 -0
package/dist/core/recognizer/RecognizerEvent.d.ts +42 -0
package/dist/core/recognizer/mapToRecognizerEvent.d.ts +8 -0
package/dist/core/rotate/RotateRecognizer.d.ts +24 -0
package/dist/core/swipe/SwipeRecognizer.d.ts +30 -0
package/dist/core/swipe/SwipeRecognizer.test.d.ts +1 -0
package/dist/core/swipe/isRecognizedAsSwipe.d.ts +4 -0
package/dist/core/tap/TapRecognizer.d.ts +20 -0
package/dist/core/tap/TapRecognizer.test.d.ts +1 -0
package/dist/core/utils/events.d.ts +40 -0
package/dist/core/utils/geometry.d.ts +17 -0
package/dist/core/utils/utils.d.ts +17 -0
package/dist/core/utils/utils.test.d.ts +1 -0
package/dist/demo/App.d.ts +2 -0
package/dist/demo/DebugBox.d.ts +5 -0
package/dist/demo/useManager.d.ts +11 -0
package/dist/demo/useTap.d.ts +5 -0
package/dist/index.js +505 -0
package/dist/index.js.map +1 -0
package/dist/index.umd.cjs +2 -0
package/dist/index.umd.cjs.map +1 -0
package/dist/main.d.ts +1 -0
package/dist/theme.d.ts +1 -0
package/package.json +4 -1
package/.github/workflows/publish.yml +0 -17
package/.prettierrc.json +0 -3
package/eslint.config.js +0 -18
package/index.html +0 -13
package/src/core/index.ts +0 -4
package/src/core/manager.ts +0 -46
package/src/core/pan/PanRecognizer.ts +0 -192
package/src/core/pinch/PinchRecognizer.ts +0 -131
package/src/core/recognizer/Recognizer.ts +0 -54
package/src/core/recognizer/RecognizerEvent.ts +0 -39
package/src/core/recognizer/mapToRecognizerEvent.ts +0 -142
package/src/core/rotate/RotateRecognizer.ts +0 -115
package/src/core/swipe/SwipeRecognizer.test.ts +0 -160
package/src/core/swipe/SwipeRecognizer.ts +0 -82
package/src/core/swipe/isRecognizedAsSwipe.ts +0 -13
package/src/core/tap/TapRecognizer.test.ts +0 -567
package/src/core/tap/TapRecognizer.ts +0 -172
package/src/core/utils/events.ts +0 -186
package/src/core/utils/geometry.ts +0 -115
package/src/core/utils/utils.test.ts +0 -26
package/src/core/utils/utils.ts +0 -58
package/src/demo/App.tsx +0 -171
package/src/demo/DebugBox.tsx +0 -10
package/src/demo/useManager.ts +0 -40
package/src/demo/useTap.tsx +0 -87
package/src/index.css +0 -66
package/src/main.tsx +0 -14
package/src/theme.ts +0 -11
package/src/vite-env.d.ts +0 -1
package/tsconfig.json +0 -26
package/tsconfig.node.json +0 -11
package/vite.config.ts +0 -38
package/vitest.config.ts +0 -8
/package/{public → dist}/vite.svg +0 -0

package/src/core/tap/TapRecognizer.test.ts DELETED Viewed

@@ -1,567 +0,0 @@
-import { describe, it, expect, beforeEach } from "vitest"
-import { TapRecognizer } from "./TapRecognizer"
-import { buffer, first, lastValueFrom, tap, timer } from "rxjs"
-const waitFor = (time: number) =>
-  new Promise((resolve) => setTimeout(resolve, time))
-describe("TapGestureRecognizer", () => {
-  let container = document.createElement("div")
-  beforeEach(() => {
-    container = document.createElement("div")
-    document.body.appendChild(container)
-  })
-  function createPointerEvent({
-    type,
-    x,
-    y,
-    identifier,
-  }: {
-    type: string
-    x: number
-    y: number
-    identifier: number
-  }) {
-    const event = new PointerEvent(type, {
-      clientX: x,
-      clientY: y,
-      pointerId: identifier,
-      pointerType: "touch",
-      bubbles: true,
-    })
-    // @ts-ignore
-    event.x = x
-    // @ts-ignore
-    event.y = y
-    return event
-  }
-  function sendPointerEvent({
-    type,
-    x,
-    y,
-    container,
-    identifier,
-  }: {
-    container: HTMLElement
-    type: string
-    x: number
-    y: number
-    identifier: number
-  }) {
-    const event = createPointerEvent({
-      type,
-      x,
-      y,
-      identifier,
-    })
-    sendPointerEventFromEvent({ event, container })
-  }
-  function sendPointerEventFromEvent({
-    event,
-    container,
-  }: {
-    event: PointerEvent
-    container: HTMLElement
-  }) {
-    container.dispatchEvent(event)
-  }
-  it("should detect a single tap", async () => {
-    const multiTapThreshold = 5
-    const waitLongEnough$ = timer(100)
-    const recognizer = new TapRecognizer({ multiTapThreshold })
-    recognizer.initialize({
-      container,
-    })
-    const values = await lastValueFrom(
-      recognizer.events$.pipe(
-        tap({
-          subscribe: async () => {
-            await waitFor(1)
-            sendPointerEvent({
-              container,
-              identifier: 1,
-              type: "pointerdown",
-              x: 0,
-              y: 0,
-            })
-            sendPointerEvent({
-              container,
-              identifier: 1,
-              type: "pointerup",
-              x: 0,
-              y: 0,
-            })
-          },
-        }),
-        buffer(waitLongEnough$),
-        first(),
-      ),
-    )
-    expect(values).toMatchObject([{ type: "tap", taps: 1 }])
-  })
-  it("should detect a double tap", async () => {
-    const multiTapThreshold = 5
-    const waitLongEnough$ = timer(multiTapThreshold * 2)
-    const recognizer = new TapRecognizer({ multiTapThreshold, maxTaps: 2 })
-    recognizer.initialize({
-      container,
-    })
-    const values = await lastValueFrom(
-      recognizer.events$.pipe(
-        tap({
-          subscribe: async () => {
-            await waitFor(1)
-            sendPointerEvent({
-              container,
-              identifier: 1,
-              type: "pointerdown",
-              x: 0,
-              y: 0,
-            })
-            sendPointerEvent({
-              container,
-              identifier: 1,
-              type: "pointerup",
-              x: 0,
-              y: 0,
-            })
-            sendPointerEvent({
-              container,
-              identifier: 2,
-              type: "pointerdown",
-              x: 0,
-              y: 0,
-            })
-            sendPointerEvent({
-              container,
-              identifier: 2,
-              type: "pointerup",
-              x: 0,
-              y: 0,
-            })
-          },
-        }),
-        buffer(waitLongEnough$),
-        first(),
-      ),
-    )
-    expect(values).toMatchObject([{ type: "tap", taps: 2 }])
-  })
-  it("should detect a triple tap", async () => {
-    const multiTapThreshold = 5
-    const recognizer = new TapRecognizer({ multiTapThreshold, maxTaps: 3 })
-    recognizer.initialize({
-      container,
-    })
-    const waitLongEnough$ = timer(100)
-    const values = await lastValueFrom(
-      recognizer.events$.pipe(
-        tap({
-          subscribe: () => {
-            setTimeout(() => {
-              sendPointerEvent({
-                container,
-                identifier: 1,
-                type: "pointerdown",
-                x: 0,
-                y: 0,
-              })
-              sendPointerEvent({
-                container,
-                identifier: 1,
-                type: "pointerup",
-                x: 0,
-                y: 0,
-              })
-              sendPointerEvent({
-                container,
-                identifier: 1,
-                type: "pointerdown",
-                x: 0,
-                y: 0,
-              })
-              sendPointerEvent({
-                container,
-                identifier: 1,
-                type: "pointerup",
-                x: 0,
-                y: 0,
-              })
-              sendPointerEvent({
-                container,
-                identifier: 1,
-                type: "pointerdown",
-                x: 0,
-                y: 0,
-              })
-              sendPointerEvent({
-                container,
-                identifier: 1,
-                type: "pointerup",
-                x: 0,
-                y: 0,
-              })
-            })
-          },
-        }),
-        buffer(waitLongEnough$),
-        first(),
-      ),
-    )
-    expect(values).toMatchObject([{ type: "tap", taps: 3 }])
-  })
-  it("should not detect a double tap if the second tap is after threshold", async () => {
-    const multiTapThreshold = 5
-    const waitLongEnough$ = timer(100)
-    const recognizer = new TapRecognizer({ multiTapThreshold, maxTaps: 2 })
-    recognizer.initialize({
-      container,
-    })
-    const values = await lastValueFrom(
-      recognizer.events$.pipe(
-        tap({
-          subscribe: async () => {
-            await waitFor(1)
-            sendPointerEvent({
-              container,
-              identifier: 1,
-              type: "pointerdown",
-              x: 0,
-              y: 0,
-            })
-            sendPointerEvent({
-              container,
-              identifier: 1,
-              type: "pointerup",
-              x: 0,
-              y: 0,
-            })
-            await waitFor(multiTapThreshold)
-            sendPointerEvent({
-              container,
-              identifier: 2,
-              type: "pointerdown",
-              x: 0,
-              y: 0,
-            })
-            sendPointerEvent({
-              container,
-              identifier: 2,
-              type: "pointerup",
-              x: 0,
-              y: 0,
-            })
-          },
-        }),
-        buffer(waitLongEnough$),
-        first(),
-      ),
-    )
-    expect(values.length).toBe(2)
-    expect(values).toMatchObject([
-      { type: "tap", taps: 1, pointers: [{ pointerId: 1 }] },
-      { type: "tap", taps: 1, pointers: [{ pointerId: 2 }] },
-    ])
-  })
-  it("should not trigger tap if moved too much between down and up", async () => {
-    const multiTapThreshold = 5
-    const waitLongEnough$ = timer(100)
-    const recognizer = new TapRecognizer({
-      multiTapThreshold,
-      posThreshold: 5,
-    })
-    recognizer.initialize({
-      container,
-    })
-    const values = await lastValueFrom(
-      recognizer.events$.pipe(
-        tap({
-          subscribe: async () => {
-            await waitFor(1)
-            sendPointerEvent({
-              container,
-              identifier: 1,
-              type: "pointerdown",
-              x: 0,
-              y: 0,
-            })
-            sendPointerEvent({
-              container,
-              identifier: 1,
-              type: "pointerup",
-              x: 50,
-              y: 50,
-            })
-          },
-        }),
-        buffer(waitLongEnough$),
-        first(),
-      ),
-    )
-    expect(values.length).toBe(0)
-  })
-  it("should not detect a tap if the pointer is held down too long", async () => {
-    const multiTapThreshold = 5
-    const maximumPressTime = 10
-    const waitLongEnough$ = timer(100)
-    const recognizer = new TapRecognizer({
-      multiTapThreshold,
-      posThreshold: 5,
-      maximumPressTime,
-    })
-    recognizer.initialize({
-      container,
-    })
-    const values = await lastValueFrom(
-      recognizer.events$.pipe(
-        tap({
-          subscribe: async () => {
-            await waitFor(1)
-            sendPointerEvent({
-              container,
-              identifier: 1,
-              type: "pointerdown",
-              x: 0,
-              y: 0,
-            })
-            await waitFor(maximumPressTime - 5)
-            sendPointerEvent({
-              container,
-              identifier: 1,
-              type: "pointerup",
-              x: 0,
-              y: 0,
-            })
-            await waitFor(multiTapThreshold * 2)
-            sendPointerEvent({
-              container,
-              identifier: 2,
-              type: "pointerdown",
-              x: 0,
-              y: 0,
-            })
-            await waitFor(maximumPressTime)
-            sendPointerEvent({
-              container,
-              identifier: 2,
-              type: "pointerup",
-              x: 0,
-              y: 0,
-            })
-          },
-        }),
-        buffer(waitLongEnough$),
-        first(),
-      ),
-    )
-    expect(values.length).toBe(1)
-    expect(values).toMatchObject([
-      { type: "tap", taps: 1, pointers: [{ pointerId: 1 }] },
-    ])
-  })
-  it("should ignore taps when there are simultaneous pointers active", async () => {
-    const recognizer = new TapRecognizer({})
-    recognizer.initialize({
-      container,
-    })
-    const waitLongEnough$ = timer(100)
-    const values = await lastValueFrom(
-      recognizer.events$.pipe(
-        tap({
-          subscribe: () => {
-            setTimeout(() => {
-              sendPointerEvent({
-                container,
-                identifier: 1,
-                type: "pointerdown",
-                x: 0,
-                y: 0,
-              })
-              sendPointerEvent({
-                container,
-                identifier: 2,
-                type: "pointerdown",
-                x: 10,
-                y: 10,
-              })
-              sendPointerEvent({
-                container,
-                identifier: 1,
-                type: "pointerup",
-                x: 0,
-                y: 0,
-              })
-              sendPointerEvent({
-                container,
-                identifier: 2,
-                type: "pointerup",
-                x: 10,
-                y: 10,
-              })
-            })
-          },
-        }),
-        buffer(waitLongEnough$),
-        first(),
-      ),
-    )
-    expect(values.length).toBe(0) // Assuming the recognizer should ignore simultaneous taps
-  })
-  it("should ignore one tap if there is more than one tap", async () => {
-    const recognizer = new TapRecognizer({
-      multiTapThreshold: 10,
-      maxTaps: 1,
-    })
-    recognizer.initialize({
-      container,
-    })
-    const waitLongEnough$ = timer(100)
-    const values = await lastValueFrom(
-      recognizer.events$.pipe(
-        tap({
-          subscribe: async () => {
-            await waitFor(1)
-            sendPointerEvent({
-              container,
-              identifier: 1,
-              type: "pointerdown",
-              x: 0,
-              y: 0,
-            })
-            sendPointerEvent({
-              container,
-              identifier: 1,
-              type: "pointerup",
-              x: 0,
-              y: 0,
-            })
-            await waitFor(1)
-            sendPointerEvent({
-              container,
-              identifier: 2,
-              type: "pointerdown",
-              x: 0,
-              y: 0,
-            })
-            sendPointerEvent({
-              container,
-              identifier: 2,
-              type: "pointerup",
-              x: 0,
-              y: 0,
-            })
-          },
-        }),
-        buffer(waitLongEnough$),
-        first(),
-      ),
-    )
-    expect(values.length).toBe(0)
-  })
-  it("should ignore taps when a second tap is outside of position threshold", async () => {
-    const recognizer = new TapRecognizer({
-      posThreshold: 5,
-      multiTapThreshold: 10,
-      maxTaps: Infinity,
-    })
-    recognizer.initialize({
-      container,
-    })
-    const waitLongEnough$ = timer(100)
-    const values = await lastValueFrom(
-      recognizer.events$.pipe(
-        tap({
-          subscribe: async () => {
-            // await waitFor(1)
-            sendPointerEvent({
-              container,
-              identifier: 1,
-              type: "pointerdown",
-              x: 0,
-              y: 0,
-            })
-            sendPointerEvent({
-              container,
-              identifier: 1,
-              type: "pointerup",
-              x: 0,
-              y: 0,
-            })
-            // await waitFor(1)
-            sendPointerEvent({
-              container,
-              identifier: 2,
-              type: "pointerdown",
-              x: 10,
-              y: 10,
-            })
-            sendPointerEvent({
-              container,
-              identifier: 2,
-              type: "pointerup",
-              x: 10,
-              y: 10,
-            })
-          },
-        }),
-        buffer(waitLongEnough$),
-        first(),
-      ),
-    )
-    expect(values.length).toBe(0)
-  })
-})