feat(signal): add specification test code

Author: devphilip21

package.json

@@ -4,8 +4,11 @@
     "postinstall": "[ -n \"$SKIP_POSTINSTALL\" ] || (npx nx build @gesturejs/builder && SKIP_POSTINSTALL=1 pnpm rebuild)"
   },
   "devDependencies": {
+    "@vitest/coverage-v8": "^2.0.0",
+    "jsdom": "^25.0.0",
     "nx": "^22.2",
     "typescript": "^5.9",
-    "vite": "^7.3"
+    "vite": "^7.3",
+    "vitest": "^2.0.0"
   }
 }

packages/signal/package.json

@@ -19,10 +19,10 @@
       "import": "./dist/core/index.js",
       "require": "./dist/core/index.cjs"
     },
-    "./pointer-signal": {
-      "types": "./dist/pointer-signal/index.d.ts",
-      "import": "./dist/pointer-signal/index.js",
-      "require": "./dist/pointer-signal/index.cjs"
+    "./single-pointer": {
+      "types": "./dist/single-pointer/index.d.ts",
+      "import": "./dist/single-pointer/index.js",
+      "require": "./dist/single-pointer/index.cjs"
     }
   },
   "files": [
@@ -38,6 +38,10 @@
     "@gesturejs/stream": "^0.1.0"
   },
   "devDependencies": {
-    "@gesturejs/builder": "workspace:*"
+    "@gesturejs/builder": "workspace:*",
+    "@vitest/coverage-v8": "*",
+    "jsdom": "*",
+    "vite": "*",
+    "vitest": "*"
   }
 }

packages/signal/src/core/pool.spec.ts

@@ -0,0 +1,72 @@
+import { describe, it, expect, vi } from "vitest";
+import { createObjectPool } from "./pool.js";
+
+describe("createObjectPool", () => {
+  const factory = () => ({ value: 0 });
+  const reset = (obj: { value: number }) => {
+    obj.value = 0;
+  };
+
+  it("should pre-allocate objects on creation", () => {
+    const pool = createObjectPool(factory, reset, 5);
+
+    expect(pool.size).toBe(5);
+    expect(pool.active).toBe(0);
+  });
+
+  it("should return object from pool on acquire", () => {
+    const pool = createObjectPool(factory, reset, 3);
+
+    const obj = pool.acquire();
+
+    expect(obj).toEqual({ value: 0 });
+    expect(pool.size).toBe(2);
+    expect(pool.active).toBe(1);
+  });
+
+  it("should create new object when pool is empty", () => {
+    const factorySpy = vi.fn(factory);
+    const pool = createObjectPool(factorySpy, reset, 1);
+
+    pool.acquire();
+    pool.acquire();
+
+    expect(factorySpy).toHaveBeenCalledTimes(2);
+  });
+
+  it("should reset and return object to pool on release", () => {
+    const pool = createObjectPool(factory, reset, 1);
+
+    const obj = pool.acquire();
+    obj.value = 42;
+    pool.release(obj);
+
+    expect(obj.value).toBe(0);
+    expect(pool.size).toBe(1);
+    expect(pool.active).toBe(0);
+  });
+
+  it("should not exceed maxSize on release", () => {
+    const pool = createObjectPool(factory, reset, 0, 2);
+
+    const obj1 = pool.acquire();
+    const obj2 = pool.acquire();
+    const obj3 = pool.acquire();
+
+    pool.release(obj1);
+    pool.release(obj2);
+    pool.release(obj3);
+
+    expect(pool.size).toBe(2);
+  });
+
+  it("should clear all pooled objects", () => {
+    const pool = createObjectPool(factory, reset, 5);
+
+    pool.acquire();
+    pool.clear();
+
+    expect(pool.size).toBe(0);
+    expect(pool.active).toBe(0);
+  });
+});

packages/signal/src/core/signal.spec.ts

@@ -0,0 +1,21 @@
+import { describe, it, expect } from "vitest";
+import { createSignal } from "./signal.js";
+
+describe("createSignal", () => {
+  it("should create signal with type and deviceId", () => {
+    const signal = createSignal("pointer", "mouse-1");
+
+    expect(signal.type).toBe("pointer");
+    expect(signal.deviceId).toBe("mouse-1");
+    expect(typeof signal.timestamp).toBe("number");
+  });
+
+  it("should use performance.now() for timestamp", () => {
+    const before = performance.now();
+    const signal = createSignal("test", "device-1");
+    const after = performance.now();
+
+    expect(signal.timestamp).toBeGreaterThanOrEqual(before);
+    expect(signal.timestamp).toBeLessThanOrEqual(after);
+  });
+});

packages/signal/src/single-pointer/signal.spec.ts

@@ -0,0 +1,64 @@
+import { describe, it, expect } from "vitest";
+import {
+  createDefaultSinglePointer,
+  resetSinglePointer,
+  isSinglePointer,
+} from "./signal.js";
+import type { Signal } from "../core/signal.js";
+
+describe("createDefaultSinglePointer", () => {
+  it("should create pointer with default values", () => {
+    const pointer = createDefaultSinglePointer();
+
+    expect(pointer).toEqual({
+      type: "pointer",
+      timestamp: 0,
+      deviceId: "",
+      phase: "move",
+      x: 0,
+      y: 0,
+      pointerType: "unknown",
+      button: "none",
+      pressure: 0.5,
+    });
+  });
+});
+
+describe("resetSinglePointer", () => {
+  it("should reset pointer to default values", () => {
+    const pointer = createDefaultSinglePointer();
+    pointer.timestamp = 100;
+    pointer.deviceId = "mouse-1";
+    pointer.phase = "start";
+    pointer.x = 150;
+    pointer.y = 200;
+    pointer.pointerType = "mouse";
+    pointer.button = "primary";
+    pointer.pressure = 1.0;
+
+    resetSinglePointer(pointer);
+
+    expect(pointer.timestamp).toBe(0);
+    expect(pointer.deviceId).toBe("");
+    expect(pointer.phase).toBe("move");
+    expect(pointer.x).toBe(0);
+    expect(pointer.y).toBe(0);
+    expect(pointer.pointerType).toBe("unknown");
+    expect(pointer.button).toBe("none");
+    expect(pointer.pressure).toBe(0.5);
+  });
+});
+
+describe("isSinglePointer", () => {
+  it("should return true for pointer type signal", () => {
+    const signal: Signal = { type: "pointer", timestamp: 0, deviceId: "" };
+
+    expect(isSinglePointer(signal)).toBe(true);
+  });
+
+  it("should return false for non-pointer signal", () => {
+    const signal: Signal = { type: "gesture", timestamp: 0, deviceId: "" };
+
+    expect(isSinglePointer(signal)).toBe(false);
+  });
+});

packages/signal/src/single-pointer/types.spec.ts

@@ -0,0 +1,18 @@
+import { describe, it, expect } from "vitest";
+import { toPointerButton } from "./types.js";
+
+describe("toPointerButton", () => {
+  it("should map standard mouse buttons", () => {
+    expect(toPointerButton(-1)).toBe("none");
+    expect(toPointerButton(0)).toBe("primary");
+    expect(toPointerButton(1)).toBe("auxiliary");
+    expect(toPointerButton(2)).toBe("secondary");
+    expect(toPointerButton(3)).toBe("back");
+    expect(toPointerButton(4)).toBe("forward");
+  });
+
+  it("should return 'none' for unknown button numbers", () => {
+    expect(toPointerButton(5)).toBe("none");
+    expect(toPointerButton(99)).toBe("none");
+  });
+});

packages/signal/src/single-pointer/utils.spec.ts

@@ -0,0 +1,89 @@
+import { describe, it, expect } from "vitest";
+import {
+  eventTypeToPhase,
+  normalizePointerType,
+  getButton,
+  getDeviceId,
+} from "./utils.js";
+
+describe("eventTypeToPhase", () => {
+  it("should map start events to 'start'", () => {
+    expect(eventTypeToPhase("pointerdown")).toBe("start");
+    expect(eventTypeToPhase("mousedown")).toBe("start");
+    expect(eventTypeToPhase("touchstart")).toBe("start");
+  });
+
+  it("should map move events to 'move'", () => {
+    expect(eventTypeToPhase("pointermove")).toBe("move");
+    expect(eventTypeToPhase("mousemove")).toBe("move");
+    expect(eventTypeToPhase("touchmove")).toBe("move");
+  });
+
+  it("should map end events to 'end'", () => {
+    expect(eventTypeToPhase("pointerup")).toBe("end");
+    expect(eventTypeToPhase("mouseup")).toBe("end");
+    expect(eventTypeToPhase("touchend")).toBe("end");
+  });
+
+  it("should map cancel events to 'cancel'", () => {
+    expect(eventTypeToPhase("pointercancel")).toBe("cancel");
+    expect(eventTypeToPhase("touchcancel")).toBe("cancel");
+  });
+
+  it("should default to 'move' for unknown events", () => {
+    expect(eventTypeToPhase("unknown")).toBe("move");
+  });
+});
+
+describe("normalizePointerType", () => {
+  it("should normalize known pointer types", () => {
+    expect(normalizePointerType("mouse")).toBe("mouse");
+    expect(normalizePointerType("touch")).toBe("touch");
+    expect(normalizePointerType("pen")).toBe("pen");
+  });
+
+  it("should return 'unknown' for unrecognized types", () => {
+    expect(normalizePointerType("stylus")).toBe("unknown");
+    expect(normalizePointerType("")).toBe("unknown");
+  });
+});
+
+describe("getButton", () => {
+  it("should return 'none' for move events", () => {
+    const event = { type: "pointermove", button: 0 } as PointerEvent;
+
+    expect(getButton(event)).toBe("none");
+  });
+
+  it("should return button type for non-move events", () => {
+    expect(getButton({ type: "pointerdown", button: 0 } as PointerEvent)).toBe(
+      "primary"
+    );
+    expect(getButton({ type: "pointerdown", button: 2 } as PointerEvent)).toBe(
+      "secondary"
+    );
+  });
+});
+
+describe("getDeviceId", () => {
+  it("should return pointer-based id for PointerEvent", () => {
+    const event = {
+      pointerType: "mouse",
+      pointerId: 1,
+    } as PointerEvent;
+
+    expect(getDeviceId(event)).toBe("mouse-1");
+  });
+
+  it("should return 'touch-device' for TouchEvent", () => {
+    const event = { touches: [] } as unknown as TouchEvent;
+
+    expect(getDeviceId(event)).toBe("touch-device");
+  });
+
+  it("should return 'mouse-device' for MouseEvent", () => {
+    const event = {} as MouseEvent;
+
+    expect(getDeviceId(event)).toBe("mouse-device");
+  });
+});

packages/signal/vitest.config.ts

@@ -0,0 +1,15 @@
+import { defineConfig } from "vitest/config";
+
+export default defineConfig({
+  test: {
+    globals: true,
+    environment: "jsdom",
+    include: ["src/**/*.spec.ts"],
+    coverage: {
+      provider: "v8",
+      reporter: ["text", "html"],
+      include: ["src/**/*.ts"],
+      exclude: ["src/**/*.spec.ts"],
+    },
+  },
+});

packages/stream/package.json

@@ -53,9 +53,9 @@
   },
   "devDependencies": {
     "@gesturejs/builder": "workspace:*",
+    "@vitest/coverage-v8": "*",
+    "jsdom": "*",
     "vite": "*",
-    "vitest": "^2.0.0",
-    "jsdom": "^25.0.0",
-    "@vitest/coverage-v8": "^2.0.0"
+    "vitest": "*"
   }
 }