@aethervtt/shard-input 0.0.1 → 0.1.0

package/dist/devices.d.ts

@@ -1,4 +1,4 @@
-import type { MouseButton } from '@aethervtt/shard-platform';
+import type { MouseButton, RawInputEvent } from '@aethervtt/shard-platform';
 /** Pressed/just-pressed/just-released bookkeeping for a set of named buttons. */
 declare class ButtonSet<K extends string> {
     private readonly down;
@@ -74,4 +74,17 @@ export declare class TouchesState {
     /** @internal */
     beginFrame(): void;
 }
+/** A raw event the gesture recognizer reads: a pointer, the wheel, or focus. */
+export type PointerInput = Extract<RawInputEvent, {
+    type: 'pointer' | 'wheel' | 'focus';
+}>;
+/** Pointer events in CSS pixels (0060), for gestures. Mouse and Touches hold the device state. */
+export declare class PointersState {
+    /** This frame's pointer, wheel and focus events, in order. Read-only: they're the raw events. */
+    readonly events: PointerInput[];
+    /** The last pointer position seen, in CSS pixels: where a wheel without one zooms about. */
+    readonly position: [number, number];
+    /** @internal */
+    beginFrame(): void;
+}
 export {};

package/dist/devices.js

@@ -126,6 +126,16 @@ class TouchesState {
     this.ended.length = 0;
   }
 }
+class PointersState {
+  /** This frame's pointer, wheel and focus events, in order. Read-only: they're the raw events. */
+  events = [];
+  /** The last pointer position seen, in CSS pixels: where a wheel without one zooms about. */
+  position = [0, 0];
+  /** @internal */
+  beginFrame() {
+    this.events.length = 0;
+  }
+}
 export {
   GAMEPAD_AXES,
   GAMEPAD_BUTTONS,
@@ -133,5 +143,6 @@ export {
   GamepadsState,
   KeyboardState,
   MouseState,
+  PointersState,
   TouchesState
 };

package/dist/gestures.d.ts

@@ -0,0 +1,226 @@
+import { type World } from '@aethervtt/shard-core';
+import { type MouseButton, type PointerKind, type PointerPolicy, type RawInputEvent } from '@aethervtt/shard-platform';
+import { type Plugin } from '@aethervtt/shard-runtime';
+export type GestureKind = 'tap' | 'double-tap' | 'long-press' | 'drag-start' | 'drag' | 'drag-end' | 'pinch' | 'twist' | 'pan2' | 'wheel';
+export interface GestureEvent {
+    kind: GestureKind;
+    /**
+     * The gesture this event belongs to: a drag's events share it, and so do a two-finger gesture's.
+     * Claims are by id. 0 for the wheel (and a ctrl-wheel pinch), which nothing claims.
+     */
+    id: number;
+    pointer: PointerKind;
+    /** The button the gesture started with ('left' for touch and the wheel). */
+    button: MouseButton;
+    /** `MODIFIERS` bits held when it started (the wheel: when it turned). */
+    modifiers: number;
+    /** Where it is now, in CSS pixels; a two-finger gesture's is the fingers' center. */
+    x: number;
+    y: number;
+    /** Where it started. */
+    startX: number;
+    startY: number;
+    /** Movement since this gesture's previous event (`wheel`: the wheel's, in pixels). */
+    dx: number;
+    dy: number;
+    /** `pinch`: this event's scale factor, above 1 as the fingers spread. 1 otherwise. */
+    scale: number;
+    /** `twist`: this event's turn in radians, clockwise on screen. 0 otherwise. */
+    angle: number;
+    /** `drag-end`: the drag was cancelled (Escape, focus loss, a pointercancel). */
+    cancelled: boolean;
+}
+export declare const Gesture: import("@aethervtt/shard-core").EventDef<GestureEvent>;
+/** Thresholds the recognizer uses. Change them on `world.resource(Gestures).settings`. */
+export interface GestureSettings {
+    /** A press that moves at least this far (CSS px) is a drag. */
+    dragPx: number;
+    /** A second tap within this long and this near the first is a double tap. */
+    doubleTapMs: number;
+    doubleTapPx: number;
+    /** A press held this long without dragging is a long press. */
+    longPressMs: number;
+}
+type TrackState = 'pending' | 'pressed' | 'dragging' | 'two' | 'done';
+interface Track {
+    pointerId: number;
+    gesture: number;
+    pointer: PointerKind;
+    button: MouseButton;
+    modifiers: number;
+    startX: number;
+    startY: number;
+    x: number;
+    y: number;
+    downAt: number;
+    state: TrackState;
+}
+interface TwoFinger {
+    gesture: number;
+    a: Track;
+    b: Track;
+    startX: number;
+    startY: number;
+    x: number;
+    y: number;
+    distance: number;
+    angle: number;
+}
+interface ClaimState {
+    owner: string | undefined;
+    held: number;
+    pointers: number[];
+    ended: boolean;
+}
+/**
+ * The gesture recognizer's state, and who owns which gesture. Consumers read `Gesture` events,
+ * claim the ones they use on their first event (`claim`), and ignore the rest.
+ */
+export declare class GesturesState {
+    readonly settings: GestureSettings;
+    /** @internal */ readonly tracks: Map<number, Track>;
+    /** @internal */ two: TwoFinger | undefined;
+    /** @internal */ readonly claims: Map<number, ClaimState>;
+    /** @internal */ lastTap: {
+        at: number;
+        x: number;
+        y: number;
+        button: MouseButton;
+    } | undefined;
+    /** @internal */ nextId: number;
+    /** @internal */ readonly policies: Map<string, PointerPolicy>;
+    /** @internal */ policyKey: string;
+    /** @internal A policy changed since the source last heard. */
+    policyDirty: boolean;
+    /** @internal */ world: World | undefined;
+    /** @internal Cancels the next frame applies (`cancel()` between frames). */
+    cancelRequested: boolean;
+    /**
+     * Takes gesture `id` for `owner`, from its first event on: its pointers are the scene's (the DOM
+     * source stops their default handling and captures them). False when someone else owns it.
+     */
+    claim(id: number, owner: string): boolean;
+    /**
+     * Takes gesture `id` for `owner` even from another owner (whose next look at `owner(id)` tells
+     * it). PlaneDrag takes a drag a fallback control took while the host was still deciding.
+     */
+    take(id: number, owner: string): boolean;
+    /**
+     * Says a consumer is deciding about gesture `id` (an async pick): fallback consumers (a control
+     * panning on a drag over empty floor) leave it alone until it's claimed or every hold is let go.
+     */
+    hold(id: number): void;
+    /** Lets go of a `hold`, or of a claim `owner` made. */
+    release(id: number, owner?: string): void;
+    /** Who owns gesture `id`, if anyone. */
+    owner(id: number): string | undefined;
+    /** Whether a fallback consumer may claim gesture `id`: it's live, unowned and nobody holds it. */
+    free(id: number): boolean;
+    /**
+     * Where gesture `id`'s pointer is now (a two-finger gesture: the center), in CSS pixels. False
+     * once it ended. A consumer that claims late (after an async pick) catches up from here.
+     */
+    position(id: number, out: {
+        [index: number]: number;
+    }): boolean;
+    /** Whether gesture `id` is still going (its pointers are down). */
+    live(id: number): boolean;
+    /**
+     * Ends every active drag and two-finger gesture, with `drag-end { cancelled: true }` for drags,
+     * at the start of the next frame. Their pointers are ignored until they lift. The `cancel` action
+     * (Escape) calls it.
+     */
+    cancel(): void;
+    /**
+     * What `owner` takes from the pointer while enabled; `undefined` removes it. The DOM source gets
+     * the union of every owner's, so it stops default handling for those and nothing else.
+     */
+    setPolicy(owner: string, policy: PointerPolicy | undefined): void;
+    /** Active pointers, gestures and claims. For agents. */
+    describe(): {
+        settings: {
+            /** A press that moves at least this far (CSS px) is a drag. */
+            dragPx: number;
+            /** A second tap within this long and this near the first is a double tap. */
+            doubleTapMs: number;
+            doubleTapPx: number;
+            /** A press held this long without dragging is a long press. */
+            longPressMs: number;
+        };
+        pointers: {
+            pointer: PointerKind;
+            button: MouseButton;
+            state: TrackState;
+            gesture: number;
+            position: number[];
+        }[];
+        claims: {
+            id: number;
+            owner: string | null;
+            held: boolean;
+        }[];
+        policy: PointerPolicy;
+    };
+    private own;
+}
+export declare const Gestures: import("@aethervtt/shard-core").ResourceDef<GesturesState>;
+/** The built-in `cancel` action: Escape ends a drag. Rebind it with `rebindAction`. */
+export declare const GestureActions: import("./actions.js").ActionMapDef<"cancel">;
+/** Turns this frame's pointer events into gestures, after `input/actions` (for Escape). */
+export declare const updateGestures: import("@aethervtt/shard-core").SystemDef<undefined>;
+/**
+ * Gestures (0060): `Gesture` events from pointers and the wheel, claims, and the `cancel` action
+ * (Escape). Needs `inputPlugin`.
+ */
+export declare const gesturesPlugin: Plugin;
+type Point = readonly [number, number];
+/** A gesture to simulate (`simulateGestures`, the protocol's `input.simulate`), in CSS pixels. */
+export type SimulatedGesture = {
+    drag: {
+        from: Point;
+        to: Point;
+        button?: MouseButton;
+        pointer?: PointerKind;
+        modifiers?: number;
+        /** Frames the move takes. Default 10. */
+        frames?: number;
+        /** Ends with Escape instead of lifting (a cancelled drag). */
+        cancel?: boolean;
+    };
+} | {
+    pinch: {
+        center: Point;
+        /** Distance between the fingers at the start and the end, px. */
+        from: number;
+        to: number;
+        /** Turn over the gesture, radians clockwise. Default 0. */
+        twist?: number;
+        /** The center's movement over the gesture (two-finger pan). Default none. */
+        pan?: Point;
+        frames?: number;
+    };
+} | {
+    wheel: {
+        at: Point;
+        dy: number;
+        dx?: number;
+        modifiers?: number;
+    };
+} | {
+    tap: Point;
+    button?: MouseButton;
+    pointer?: PointerKind;
+} | {
+    wait: number;
+};
+/**
+ * Raw input frames that play `gestures` one after another, a step per frame. Pointers start at
+ * id 1,000,000 so they never collide with a live one.
+ */
+export declare function gestureFrames(gestures: readonly SimulatedGesture[]): RawInputEvent[][];
+/**
+ * Plays gestures through the input stream, a step per frame from the next one on, so gameplay
+ * tests and agents drive controls and drags headless. Returns how many frames they take.
+ */
+export declare function simulateGestures(world: World, gestures: readonly SimulatedGesture[]): number;
+export {};

package/dist/gestures.js

@@ -0,0 +1,535 @@
+import {
+  defineEvent,
+  defineResource,
+  defineSystem,
+  First,
+  ShardError
+} from "@aethervtt/shard-core";
+import {
+  MODIFIERS
+} from "@aethervtt/shard-platform";
+import { definePlugin, FrameDemand, Time } from "@aethervtt/shard-runtime";
+import { defineActions } from "./actions.js";
+import {
+  addActions,
+  InputQueue,
+  Mouse,
+  Pointers,
+  scheduleInput,
+  Touches,
+  updateActions
+} from "./plugin.js";
+const Gesture = defineEvent("input/Gesture", {
+  description: "Taps, long presses, drags, pinches, twists, two-finger pans and the wheel, in CSS pixels (0060)."
+});
+class GesturesState {
+  settings = {
+    dragPx: 4,
+    doubleTapMs: 300,
+    doubleTapPx: 6,
+    longPressMs: 500
+  };
+  /** @internal */
+  tracks = /* @__PURE__ */ new Map();
+  /** @internal */
+  two = void 0;
+  /** @internal */
+  claims = /* @__PURE__ */ new Map();
+  /** @internal */
+  lastTap;
+  /** @internal */
+  nextId = 1;
+  /** @internal */
+  policies = /* @__PURE__ */ new Map();
+  /** @internal */
+  policyKey = "";
+  /** @internal A policy changed since the source last heard. */
+  policyDirty = false;
+  /** @internal */
+  world = void 0;
+  /** @internal Cancels the next frame applies (`cancel()` between frames). */
+  cancelRequested = false;
+  /**
+   * Takes gesture `id` for `owner`, from its first event on: its pointers are the scene's (the DOM
+   * source stops their default handling and captures them). False when someone else owns it.
+   */
+  claim(id, owner) {
+    const c = this.claims.get(id);
+    if (!c || c.ended) return false;
+    if (c.owner !== void 0 && c.owner !== owner) return false;
+    this.own(c, owner);
+    return true;
+  }
+  /**
+   * Takes gesture `id` for `owner` even from another owner (whose next look at `owner(id)` tells
+   * it). PlaneDrag takes a drag a fallback control took while the host was still deciding.
+   */
+  take(id, owner) {
+    const c = this.claims.get(id);
+    if (!c || c.ended) return false;
+    this.own(c, owner);
+    return true;
+  }
+  /**
+   * Says a consumer is deciding about gesture `id` (an async pick): fallback consumers (a control
+   * panning on a drag over empty floor) leave it alone until it's claimed or every hold is let go.
+   */
+  hold(id) {
+    const c = this.claims.get(id);
+    if (c && !c.ended) c.held++;
+  }
+  /** Lets go of a `hold`, or of a claim `owner` made. */
+  release(id, owner) {
+    const c = this.claims.get(id);
+    if (!c) return;
+    if (owner === void 0) c.held = Math.max(0, c.held - 1);
+    else if (c.owner === owner) c.owner = void 0;
+  }
+  /** Who owns gesture `id`, if anyone. */
+  owner(id) {
+    return this.claims.get(id)?.owner;
+  }
+  /** Whether a fallback consumer may claim gesture `id`: it's live, unowned and nobody holds it. */
+  free(id) {
+    const c = this.claims.get(id);
+    return c !== void 0 && !c.ended && c.owner === void 0 && c.held === 0;
+  }
+  /**
+   * Where gesture `id`'s pointer is now (a two-finger gesture: the center), in CSS pixels. False
+   * once it ended. A consumer that claims late (after an async pick) catches up from here.
+   */
+  position(id, out) {
+    for (const t of this.tracks.values()) {
+      if (t.gesture !== id || t.state === "done") continue;
+      out[0] = t.x;
+      out[1] = t.y;
+      return true;
+    }
+    if (this.two?.gesture === id) {
+      out[0] = this.two.x;
+      out[1] = this.two.y;
+      return true;
+    }
+    return false;
+  }
+  /** Whether gesture `id` is still going (its pointers are down). */
+  live(id) {
+    const c = this.claims.get(id);
+    return c !== void 0 && !c.ended;
+  }
+  /**
+   * Ends every active drag and two-finger gesture, with `drag-end { cancelled: true }` for drags,
+   * at the start of the next frame. Their pointers are ignored until they lift. The `cancel` action
+   * (Escape) calls it.
+   */
+  cancel() {
+    this.cancelRequested = true;
+  }
+  /**
+   * What `owner` takes from the pointer while enabled; `undefined` removes it. The DOM source gets
+   * the union of every owner's, so it stops default handling for those and nothing else.
+   */
+  setPolicy(owner, policy) {
+    if (policy) this.policies.set(owner, policy);
+    else if (!this.policies.delete(owner)) return;
+    this.policyDirty = true;
+  }
+  /** Active pointers, gestures and claims. For agents. */
+  describe() {
+    return {
+      settings: { ...this.settings },
+      pointers: [...this.tracks.values()].map((t) => ({
+        pointer: t.pointer,
+        button: t.button,
+        state: t.state,
+        gesture: t.gesture,
+        position: [t.x, t.y]
+      })),
+      claims: [...this.claims].filter(([, c]) => !c.ended).map(([id, c]) => ({ id, owner: c.owner ?? null, held: c.held > 0 })),
+      policy: union(this.policies)
+    };
+  }
+  own(c, owner) {
+    c.owner = owner;
+    const source = this.world?.tryResource(InputQueue)?.source;
+    for (const p of c.pointers) source?.claimPointer?.(p);
+  }
+}
+const Gestures = defineResource("input/Gestures", {
+  description: "Gesture recognizer (0060): thresholds, active pointers, and who claimed which gesture."
+});
+const GestureActions = defineActions(
+  "input/GestureActions",
+  { cancel: { kind: "button", bindings: ["Key:Escape"] } },
+  { context: "any" }
+);
+const BUTTON_ORDER = ["left", "middle", "right", "back", "forward"];
+function union(policies) {
+  const buttons = /* @__PURE__ */ new Set();
+  let wheel2 = false;
+  let touch = false;
+  for (const p of policies.values()) {
+    for (const b of p.buttons) buttons.add(b);
+    wheel2 ||= p.wheel;
+    touch ||= p.touch;
+  }
+  return { buttons: BUTTON_ORDER.filter((b) => buttons.has(b)), wheel: wheel2, touch };
+}
+function send(world, kind, id, t, x, y, startX, startY, dx, dy, scale = 1, angle = 0, cancelled = false) {
+  world.send(Gesture, {
+    kind,
+    id,
+    pointer: t.pointer,
+    button: t.button,
+    modifiers: t.modifiers,
+    x,
+    y,
+    startX,
+    startY,
+    dx,
+    dy,
+    scale,
+    angle,
+    cancelled
+  });
+}
+function endDrag(world, s, t, cancelled) {
+  if (t.state === "dragging")
+    send(world, "drag-end", t.gesture, t, t.x, t.y, t.startX, t.startY, 0, 0, 1, 0, cancelled);
+  end(s, t.gesture);
+}
+function end(s, id) {
+  const c = s.claims.get(id);
+  if (c) c.ended = true;
+}
+function cancelAll(world, s) {
+  for (const t of s.tracks.values()) {
+    if (t.state === "dragging") endDrag(world, s, t, true);
+    else if (t.state !== "done") end(s, t.gesture);
+    t.state = "done";
+  }
+  if (s.two) {
+    end(s, s.two.gesture);
+    s.two = void 0;
+  }
+}
+function startTwo(world, s, a, b) {
+  for (const t of [a, b]) {
+    if (t.state === "dragging") endDrag(world, s, t, false);
+    else end(s, t.gesture);
+    t.state = "two";
+  }
+  const id = s.nextId++;
+  s.claims.set(id, {
+    owner: void 0,
+    held: 0,
+    pointers: [a.pointerId, b.pointerId],
+    ended: false
+  });
+  const x = (a.x + b.x) / 2;
+  const y = (a.y + b.y) / 2;
+  s.two = {
+    gesture: id,
+    a,
+    b,
+    startX: x,
+    startY: y,
+    x,
+    y,
+    distance: Math.sqrt((b.x - a.x) ** 2 + (b.y - a.y) ** 2),
+    angle: Math.atan2(b.y - a.y, b.x - a.x)
+  };
+}
+function moveTwo(world, two) {
+  const { a, b } = two;
+  const x = (a.x + b.x) / 2;
+  const y = (a.y + b.y) / 2;
+  const distance = Math.sqrt((b.x - a.x) ** 2 + (b.y - a.y) ** 2);
+  const angle = Math.atan2(b.y - a.y, b.x - a.x);
+  if (x !== two.x || y !== two.y)
+    send(world, "pan2", two.gesture, a, x, y, two.startX, two.startY, x - two.x, y - two.y);
+  if (distance > 0 && two.distance > 0 && distance !== two.distance)
+    send(
+      world,
+      "pinch",
+      two.gesture,
+      a,
+      x,
+      y,
+      two.startX,
+      two.startY,
+      0,
+      0,
+      distance / two.distance
+    );
+  let turn = angle - two.angle;
+  if (turn > Math.PI) turn -= 2 * Math.PI;
+  else if (turn < -Math.PI) turn += 2 * Math.PI;
+  if (turn !== 0) send(world, "twist", two.gesture, a, x, y, two.startX, two.startY, 0, 0, 1, turn);
+  two.x = x;
+  two.y = y;
+  two.distance = distance;
+  two.angle = angle;
+}
+function down(world, s, e, now, ui) {
+  const old = s.tracks.get(e.id);
+  if (old) up(world, s, old, now, true);
+  const id = s.nextId++;
+  const t = {
+    pointerId: e.id,
+    gesture: id,
+    pointer: e.pointer,
+    button: e.pointer === "touch" ? "left" : e.button,
+    modifiers: e.modifiers,
+    startX: e.x,
+    startY: e.y,
+    x: e.x,
+    y: e.y,
+    downAt: now,
+    state: "pending"
+  };
+  s.tracks.set(e.id, t);
+  s.claims.set(id, { owner: ui ? "ui" : void 0, held: 0, pointers: [e.id], ended: false });
+  if (e.pointer !== "touch") return;
+  let touching = 0;
+  let other;
+  for (const u of s.tracks.values()) {
+    if (u.pointer !== "touch") continue;
+    touching++;
+    if (u !== t && u.state !== "done") other = u;
+  }
+  if (touching === 2 && other && !s.two) startTwo(world, s, other, t);
+  else if (touching > 2) t.state = "done";
+}
+function move(world, s, t, x, y) {
+  const dx = x - t.x;
+  const dy = y - t.y;
+  t.x = x;
+  t.y = y;
+  if (t.state === "two") {
+    if (s.two && (s.two.a === t || s.two.b === t)) moveTwo(world, s.two);
+    return;
+  }
+  if (t.state === "dragging") {
+    send(world, "drag", t.gesture, t, x, y, t.startX, t.startY, dx, dy);
+    return;
+  }
+  if (t.state !== "pending" && t.state !== "pressed") return;
+  const ox = x - t.startX;
+  const oy = y - t.startY;
+  if (ox * ox + oy * oy < s.settings.dragPx * s.settings.dragPx) return;
+  t.state = "dragging";
+  send(world, "drag-start", t.gesture, t, x, y, t.startX, t.startY, ox, oy);
+}
+function up(world, s, t, now, cancelled) {
+  s.tracks.delete(t.pointerId);
+  if (t.state === "dragging") {
+    endDrag(world, s, t, cancelled);
+    return;
+  }
+  if (t.state === "two") {
+    const two = s.two;
+    if (two && (two.a === t || two.b === t)) {
+      end(s, two.gesture);
+      const rest = two.a === t ? two.b : two.a;
+      rest.state = "done";
+      s.two = void 0;
+    }
+    end(s, t.gesture);
+    return;
+  }
+  end(s, t.gesture);
+  if (t.state !== "pending" || cancelled) return;
+  send(world, "tap", t.gesture, t, t.x, t.y, t.startX, t.startY, 0, 0);
+  const last = s.lastTap;
+  const { doubleTapMs, doubleTapPx } = s.settings;
+  if (last && last.button === t.button && now - last.at <= doubleTapMs && (t.x - last.x) ** 2 + (t.y - last.y) ** 2 <= doubleTapPx * doubleTapPx) {
+    send(world, "double-tap", t.gesture, t, t.x, t.y, t.startX, t.startY, 0, 0);
+    s.lastTap = void 0;
+  } else {
+    s.lastTap = { at: now, x: t.x, y: t.y, button: t.button };
+  }
+}
+const WHEEL = { pointer: "mouse", button: "left", modifiers: 0 };
+function wheel(world, e, fx, fy) {
+  const x = e.x ?? fx;
+  const y = e.y ?? fy;
+  WHEEL.modifiers = e.modifiers ?? 0;
+  if ((WHEEL.modifiers & MODIFIERS.ctrl) !== 0)
+    send(world, "pinch", 0, WHEEL, x, y, x, y, 0, 0, Math.exp(-e.dy * 0.01));
+  else send(world, "wheel", 0, WHEEL, x, y, x, y, e.dx, e.dy);
+}
+function onUi(world, e) {
+  if (e.pointer === "touch") return world.tryResource(Touches)?.captured.has(e.id) ?? false;
+  return world.tryResource(Mouse)?.captured ?? false;
+}
+function apply(world, s, e, now, fx, fy) {
+  if (e.type === "wheel") {
+    wheel(world, e, fx, fy);
+    return;
+  }
+  if (e.type === "focus") {
+    if (!e.focused) {
+      cancelAll(world, s);
+      s.tracks.clear();
+    }
+    return;
+  }
+  if (e.phase === "down") {
+    down(world, s, e, now, onUi(world, e));
+    return;
+  }
+  const t = s.tracks.get(e.id);
+  if (!t) return;
+  if (e.phase === "move") move(world, s, t, e.x, e.y);
+  else {
+    if (e.x !== t.x || e.y !== t.y) move(world, s, t, e.x, e.y);
+    up(world, s, t, now, e.phase === "cancel");
+  }
+}
+const updateGestures = defineSystem({
+  name: "input/gestures",
+  description: "Recognizes taps, presses, drags and two-finger gestures from pointer events.",
+  run: (_, world) => {
+    const s = world.resource(Gestures);
+    if (s.claims.size > 0) {
+      for (const [id, c] of s.claims) if (c.ended) s.claims.delete(id);
+    }
+    const now = world.resource(Time).elapsed * 1e3;
+    const actions = world.tryResource(GestureActions.resource);
+    if (s.cancelRequested) {
+      s.cancelRequested = false;
+      cancelAll(world, s);
+    }
+    const pointers = world.resource(Pointers);
+    const fx = pointers.position[0];
+    const fy = pointers.position[1];
+    for (const e of pointers.events) apply(world, s, e, now, fx, fy);
+    if (actions?.justPressed("cancel")) cancelAll(world, s);
+    let soonest = Number.POSITIVE_INFINITY;
+    if (s.tracks.size > 0)
+      for (const t of s.tracks.values()) {
+        if (t.state !== "pending") continue;
+        const left = t.downAt + s.settings.longPressMs - now;
+        if (left <= 0) {
+          t.state = "pressed";
+          send(world, "long-press", t.gesture, t, t.x, t.y, t.startX, t.startY, 0, 0);
+        } else if (left < soonest) soonest = left;
+      }
+    if (soonest !== Number.POSITIVE_INFINITY) world.resource(FrameDemand).after(soonest);
+    syncPolicy(world, s);
+  }
+});
+function syncPolicy(world, s) {
+  if (!s.policyDirty) return;
+  s.policyDirty = false;
+  const policy = union(s.policies);
+  const key = `${policy.buttons.join(",")}|${policy.wheel}|${policy.touch}`;
+  if (key === s.policyKey) return;
+  s.policyKey = key;
+  world.resource(InputQueue).source?.setPointerPolicy?.(policy);
+}
+const gesturesPlugin = definePlugin({
+  name: "input/gestures",
+  dependencies: ["input"],
+  provides: [Gestures, Gesture, GestureActions.resource, updateGestures],
+  build(app) {
+    const state = new GesturesState();
+    state.world = app.world;
+    app.insertResource(Gestures, state);
+    addActions(app.world, GestureActions);
+    app.addSystems(First, updateGestures.after(updateActions));
+  }
+});
+const SIM_ID = 1e6;
+function gestureFrames(gestures) {
+  const frames = [];
+  let id = SIM_ID;
+  const p = (pid, phase, x, y, pointer = "mouse", button = "left", modifiers = 0) => ({ type: "pointer", id: pid, phase, pointer, button, x, y, modifiers });
+  for (const g of gestures) {
+    if ("drag" in g) {
+      const d = g.drag;
+      const n = Math.max(1, d.frames ?? 10);
+      const pid = id++;
+      const kind = d.pointer ?? "mouse";
+      const button = d.button ?? "left";
+      frames.push([p(pid, "down", d.from[0], d.from[1], kind, button, d.modifiers)]);
+      for (let i = 1; i <= n; i++) {
+        const t = i / n;
+        const x = d.from[0] + (d.to[0] - d.from[0]) * t;
+        const y = d.from[1] + (d.to[1] - d.from[1]) * t;
+        frames.push([p(pid, "move", x, y, kind, button, d.modifiers)]);
+      }
+      if (d.cancel) {
+        frames.push([{ type: "key", code: "Escape", pressed: true }]);
+        frames.push([{ type: "key", code: "Escape", pressed: false }]);
+      }
+      frames.push([p(pid, "up", d.to[0], d.to[1], kind, button, d.modifiers)]);
+    } else if ("pinch" in g) {
+      const q = g.pinch;
+      const n = Math.max(1, q.frames ?? 10);
+      const a = id++;
+      const b = id++;
+      const at = (t) => {
+        const r = (q.from + (q.to - q.from) * t) / 2;
+        const turn = (q.twist ?? 0) * t;
+        const cx = q.center[0] + (q.pan?.[0] ?? 0) * t;
+        const cy = q.center[1] + (q.pan?.[1] ?? 0) * t;
+        const c = Math.cos(turn) * r;
+        const s = Math.sin(turn) * r;
+        return [cx - c, cy - s, cx + c, cy + s];
+      };
+      const start = at(0);
+      frames.push([
+        p(a, "down", start[0], start[1], "touch"),
+        p(b, "down", start[2], start[3], "touch")
+      ]);
+      for (let i = 1; i <= n; i++) {
+        const f = at(i / n);
+        frames.push([p(a, "move", f[0], f[1], "touch"), p(b, "move", f[2], f[3], "touch")]);
+      }
+      const end2 = at(1);
+      frames.push([p(a, "up", end2[0], end2[1], "touch"), p(b, "up", end2[2], end2[3], "touch")]);
+    } else if ("wheel" in g) {
+      const w = g.wheel;
+      frames.push([
+        {
+          type: "wheel",
+          dx: w.dx ?? 0,
+          dy: w.dy,
+          x: w.at[0],
+          y: w.at[1],
+          modifiers: w.modifiers ?? 0
+        }
+      ]);
+    } else if ("tap" in g) {
+      const pid = id++;
+      const kind = g.pointer ?? "mouse";
+      const button = g.button ?? "left";
+      frames.push([p(pid, "down", g.tap[0], g.tap[1], kind, button)]);
+      frames.push([p(pid, "up", g.tap[0], g.tap[1], kind, button)]);
+    } else if ("wait" in g) {
+      for (let i = 0; i < g.wait; i++) frames.push([]);
+    } else {
+      throw new ShardError("input/unknown-gesture", `Can't simulate ${JSON.stringify(g)}`, {
+        hint: "Simulate { drag }, { pinch }, { wheel }, { tap } or { wait }."
+      });
+    }
+  }
+  return frames;
+}
+function simulateGestures(world, gestures) {
+  const frames = gestureFrames(gestures);
+  scheduleInput(world, frames);
+  return frames.length;
+}
+export {
+  Gesture,
+  GestureActions,
+  Gestures,
+  GesturesState,
+  gestureFrames,
+  gesturesPlugin,
+  simulateGestures,
+  updateGestures
+};

package/dist/index.d.ts

@@ -1,4 +1,5 @@
 export { type ActionDef, type ActionMapDef, ActionState, type Axis1dAction, type Axis2dAction, actionMapSchema, type ButtonAction, defineActions, type Interaction, } from './actions.js';
 export { type ParsedBinding, parseBinding } from './bindings.js';
-export { GAMEPAD_AXES, GAMEPAD_BUTTONS, type GamepadAxis, type GamepadButton, GamepadState, GamepadsState, KeyboardState, MouseState, type Touch, TouchesState, } from './devices.js';
-export { addActions, describeInput, Gamepads, type InjectedInput, InputContext, type InputContextValue, type InputPluginOptions, InputQueue, injectInput, inputPlugin, Keyboard, Mouse, rebindAction, startRecording, startReplay, stopRecording, Touches, updateActions, updateInput, } from './plugin.js';
+export { GAMEPAD_AXES, GAMEPAD_BUTTONS, type GamepadAxis, type GamepadButton, GamepadState, GamepadsState, KeyboardState, MouseState, type PointerInput, PointersState, type Touch, TouchesState, } from './devices.js';
+export { Gesture, GestureActions, type GestureEvent, type GestureKind, type GestureSettings, Gestures, GesturesState, gestureFrames, gesturesPlugin, type SimulatedGesture, simulateGestures, updateGestures, } from './gestures.js';
+export { addActions, describeInput, Gamepads, type InjectedInput, InputContext, type InputContextValue, type InputPluginOptions, InputQueue, injectInput, inputPlugin, Keyboard, Mouse, Pointers, rebindAction, scheduleInput, startRecording, startReplay, stopRecording, Touches, updateActions, updateInput, } from './plugin.js';

package/dist/index.js

@@ -11,8 +11,19 @@ import {
   GamepadsState,
   KeyboardState,
   MouseState,
+  PointersState,
   TouchesState
 } from "./devices.js";
+import {
+  Gesture,
+  GestureActions,
+  Gestures,
+  GesturesState,
+  gestureFrames,
+  gesturesPlugin,
+  simulateGestures,
+  updateGestures
+} from "./gestures.js";
 import {
   addActions,
   describeInput,
@@ -23,7 +34,9 @@ import {
   inputPlugin,
   Keyboard,
   Mouse,
+  Pointers,
   rebindAction,
+  scheduleInput,
   startRecording,
   startReplay,
   stopRecording,
@@ -38,25 +51,36 @@ export {
   GamepadState,
   Gamepads,
   GamepadsState,
+  Gesture,
+  GestureActions,
+  Gestures,
+  GesturesState,
   InputContext,
   InputQueue,
   Keyboard,
   KeyboardState,
   Mouse,
   MouseState,
+  Pointers,
+  PointersState,
   Touches,
   TouchesState,
   actionMapSchema,
   addActions,
   defineActions,
   describeInput,
+  gestureFrames,
+  gesturesPlugin,
   injectInput,
   inputPlugin,
   parseBinding,
   rebindAction,
+  scheduleInput,
+  simulateGestures,
   startRecording,
   startReplay,
   stopRecording,
   updateActions,
+  updateGestures,
   updateInput
 };

package/dist/plugin.d.ts

@@ -2,11 +2,12 @@ import { type World } from '@aethervtt/shard-core';
 import type { InputSource, RawInputEvent } from '@aethervtt/shard-platform';
 import { type Plugin } from '@aethervtt/shard-runtime';
 import type { ActionMapDef, ActionState } from './actions.js';
-import { GamepadsState, KeyboardState, MouseState, TouchesState } from './devices.js';
+import { GamepadsState, KeyboardState, MouseState, PointersState, TouchesState } from './devices.js';
 export declare const Keyboard: import("@aethervtt/shard-core").ResourceDef<KeyboardState>;
 export declare const Mouse: import("@aethervtt/shard-core").ResourceDef<MouseState>;
 export declare const Gamepads: import("@aethervtt/shard-core").ResourceDef<GamepadsState>;
 export declare const Touches: import("@aethervtt/shard-core").ResourceDef<TouchesState>;
+export declare const Pointers: import("@aethervtt/shard-core").ResourceDef<PointersState>;
 interface InputQueueState {
     source: InputSource | undefined;
     /** Injected events, applied at the start of the next frame. */
@@ -21,6 +22,8 @@ interface InputQueueState {
         frame: number;
         length: number;
     } | undefined;
+    /** Simulated input still to come (`simulateInput`), one entry per frame, merged with live input. */
+    scheduled: RawInputEvent[][];
 }
 export declare const InputQueue: import("@aethervtt/shard-core").ResourceDef<InputQueueState>;
 export interface InputPluginOptions {
@@ -66,6 +69,11 @@ export type InjectedInput = RawInputEvent | {
  * input (so it's recorded and replayed too). Actions are named `"<map>.<action>"`.
  */
 export declare function injectInput(world: World, input: InjectedInput): void;
+/**
+ * Queues raw input over the next frames, one entry per frame (empty entries wait a frame),
+ * after anything already queued. Gesture simulation (`simulateGestures`) builds on it.
+ */
+export declare function scheduleInput(world: World, frames: readonly (readonly RawInputEvent[])[]): void;
 export declare function startRecording(world: World): void;
 /** Stops recording and returns it as JSON lines: `{"f":<frame>,"e":[...events]}` per non-empty frame. */
 export declare function stopRecording(world: World): string;
@@ -79,6 +87,7 @@ export declare function describeInput(world: World): {
     keysHeld: string[];
     gamepads: number;
     touches: number;
+    scheduledFrames: number;
     context: string;
     pointerCaptured: boolean;
     actionMaps: {

package/dist/plugin.js

@@ -1,11 +1,12 @@
 import { defineResource, defineSystem, First, ShardError } from "@aethervtt/shard-core";
-import { definePlugin, Time } from "@aethervtt/shard-runtime";
+import { definePlugin, FrameDemand, Time } from "@aethervtt/shard-runtime";
 import {
   GAMEPAD_AXES,
   GAMEPAD_BUTTONS,
   GamepadsState,
   KeyboardState,
   MouseState,
+  PointersState,
   TouchesState
 } from "./devices.js";
 import * as pluginModule from "./plugin.js";
@@ -21,6 +22,9 @@ const Gamepads = defineResource("input/Gamepads", {
 const Touches = defineResource("input/Touches", {
   description: "Active touches."
 });
+const Pointers = defineResource("input/Pointers", {
+  description: "This frame's pointer and wheel events in CSS pixels, for gestures (0060)."
+});
 const InputQueue = defineResource("input/Queue", {
   description: "Raw input buffer: live source, injected events, recording, replay."
 });
@@ -32,6 +36,15 @@ function devices(world) {
     touches: world.resource(Touches)
   };
 }
+function pointers(world, e) {
+  if (e.type !== "pointer" && e.type !== "wheel" && e.type !== "focus") return;
+  const p = world.resource(Pointers);
+  p.events.push(e);
+  if (e.type === "pointer") {
+    p.position[0] = e.x;
+    p.position[1] = e.y;
+  }
+}
 function apply(world, d, e) {
   switch (e.type) {
     case "key":
@@ -84,6 +97,8 @@ function apply(world, d, e) {
       }
       break;
     }
+    case "pointer":
+      break;
     case "focus":
       if (!e.focused) {
         d.keyboard.releaseAll();
@@ -124,6 +139,7 @@ const updateInput = defineSystem({
     d.mouse.beginFrame();
     d.gamepads.beginFrame();
     d.touches.beginFrame();
+    world.resource(Pointers).beginFrame();
     const events = q.scratch;
     events.length = 0;
     if (q.replay) {
@@ -136,7 +152,14 @@ const updateInput = defineSystem({
     }
     for (const e of q.pending) events.push(e);
     q.pending.length = 0;
-    for (const e of events) apply(world, d, e);
+    if (q.scheduled.length > 0) {
+      for (const e of q.scheduled.shift()) events.push(e);
+      world.resource(FrameDemand).set(SIMULATE_DEMAND, q.scheduled.length > 0);
+    }
+    for (const e of events) {
+      apply(world, d, e);
+      pointers(world, e);
+    }
     if (q.recording) q.recording.push(events.map((e) => ({ ...e })));
   }
 });
@@ -152,6 +175,7 @@ const updateActions = defineSystem({
   }
 });
 function inputPlugin(options = {}) {
+  let unsubscribe;
   return definePlugin({
     name: "input",
     provides: [pluginModule],
@@ -163,12 +187,23 @@ function inputPlugin(options = {}) {
         scratch: [],
         maps: [],
         recording: void 0,
-        replay: void 0
+        replay: void 0,
+        scheduled: []
       };
-      app.insertResource(Keyboard, new KeyboardState()).insertResource(Mouse, new MouseState()).insertResource(Gamepads, new GamepadsState()).insertResource(Touches, new TouchesState()).insertResource(InputQueue, queue);
+      app.insertResource(Keyboard, new KeyboardState()).insertResource(Mouse, new MouseState()).insertResource(Gamepads, new GamepadsState()).insertResource(Touches, new TouchesState()).insertResource(Pointers, new PointersState()).insertResource(InputQueue, queue);
       app.world.initResource(InputContext);
       for (const map of options.actions ?? []) addActions(app.world, map);
       app.addSystems(First, updateInput, updateActions.after(updateInput));
+      unsubscribe = options.source?.onInput?.(() => {
+        if (!app.disposed) app.requestFrame();
+      });
+    },
+    dispose(app) {
+      unsubscribe?.();
+      unsubscribe = void 0;
+      const queue = app.world.tryResource(InputQueue);
+      queue?.source?.dispose();
+      if (queue) queue.source = void 0;
     }
   });
 }
@@ -206,6 +241,12 @@ function injectInput(world, input) {
       value: input.value
     });
 }
+const SIMULATE_DEMAND = "input/simulate";
+function scheduleInput(world, frames) {
+  const q = world.resource(InputQueue);
+  for (const frame of frames) q.scheduled.push([...frame]);
+  if (q.scheduled.length > 0) world.resource(FrameDemand).hold(SIMULATE_DEMAND);
+}
 function startRecording(world) {
   world.resource(InputQueue).recording = [];
 }
@@ -238,6 +279,7 @@ function describeInput(world) {
     keysHeld: world.resource(Keyboard).held(),
     gamepads: world.resource(Gamepads).connected().length,
     touches: world.resource(Touches).active.size,
+    scheduledFrames: q.scheduled.length,
     context: world.resource(InputContext).active,
     pointerCaptured: world.resource(Mouse).captured,
     actionMaps: q.maps.map((m) => ({
@@ -256,12 +298,14 @@ export {
   InputQueue,
   Keyboard,
   Mouse,
+  Pointers,
   Touches,
   addActions,
   describeInput,
   injectInput,
   inputPlugin,
   rebindAction,
+  scheduleInput,
   startRecording,
   startReplay,
   stopRecording,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aethervtt/shard-input",
-  "version": "0.0.1",
+  "version": "0.1.0",
   "license": "MIT",
   "type": "module",
   "sideEffects": false,
@@ -16,9 +16,9 @@
     "README.md"
   ],
   "dependencies": {
-    "@aethervtt/shard-core": "0.0.1",
-    "@aethervtt/shard-platform": "0.0.1",
-    "@aethervtt/shard-runtime": "0.0.1"
+    "@aethervtt/shard-core": "0.1.0",
+    "@aethervtt/shard-platform": "0.1.0",
+    "@aethervtt/shard-runtime": "0.1.0"
   },
   "repository": {
     "type": "git",
@@ -30,6 +30,6 @@
     "provenance": true
   },
   "shard": {
-    "buildSha": "d6c5c6aef4675575c878b02cf2c8f738b4190229"
+    "buildSha": "8e14c9896f82a3554b156f1ffdd68f2cc3e7d78a"
   }
 }