@mindees/core 0.4.0 → 0.6.0

package/dist/gesture/recognizers.d.ts

@@ -0,0 +1,133 @@
+//#region src/gesture/recognizers.d.ts
+/**
+ * Gesture recognizers — RN Gesture Handler / Flutter GestureDetector parity, built on the reactive
+ * core. Each factory returns a {@link Recognizer}: a bag of pointer-event handlers to spread onto a
+ * host element, plus REACTIVE state (signals) you read in a `style` accessor or feed to the
+ * animation engine. The only platform-aware code is {@link normalizePointer}; everything else is
+ * pure payload → signal, so it runs on web (Pointer Events), native (the command-backend payload),
+ * and tests (synthetic events), and SSRs safely (no `document` access).
+ *
+ * Attach two recognizers to ONE element via {@link composeGestures} — the renderer binds a single
+ * listener per event name, so spreading two `onPointerMove`s would drop one; compose merges them.
+ *
+ * @module
+ */
+/** A normalized pointer sample (platform differences absorbed by {@link normalizePointer}). */
+interface PointerSample {
+  readonly pointerId: number;
+  readonly x: number;
+  readonly y: number;
+  /** Timestamp in ms. */
+  readonly t: number;
+  readonly pointerType?: string;
+}
+/** @internal Test-only: inject a deterministic clock + timer. */
+declare function _setGestureClock(opts: {
+  now?: () => number;
+  schedule?: (fn: () => void, ms: number) => () => void;
+}): void;
+/** Normalize a host pointer event to a {@link PointerSample}. Web `PointerEvent` or a native payload. */
+declare function normalizePointer(e: unknown): PointerSample;
+/** Handlers to spread onto a host element. */
+interface GestureHandlers {
+  onPointerDown(e: unknown): void;
+  onPointerMove(e: unknown): void;
+  onPointerUp(e: unknown): void;
+  onPointerCancel(e: unknown): void;
+}
+/** A recognizer: handlers to attach, reactive `state`, and a `reset()` for cleanup. */
+interface Recognizer<S = Record<string, () => number | boolean>> {
+  readonly handlers: GestureHandlers;
+  readonly state: S;
+  /** Clear pointers, timers, and reset state to rest (call from `onCleanup`). */
+  reset(): void;
+}
+/** A continuous pan/drag update (translations relative to gesture start; velocity in px/ms). */
+interface PanEvent {
+  readonly translationX: number;
+  readonly translationY: number;
+  readonly velocityX: number;
+  readonly velocityY: number;
+  readonly x: number;
+  readonly y: number;
+}
+interface PanState {
+  readonly active: () => boolean;
+  readonly translationX: () => number;
+  readonly translationY: () => number;
+  readonly velocityX: () => number;
+  readonly velocityY: () => number;
+  readonly x: () => number;
+  readonly y: () => number;
+}
+/** Recognize a drag. Becomes active once the pointer moves past `minDistance` (slop). */
+declare function pan(config: {
+  onBegin?: (e: PanEvent) => void;
+  onUpdate?: (e: PanEvent) => void;
+  onEnd?: (e: PanEvent & {
+    completed: boolean;
+  }) => void;
+  minDistance?: number;
+  axis?: 'both' | 'x' | 'y';
+}): Recognizer<PanState>;
+interface TapState {
+  readonly active: () => boolean;
+}
+/** Recognize a tap: down + up within `maxDistance` and `maxDurationMs`, no extra pointer. */
+declare function tap(config: {
+  onTap?: () => void;
+  maxDistance?: number;
+  maxDurationMs?: number;
+}): Recognizer<TapState>;
+/** Recognize a long press: pointer held past `minDurationMs` without moving past `maxDistance`. */
+declare function longPress(config: {
+  onBegin?: () => void;
+  onLongPress?: () => void;
+  onEnd?: () => void;
+  minDurationMs?: number;
+  maxDistance?: number;
+}): Recognizer<TapState>;
+interface PinchEvent {
+  readonly scale: number;
+  readonly velocity: number;
+  readonly focalX: number;
+  readonly focalY: number;
+}
+interface PinchState {
+  readonly active: () => boolean;
+  readonly scale: () => number;
+  readonly focalX: () => number;
+  readonly focalY: () => number;
+}
+/** Recognize a two-finger pinch. `scale` is current distance / start distance between the pinned pair. */
+declare function pinch(config: {
+  onBegin?: (e: PinchEvent) => void;
+  onUpdate?: (e: PinchEvent) => void;
+  onEnd?: (e: PinchEvent) => void;
+}): Recognizer<PinchState>;
+type SwipeDirection = 'left' | 'right' | 'up' | 'down';
+interface SwipeEvent {
+  readonly direction: SwipeDirection;
+  readonly velocityX: number;
+  readonly velocityY: number;
+  readonly x: number;
+  readonly y: number;
+}
+/** Recognize a fast flick on pointer-up (velocity ≥ `minVelocity` px/ms over `minDistance`). */
+declare function swipe(config: {
+  onSwipe?: (e: SwipeEvent) => void;
+  direction?: 'any' | SwipeDirection;
+  minVelocity?: number;
+  minDistance?: number;
+}): Recognizer<TapState>;
+/**
+ * Merge several recognizers into ONE so they can attach to a single element — required because the
+ * renderer binds a single listener per event name (spreading two `onPointerMove`s would drop one).
+ * `simultaneous` (the default): every recognizer sees every event independently (e.g. pan + pinch
+ * together). Per-recognizer slop already disambiguates tap-vs-pan; an explicit exclusive arena is a
+ * follow-up.
+ */
+declare function composeGestures(recognizers: readonly Recognizer<never>[]): Recognizer<never>;
+//#endregion
+export { GestureHandlers, PanEvent, PanState, PinchEvent, PinchState, PointerSample, Recognizer, SwipeDirection, SwipeEvent, TapState, _setGestureClock, composeGestures, longPress, normalizePointer, pan, pinch, swipe, tap };
+//# sourceMappingURL=recognizers.d.ts.map

package/dist/gesture/recognizers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"recognizers.d.ts","names":[],"sources":["../../src/gesture/recognizers.ts"],"mappings":";;AAiBA;;;;;;;;;;AAMsB;AAWtB;;UAjBiB,aAAA;EAAA,SACN,SAAA;EAAA,SACA,CAAA;EAAA,SACA,CAAA;EAgBG;EAAA,SAdH,CAAA;EAAA,SACA,WAAA;AAAA;AAcV;AAAA,iBAHe,gBAAA,CAAiB,IAAA;EAC/B,GAAA;EACA,QAAA,IAAY,EAAA,cAAgB,EAAA;AAAA;AAO6B;AAAA,iBAA3C,gBAAA,CAAiB,CAAA,YAAa,aAAa;;UAgB1C,eAAA;EACf,aAAA,CAAc,CAAA;EACd,aAAA,CAAc,CAAA;EACd,WAAA,CAAY,CAAA;EACZ,eAAA,CAAgB,CAAA;AAAA;;UAID,UAAA,KAAe,MAAA;EAAA,SACrB,QAAA,EAAU,eAAA;EAAA,SACV,KAAA,EAAO,CAAA;EANU;EAQ1B,KAAA;AAAA;;UAoDe,QAAA;EAAA,SACN,YAAA;EAAA,SACA,YAAA;EAAA,SACA,SAAA;EAAA,SACA,SAAA;EAAA,SACA,CAAA;EAAA,SACA,CAAA;AAAA;AAAA,UAGM,QAAA;EAAA,SACN,MAAA;EAAA,SACA,YAAA;EAAA,SACA,YAAA;EAAA,SACA,SAAA;EAAA,SACA,SAAA;EAAA,SACA,CAAA;EAAA,SACA,CAAA;AAAA;;iBAIK,GAAA,CAAI,MAAA;EAClB,OAAA,IAAW,CAAA,EAAG,QAAA;EACd,QAAA,IAAY,CAAA,EAAG,QAAA;EACf,KAAA,IAAS,CAAA,EAAG,QAAA;IAAa,SAAA;EAAA;EACzB,WAAA;EACA,IAAA;AAAA,IACE,UAAA,CAAW,QAAA;AAAA,UAqHE,QAAA;EAAA,SACN,MAAM;AAAA;;iBAID,GAAA,CAAI,MAAA;EAClB,KAAA;EACA,WAAA;EACA,aAAA;AAAA,IACE,UAAU,CAAC,QAAA;;iBAoDC,SAAA,CAAU,MAAA;EACxB,OAAA;EACA,WAAA;EACA,KAAA;EACA,aAAA;EACA,WAAA;AAAA,IACE,UAAU,CAAC,QAAA;AAAA,UA0DE,UAAA;EAAA,SACN,KAAA;EAAA,SACA,QAAA;EAAA,SACA,MAAA;EAAA,SACA,MAAA;AAAA;AAAA,UAEM,UAAA;EAAA,SACN,MAAA;EAAA,SACA,KAAA;EAAA,SACA,MAAA;EAAA,SACA,MAAA;AAAA;;iBAIK,KAAA,CAAM,MAAA;EACpB,OAAA,IAAW,CAAA,EAAG,UAAA;EACd,QAAA,IAAY,CAAA,EAAG,UAAA;EACf,KAAA,IAAS,CAAA,EAAG,UAAA;AAAA,IACV,UAAA,CAAW,UAAA;AAAA,KAuHH,cAAA;AAAA,UACK,UAAA;EAAA,SACN,SAAA,EAAW,cAAc;EAAA,SACzB,SAAA;EAAA,SACA,SAAA;EAAA,SACA,CAAA;EAAA,SACA,CAAA;AAAA;;iBAIK,KAAA,CAAM,MAAA;EACpB,OAAA,IAAW,CAAA,EAAG,UAAA;EACd,SAAA,WAAoB,cAAA;EACpB,WAAA;EACA,WAAA;AAAA,IACE,UAAA,CAAW,QAAA;;;;;;;AA5QQ;iBA2UP,eAAA,CAAgB,WAAA,WAAsB,UAAA,YAAsB,UAAU"}

package/dist/gesture/recognizers.js

@@ -0,0 +1,507 @@
+import { batch, signal } from "../reactive/reactive.js";
+//#region src/gesture/recognizers.ts
+/**
+* Gesture recognizers — RN Gesture Handler / Flutter GestureDetector parity, built on the reactive
+* core. Each factory returns a {@link Recognizer}: a bag of pointer-event handlers to spread onto a
+* host element, plus REACTIVE state (signals) you read in a `style` accessor or feed to the
+* animation engine. The only platform-aware code is {@link normalizePointer}; everything else is
+* pure payload → signal, so it runs on web (Pointer Events), native (the command-backend payload),
+* and tests (synthetic events), and SSRs safely (no `document` access).
+*
+* Attach two recognizers to ONE element via {@link composeGestures} — the renderer binds a single
+* listener per event name, so spreading two `onPointerMove`s would drop one; compose merges them.
+*
+* @module
+*/
+let nowMs = () => Date.now();
+let scheduleTimer = (fn, ms) => {
+	const id = setTimeout(fn, ms);
+	return () => clearTimeout(id);
+};
+/** @internal Test-only: inject a deterministic clock + timer. */
+function _setGestureClock(opts) {
+	if (opts.now) nowMs = opts.now;
+	if (opts.schedule) scheduleTimer = opts.schedule;
+}
+/** Normalize a host pointer event to a {@link PointerSample}. Web `PointerEvent` or a native payload. */
+function normalizePointer(e) {
+	const ev = e ?? {};
+	const web = "clientX" in ev;
+	const num = (v, d = 0) => typeof v === "number" && Number.isFinite(v) ? v : d;
+	return {
+		pointerId: num(ev.pointerId, 1),
+		x: web ? num(ev.clientX) : num(ev.x),
+		y: web ? num(ev.clientY) : num(ev.y),
+		t: num(web ? ev.timeStamp : ev.timestamp, nowMs()),
+		...typeof (web ? ev.pointerType : ev.type) === "string" ? { pointerType: web ? ev.pointerType : ev.type } : {}
+	};
+}
+const VEL_ALPHA = .6;
+const dist = (ax, ay, bx, by) => Math.hypot(ax - bx, ay - by);
+/** Update a tracked pointer + its EWMA velocity from a new sample. */
+function track(p, s) {
+	const dtMs = s.t - p.lastT;
+	if (dtMs > 0) {
+		p.vx = VEL_ALPHA * ((s.x - p.lastX) / dtMs) + (1 - VEL_ALPHA) * p.vx;
+		p.vy = VEL_ALPHA * ((s.y - p.lastY) / dtMs) + (1 - VEL_ALPHA) * p.vy;
+	}
+	p.lastX = s.x;
+	p.lastY = s.y;
+	p.lastT = s.t;
+	p.x = s.x;
+	p.y = s.y;
+}
+function newTracked(s) {
+	return {
+		startX: s.x,
+		startY: s.y,
+		startT: s.t,
+		x: s.x,
+		y: s.y,
+		lastX: s.x,
+		lastY: s.y,
+		lastT: s.t,
+		vx: 0,
+		vy: 0
+	};
+}
+/** Recognize a drag. Becomes active once the pointer moves past `minDistance` (slop). */
+function pan(config) {
+	const minDistance = config.minDistance ?? 10;
+	const axis = config.axis ?? "both";
+	const pointers = /* @__PURE__ */ new Map();
+	let id = null;
+	let active = false;
+	const active$ = signal(false);
+	const tx$ = signal(0);
+	const ty$ = signal(0);
+	const vx$ = signal(0);
+	const vy$ = signal(0);
+	const x$ = signal(0);
+	const y$ = signal(0);
+	const filt = (dx, dy) => axis === "x" ? [dx, 0] : axis === "y" ? [0, dy] : [dx, dy];
+	const eventFor = (p) => {
+		const [tx, ty] = filt(p.x - p.startX, p.y - p.startY);
+		const [vx, vy] = filt(p.vx, p.vy);
+		return {
+			translationX: tx,
+			translationY: ty,
+			velocityX: vx,
+			velocityY: vy,
+			x: p.x,
+			y: p.y
+		};
+	};
+	const writeFrom = (p) => {
+		const e = eventFor(p);
+		tx$.set(e.translationX);
+		ty$.set(e.translationY);
+		vx$.set(e.velocityX);
+		vy$.set(e.velocityY);
+		x$.set(e.x);
+		y$.set(e.y);
+	};
+	const reset = () => {
+		pointers.clear();
+		id = null;
+		active = false;
+		batch(() => {
+			active$.set(false);
+			tx$.set(0);
+			ty$.set(0);
+			vx$.set(0);
+			vy$.set(0);
+		});
+	};
+	return {
+		state: {
+			active: () => active$(),
+			translationX: () => tx$(),
+			translationY: () => ty$(),
+			velocityX: () => vx$(),
+			velocityY: () => vy$(),
+			x: () => x$(),
+			y: () => y$()
+		},
+		reset,
+		handlers: {
+			onPointerDown(e) {
+				const s = normalizePointer(e);
+				pointers.set(s.pointerId, newTracked(s));
+				if (id === null) id = s.pointerId;
+			},
+			onPointerMove(e) {
+				const s = normalizePointer(e);
+				const p = pointers.get(s.pointerId);
+				if (!p) return;
+				track(p, s);
+				if (s.pointerId !== id) return;
+				const [sx, sy] = filt(p.x - p.startX, p.y - p.startY);
+				const slop = Math.hypot(sx, sy);
+				batch(() => {
+					if (!active && slop >= minDistance) {
+						active = true;
+						active$.set(true);
+						writeFrom(p);
+						config.onBegin?.(eventFor(p));
+					} else if (active) {
+						writeFrom(p);
+						config.onUpdate?.(eventFor(p));
+					}
+				});
+			},
+			onPointerUp(e) {
+				const s = normalizePointer(e);
+				const p = pointers.get(s.pointerId);
+				if (p) track(p, s);
+				if (s.pointerId === id && active && p) config.onEnd?.({
+					...eventFor(p),
+					completed: true
+				});
+				pointers.delete(s.pointerId);
+				if (s.pointerId === id) {
+					id = pointers.keys().next().value ?? null;
+					active = false;
+					active$.set(false);
+				}
+			},
+			onPointerCancel(e) {
+				const s = normalizePointer(e);
+				const p = pointers.get(s.pointerId);
+				if (s.pointerId === id && active && p) config.onEnd?.({
+					...eventFor(p),
+					completed: false
+				});
+				pointers.delete(s.pointerId);
+				if (s.pointerId === id) {
+					id = pointers.keys().next().value ?? null;
+					active = false;
+					active$.set(false);
+				}
+			}
+		}
+	};
+}
+/** Recognize a tap: down + up within `maxDistance` and `maxDurationMs`, no extra pointer. */
+function tap(config) {
+	const maxDistance = config.maxDistance ?? 10;
+	const maxDurationMs = config.maxDurationMs ?? 500;
+	let down = null;
+	let failed = false;
+	const active$ = signal(false);
+	const reset = () => {
+		down = null;
+		failed = false;
+		active$.set(false);
+	};
+	return {
+		state: { active: () => active$() },
+		reset,
+		handlers: {
+			onPointerDown(e) {
+				if (down !== null) {
+					failed = true;
+					return;
+				}
+				down = normalizePointer(e);
+				failed = false;
+				active$.set(true);
+			},
+			onPointerMove(e) {
+				if (!down || failed) return;
+				const s = normalizePointer(e);
+				if (s.pointerId === down.pointerId && dist(s.x, s.y, down.x, down.y) > maxDistance) {
+					failed = true;
+					active$.set(false);
+				}
+			},
+			onPointerUp(e) {
+				const s = normalizePointer(e);
+				if (down && !failed && s.pointerId === down.pointerId) {
+					if (dist(s.x, s.y, down.x, down.y) <= maxDistance && s.t - down.t <= maxDurationMs) config.onTap?.();
+				}
+				if (!down || s.pointerId === down.pointerId) reset();
+			},
+			onPointerCancel(e) {
+				const s = normalizePointer(e);
+				if (!down || s.pointerId === down.pointerId) reset();
+			}
+		}
+	};
+}
+/** Recognize a long press: pointer held past `minDurationMs` without moving past `maxDistance`. */
+function longPress(config) {
+	const minDurationMs = config.minDurationMs ?? 500;
+	const maxDistance = config.maxDistance ?? 10;
+	let down = null;
+	let cancelTimer = null;
+	let fired = false;
+	const active$ = signal(false);
+	const clear = () => {
+		cancelTimer?.();
+		cancelTimer = null;
+	};
+	const reset = () => {
+		clear();
+		down = null;
+		fired = false;
+		active$.set(false);
+	};
+	/** End the press, firing onEnd iff the long-press had fired, then reset. */
+	const finish = () => {
+		if (fired) config.onEnd?.();
+		reset();
+	};
+	return {
+		state: { active: () => active$() },
+		reset,
+		handlers: {
+			onPointerDown(e) {
+				if (down !== null) return;
+				down = normalizePointer(e);
+				fired = false;
+				active$.set(true);
+				config.onBegin?.();
+				cancelTimer = scheduleTimer(() => {
+					fired = true;
+					config.onLongPress?.();
+				}, minDurationMs);
+			},
+			onPointerMove(e) {
+				if (!down) return;
+				const s = normalizePointer(e);
+				if (s.pointerId === down.pointerId && dist(s.x, s.y, down.x, down.y) > maxDistance) finish();
+			},
+			onPointerUp(e) {
+				const s = normalizePointer(e);
+				if (down && s.pointerId === down.pointerId) finish();
+			},
+			onPointerCancel(e) {
+				const s = normalizePointer(e);
+				if (!down || s.pointerId === down.pointerId) finish();
+			}
+		}
+	};
+}
+/** Recognize a two-finger pinch. `scale` is current distance / start distance between the pinned pair. */
+function pinch(config) {
+	const pts = /* @__PURE__ */ new Map();
+	let pair = null;
+	let startDist = 0;
+	let lastScale = 1;
+	let lastT = 0;
+	const active$ = signal(false);
+	const scale$ = signal(1);
+	const fx$ = signal(0);
+	const fy$ = signal(0);
+	const pairPts = () => {
+		if (!pair) return null;
+		const a = pts.get(pair[0]);
+		const b = pts.get(pair[1]);
+		return a && b ? [a, b] : null;
+	};
+	const eventNow = (a, b, t) => {
+		const d = dist(a.x, a.y, b.x, b.y);
+		const scale = startDist > 0 ? d / startDist : 1;
+		const dt = t - lastT;
+		const velocity = dt > 0 ? (scale - lastScale) / dt : 0;
+		lastScale = scale;
+		lastT = t;
+		return {
+			scale,
+			velocity,
+			focalX: (a.x + b.x) / 2,
+			focalY: (a.y + b.y) / 2
+		};
+	};
+	const reset = () => {
+		pts.clear();
+		pair = null;
+		startDist = 0;
+		lastScale = 1;
+		batch(() => {
+			active$.set(false);
+			scale$.set(1);
+			fx$.set(0);
+			fy$.set(0);
+		});
+	};
+	const begin = () => {
+		const pp = pairPts();
+		if (!pp) return;
+		startDist = dist(pp[0].x, pp[0].y, pp[1].x, pp[1].y);
+		lastScale = 1;
+		lastT = Math.max(pp[0].t, pp[1].t);
+		const focalX = (pp[0].x + pp[1].x) / 2;
+		const focalY = (pp[0].y + pp[1].y) / 2;
+		batch(() => {
+			active$.set(true);
+			scale$.set(1);
+			fx$.set(focalX);
+			fy$.set(focalY);
+		});
+		config.onBegin?.({
+			scale: 1,
+			velocity: 0,
+			focalX,
+			focalY
+		});
+	};
+	/** A pointer left: if it was a pinned finger but ≥2 remain, re-pin survivors continuously; else end. */
+	const onLift = (s) => {
+		pts.delete(s.pointerId);
+		if (!active$() || !pair) return;
+		if (!(s.pointerId === pair[0] || s.pointerId === pair[1])) return;
+		if (pts.size >= 2) {
+			const ids = [...pts.keys()];
+			pair = [ids[0], ids[1]];
+			const pp = pairPts();
+			if (pp) {
+				startDist = dist(pp[0].x, pp[0].y, pp[1].x, pp[1].y) / Math.max(scale$(), 1e-4);
+				lastScale = scale$();
+			}
+			return;
+		}
+		config.onEnd?.({
+			scale: scale$(),
+			velocity: 0,
+			focalX: fx$(),
+			focalY: fy$()
+		});
+		reset();
+	};
+	return {
+		state: {
+			active: () => active$(),
+			scale: () => scale$(),
+			focalX: () => fx$(),
+			focalY: () => fy$()
+		},
+		reset,
+		handlers: {
+			onPointerDown(e) {
+				const s = normalizePointer(e);
+				pts.set(s.pointerId, s);
+				if (!pair && pts.size >= 2) {
+					const ids = [...pts.keys()];
+					pair = [ids[0], ids[1]];
+					begin();
+				}
+			},
+			onPointerMove(e) {
+				const s = normalizePointer(e);
+				if (!pts.has(s.pointerId)) return;
+				pts.set(s.pointerId, s);
+				const pp = pairPts();
+				if (!active$() || !pp) return;
+				const ev = eventNow(pp[0], pp[1], s.t);
+				batch(() => {
+					scale$.set(ev.scale);
+					fx$.set(ev.focalX);
+					fy$.set(ev.focalY);
+				});
+				config.onUpdate?.(ev);
+			},
+			onPointerUp(e) {
+				onLift(normalizePointer(e));
+			},
+			onPointerCancel(e) {
+				onLift(normalizePointer(e));
+			}
+		}
+	};
+}
+/** Recognize a fast flick on pointer-up (velocity ≥ `minVelocity` px/ms over `minDistance`). */
+function swipe(config) {
+	const want = config.direction ?? "any";
+	const minVelocity = config.minVelocity ?? .3;
+	const minDistance = config.minDistance ?? 30;
+	const pointers = /* @__PURE__ */ new Map();
+	const active$ = signal(false);
+	const reset = () => {
+		pointers.clear();
+		active$.set(false);
+	};
+	const dominant = (p) => {
+		const dx = p.x - p.startX;
+		const dy = p.y - p.startY;
+		if (Math.abs(dx) >= Math.abs(dy)) return dx >= 0 ? "right" : "left";
+		return dy >= 0 ? "down" : "up";
+	};
+	return {
+		state: { active: () => active$() },
+		reset,
+		handlers: {
+			onPointerDown(e) {
+				const s = normalizePointer(e);
+				pointers.set(s.pointerId, newTracked(s));
+				active$.set(true);
+			},
+			onPointerMove(e) {
+				const s = normalizePointer(e);
+				const p = pointers.get(s.pointerId);
+				if (p) track(p, s);
+			},
+			onPointerUp(e) {
+				const s = normalizePointer(e);
+				const p = pointers.get(s.pointerId);
+				if (p) {
+					track(p, s);
+					const speed = Math.hypot(p.vx, p.vy);
+					const moved = dist(p.x, p.y, p.startX, p.startY);
+					const dir = dominant(p);
+					if (speed >= minVelocity && moved >= minDistance && (want === "any" || want === dir)) config.onSwipe?.({
+						direction: dir,
+						velocityX: p.vx,
+						velocityY: p.vy,
+						x: p.x,
+						y: p.y
+					});
+				}
+				pointers.delete(s.pointerId);
+				if (pointers.size === 0) active$.set(false);
+			},
+			onPointerCancel(e) {
+				const s = normalizePointer(e);
+				pointers.delete(s.pointerId);
+				if (pointers.size === 0) active$.set(false);
+			}
+		}
+	};
+}
+/**
+* Merge several recognizers into ONE so they can attach to a single element — required because the
+* renderer binds a single listener per event name (spreading two `onPointerMove`s would drop one).
+* `simultaneous` (the default): every recognizer sees every event independently (e.g. pan + pinch
+* together). Per-recognizer slop already disambiguates tap-vs-pan; an explicit exclusive arena is a
+* follow-up.
+*/
+function composeGestures(recognizers) {
+	const fan = (key) => (e) => {
+		let firstError;
+		batch(() => {
+			for (const r of recognizers) try {
+				r.handlers[key](e);
+			} catch (err) {
+				if (firstError === void 0) firstError = err;
+			}
+		});
+		if (firstError !== void 0) throw firstError;
+	};
+	return {
+		state: {},
+		reset: () => {
+			for (const r of recognizers) r.reset();
+		},
+		handlers: {
+			onPointerDown: fan("onPointerDown"),
+			onPointerMove: fan("onPointerMove"),
+			onPointerUp: fan("onPointerUp"),
+			onPointerCancel: fan("onPointerCancel")
+		}
+	};
+}
+//#endregion
+export { _setGestureClock, composeGestures, longPress, normalizePointer, pan, pinch, swipe, tap };
+
+//# sourceMappingURL=recognizers.js.map