@flare-engine/input 0.2.1 → 0.3.0

package/dist/index.js

@@ -1,595 +1,771 @@
-"use strict";
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+let _flare_engine_events = require("@flare-engine/events");
+//#region src/gamepad.ts
+/**
+* Gamepad — poll-based state for a single connected controller.
+*
+* Buttons and axes are indexed against the W3C "Standard Gamepad" mapping by
+* default. Callers can translate raw indices via `remap.ts` before feeding
+* snapshots into `updateGamepadFromSnapshot`.
+*/
+/** W3C Standard Gamepad button indices. */
+const GamepadButton = {
+	A: 0,
+	B: 1,
+	X: 2,
+	Y: 3,
+	LB: 4,
+	RB: 5,
+	LT: 6,
+	RT: 7,
+	Back: 8,
+	Start: 9,
+	LS: 10,
+	RS: 11,
+	DpadUp: 12,
+	DpadDown: 13,
+	DpadLeft: 14,
+	DpadRight: 15,
+	Home: 16
 };
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-
-// src/index.ts
-var index_exports = {};
-__export(index_exports, {
-  GamepadAxis: () => GamepadAxis,
-  GamepadButton: () => GamepadButton,
-  GestureDetector: () => GestureDetector,
-  InputManager: () => InputManager,
-  applyRemap: () => applyRemap,
-  createButtonState: () => createButtonState,
-  createGamepadState: () => createGamepadState,
-  createIdentityRemap: () => createIdentityRemap,
-  createJoystickState: () => createJoystickState,
-  createPointer: () => createPointer,
-  createWebGamepadSource: () => createWebGamepadSource,
-  getAxis: () => getAxis,
-  isButtonDown: () => isButtonDown,
-  loadRemap: () => loadRemap,
-  pointerDown: () => pointerDown,
-  pointerMove: () => pointerMove,
-  pointerUp: () => pointerUp,
-  pressButton: () => pressButton,
-  releaseButton: () => releaseButton,
-  releaseJoystick: () => releaseJoystick,
-  resetButtonFrame: () => resetButtonFrame,
-  resetGamepadFrame: () => resetGamepadFrame,
-  resetPointerFrame: () => resetPointerFrame,
-  saveRemap: () => saveRemap,
-  updateGamepadFromSnapshot: () => updateGamepadFromSnapshot,
-  updateJoystick: () => updateJoystick,
-  wasButtonPressed: () => wasButtonPressed,
-  wasButtonReleased: () => wasButtonReleased
-});
-module.exports = __toCommonJS(index_exports);
-
-// src/pointer.ts
-function createPointer() {
-  return {
-    position: { x: 0, y: 0 },
-    delta: { x: 0, y: 0 },
-    isDown: false,
-    justPressed: false,
-    justReleased: false
-  };
-}
-function resetPointerFrame(pointer) {
-  pointer.delta.x = 0;
-  pointer.delta.y = 0;
-  pointer.justPressed = false;
-  pointer.justReleased = false;
-}
-function pointerDown(pointer, x, y) {
-  const wasDown = pointer.isDown;
-  pointer.isDown = true;
-  if (!wasDown) {
-    pointer.justPressed = true;
-  }
-  pointer.delta.x = x - pointer.position.x;
-  pointer.delta.y = y - pointer.position.y;
-  pointer.position.x = x;
-  pointer.position.y = y;
-}
-function pointerMove(pointer, x, y) {
-  pointer.delta.x = x - pointer.position.x;
-  pointer.delta.y = y - pointer.position.y;
-  pointer.position.x = x;
-  pointer.position.y = y;
-}
-function pointerUp(pointer, x, y) {
-  pointer.isDown = false;
-  pointer.justReleased = true;
-  pointer.delta.x = x - pointer.position.x;
-  pointer.delta.y = y - pointer.position.y;
-  pointer.position.x = x;
-  pointer.position.y = y;
-}
-
-// src/gamepad.ts
-var GamepadButton = {
-  A: 0,
-  B: 1,
-  X: 2,
-  Y: 3,
-  LB: 4,
-  RB: 5,
-  LT: 6,
-  RT: 7,
-  Back: 8,
-  Start: 9,
-  LS: 10,
-  RS: 11,
-  DpadUp: 12,
-  DpadDown: 13,
-  DpadLeft: 14,
-  DpadRight: 15,
-  Home: 16
-};
-var GamepadAxis = {
-  LeftX: 0,
-  LeftY: 1,
-  RightX: 2,
-  RightY: 3
+/** W3C Standard Gamepad axes. */
+const GamepadAxis = {
+	LeftX: 0,
+	LeftY: 1,
+	RightX: 2,
+	RightY: 3
 };
 function createGamepadState(index = 0, buttonCount = 17, axisCount = 4) {
-  const buttons = new Array(buttonCount);
-  for (let i = 0; i < buttonCount; i++) {
-    buttons[i] = { pressed: false, value: 0, pressedThisFrame: false, releasedThisFrame: false };
-  }
-  const axes = new Array(axisCount).fill(0);
-  return { connected: false, id: "", index, buttons, axes, timestamp: 0 };
+	const buttons = new Array(buttonCount);
+	for (let i = 0; i < buttonCount; i++) buttons[i] = {
+		pressed: false,
+		value: 0,
+		pressedThisFrame: false,
+		releasedThisFrame: false
+	};
+	return {
+		connected: false,
+		id: "",
+		index,
+		buttons,
+		axes: new Array(axisCount).fill(0),
+		timestamp: 0
+	};
 }
 function applyDeadZone(value, deadZone) {
-  const abs = Math.abs(value);
-  if (abs <= deadZone) return 0;
-  const sign = value < 0 ? -1 : 1;
-  return sign * ((abs - deadZone) / (1 - deadZone));
+	const abs = Math.abs(value);
+	if (abs <= deadZone) return 0;
+	return (value < 0 ? -1 : 1) * ((abs - deadZone) / (1 - deadZone));
 }
+/**
+* Apply a fresh snapshot to an existing `GamepadState` in place. Derived
+* `pressedThisFrame` / `releasedThisFrame` flags are recomputed from the
+* previous `pressed` value.
+*
+* `deadZone` in [0, 1). Values at or below are treated as 0.
+*/
 function updateGamepadFromSnapshot(state, snapshot, deadZone = 0) {
-  if (snapshot === null) {
-    if (!state.connected && !anyButtonDown(state)) {
-      clearFrameFlags(state);
-      return;
-    }
-    for (let i = 0; i < state.buttons.length; i++) {
-      const b = state.buttons[i];
-      if (!b) continue;
-      b.pressedThisFrame = false;
-      b.releasedThisFrame = b.pressed;
-      b.pressed = false;
-      b.value = 0;
-    }
-    for (let i = 0; i < state.axes.length; i++) state.axes[i] = 0;
-    state.connected = false;
-    state.id = "";
-    return;
-  }
-  state.connected = true;
-  state.id = snapshot.id;
-  state.index = snapshot.index;
-  state.timestamp = snapshot.timestamp;
-  const srcButtons = snapshot.buttons;
-  const bLen = Math.min(state.buttons.length, srcButtons.length);
-  for (let i = 0; i < bLen; i++) {
-    const prev = state.buttons[i];
-    const src = srcButtons[i];
-    if (!prev || !src) continue;
-    const wasPressed = prev.pressed;
-    prev.pressed = src.pressed;
-    prev.value = src.value;
-    prev.pressedThisFrame = src.pressed && !wasPressed;
-    prev.releasedThisFrame = !src.pressed && wasPressed;
-  }
-  for (let i = bLen; i < state.buttons.length; i++) {
-    const b = state.buttons[i];
-    if (!b) continue;
-    b.pressedThisFrame = false;
-    b.releasedThisFrame = b.pressed;
-    b.pressed = false;
-    b.value = 0;
-  }
-  const aLen = Math.min(state.axes.length, snapshot.axes.length);
-  for (let i = 0; i < aLen; i++) {
-    state.axes[i] = applyDeadZone(snapshot.axes[i] ?? 0, deadZone);
-  }
-  for (let i = aLen; i < state.axes.length; i++) state.axes[i] = 0;
+	if (snapshot === null) {
+		if (!state.connected && !anyButtonDown(state)) {
+			clearFrameFlags(state);
+			return;
+		}
+		for (let i = 0; i < state.buttons.length; i++) {
+			const b = state.buttons[i];
+			if (!b) continue;
+			b.pressedThisFrame = false;
+			b.releasedThisFrame = b.pressed;
+			b.pressed = false;
+			b.value = 0;
+		}
+		for (let i = 0; i < state.axes.length; i++) state.axes[i] = 0;
+		state.connected = false;
+		state.id = "";
+		return;
+	}
+	state.connected = true;
+	state.id = snapshot.id;
+	state.index = snapshot.index;
+	state.timestamp = snapshot.timestamp;
+	const srcButtons = snapshot.buttons;
+	const bLen = Math.min(state.buttons.length, srcButtons.length);
+	for (let i = 0; i < bLen; i++) {
+		const prev = state.buttons[i];
+		const src = srcButtons[i];
+		if (!prev || !src) continue;
+		const wasPressed = prev.pressed;
+		prev.pressed = src.pressed;
+		prev.value = src.value;
+		prev.pressedThisFrame = src.pressed && !wasPressed;
+		prev.releasedThisFrame = !src.pressed && wasPressed;
+	}
+	for (let i = bLen; i < state.buttons.length; i++) {
+		const b = state.buttons[i];
+		if (!b) continue;
+		b.pressedThisFrame = false;
+		b.releasedThisFrame = b.pressed;
+		b.pressed = false;
+		b.value = 0;
+	}
+	const aLen = Math.min(state.axes.length, snapshot.axes.length);
+	for (let i = 0; i < aLen; i++) state.axes[i] = applyDeadZone(snapshot.axes[i] ?? 0, deadZone);
+	for (let i = aLen; i < state.axes.length; i++) state.axes[i] = 0;
 }
+/** Reset just the per-frame edge flags. Call when advancing a frame without a fresh snapshot. */
 function resetGamepadFrame(state) {
-  clearFrameFlags(state);
+	clearFrameFlags(state);
 }
 function clearFrameFlags(state) {
-  for (let i = 0; i < state.buttons.length; i++) {
-    const b = state.buttons[i];
-    if (!b) continue;
-    b.pressedThisFrame = false;
-    b.releasedThisFrame = false;
-  }
+	for (let i = 0; i < state.buttons.length; i++) {
+		const b = state.buttons[i];
+		if (!b) continue;
+		b.pressedThisFrame = false;
+		b.releasedThisFrame = false;
+	}
 }
 function anyButtonDown(state) {
-  for (let i = 0; i < state.buttons.length; i++) {
-    if (state.buttons[i]?.pressed) return true;
-  }
-  return false;
+	for (let i = 0; i < state.buttons.length; i++) if (state.buttons[i]?.pressed) return true;
+	return false;
 }
 function isButtonDown(state, button) {
-  return state.buttons[button]?.pressed ?? false;
+	return state.buttons[button]?.pressed ?? false;
 }
 function wasButtonPressed(state, button) {
-  return state.buttons[button]?.pressedThisFrame ?? false;
+	return state.buttons[button]?.pressedThisFrame ?? false;
 }
 function wasButtonReleased(state, button) {
-  return state.buttons[button]?.releasedThisFrame ?? false;
+	return state.buttons[button]?.releasedThisFrame ?? false;
 }
 function getAxis(state, axis) {
-  return state.axes[axis] ?? 0;
+	return state.axes[axis] ?? 0;
 }
-
-// src/remap.ts
+//#endregion
+//#region src/gamepad-source.ts
+/**
+* Wrap `navigator.getGamepads()` (W3C Gamepad API). If `nav` is not supplied,
+* uses `globalThis.navigator`. Returns an empty array when the API is absent.
+*/
+function createWebGamepadSource(nav) {
+	const source = nav ?? (typeof globalThis === "undefined" ? void 0 : globalThis.navigator);
+	return { poll() {
+		if (!source?.getGamepads) return [];
+		const pads = source.getGamepads();
+		const out = new Array(pads.length);
+		for (let i = 0; i < pads.length; i++) {
+			const p = pads[i];
+			if (!p?.connected) {
+				out[i] = null;
+				continue;
+			}
+			out[i] = webGamepadToSnapshot(p);
+		}
+		return out;
+	} };
+}
+function webGamepadToSnapshot(p) {
+	const buttons = new Array(p.buttons.length);
+	for (let i = 0; i < p.buttons.length; i++) {
+		const b = p.buttons[i];
+		buttons[i] = {
+			pressed: b?.pressed ?? false,
+			value: b?.value ?? 0
+		};
+	}
+	const axes = new Array(p.axes.length);
+	for (let i = 0; i < p.axes.length; i++) axes[i] = p.axes[i] ?? 0;
+	return {
+		id: p.id,
+		index: p.index,
+		timestamp: p.timestamp,
+		buttons,
+		axes
+	};
+}
+//#endregion
+//#region src/gestures.ts
+const DEFAULT_TAP_MAX_DURATION = .3;
+const DEFAULT_TAP_MAX_DISTANCE = 20;
+const DEFAULT_LONG_PRESS_MIN_DURATION = .5;
+const DEFAULT_SWIPE_MIN_DISTANCE = 50;
+const DEFAULT_SWIPE_MAX_DURATION = .4;
+/**
+* GestureDetector recognizes tap, long press, swipe, and pinch gestures
+* from raw pointer events.
+*/
+var GestureDetector = class {
+	onTap = new _flare_engine_events.Signal();
+	onLongPress = new _flare_engine_events.Signal();
+	onSwipe = new _flare_engine_events.Signal();
+	onPinch = new _flare_engine_events.Signal();
+	tapMaxDuration;
+	tapMaxDistance;
+	longPressMinDuration;
+	swipeMinDistance;
+	swipeMaxDuration;
+	_startPos = {
+		x: 0,
+		y: 0
+	};
+	_startTime = 0;
+	_isTracking = false;
+	_longPressFired = false;
+	_pinchStartDistance = 0;
+	_pinchTouches = null;
+	constructor(config) {
+		this.tapMaxDuration = config?.tapMaxDuration ?? DEFAULT_TAP_MAX_DURATION;
+		this.tapMaxDistance = config?.tapMaxDistance ?? DEFAULT_TAP_MAX_DISTANCE;
+		this.longPressMinDuration = config?.longPressMinDuration ?? DEFAULT_LONG_PRESS_MIN_DURATION;
+		this.swipeMinDistance = config?.swipeMinDistance ?? DEFAULT_SWIPE_MIN_DISTANCE;
+		this.swipeMaxDuration = config?.swipeMaxDuration ?? DEFAULT_SWIPE_MAX_DURATION;
+	}
+	/** Feed a pointer-down event. */
+	pointerDown(x, y) {
+		this._startPos = {
+			x,
+			y
+		};
+		this._startTime = 0;
+		this._isTracking = true;
+		this._longPressFired = false;
+	}
+	/** Feed a pointer-up event. */
+	pointerUp(x, y, elapsedSinceDown) {
+		if (!this._isTracking) return;
+		this._isTracking = false;
+		const dx = x - this._startPos.x;
+		const dy = y - this._startPos.y;
+		const dist = Math.sqrt(dx * dx + dy * dy);
+		const duration = elapsedSinceDown;
+		if (dist >= this.swipeMinDistance && duration <= this.swipeMaxDuration) {
+			const absDx = Math.abs(dx);
+			const absDy = Math.abs(dy);
+			let direction;
+			if (absDx > absDy) direction = dx > 0 ? "right" : "left";
+			else direction = dy > 0 ? "down" : "up";
+			this.onSwipe.emit({
+				direction,
+				distance: dist,
+				duration
+			});
+			return;
+		}
+		if (dist <= this.tapMaxDistance && duration <= this.tapMaxDuration) {
+			this.onTap.emit({
+				x,
+				y
+			});
+			return;
+		}
+	}
+	/**
+	* Update gesture tracking. Call each frame with dt.
+	* @param dt Delta time in seconds.
+	* @param currentX Current pointer X.
+	* @param currentY Current pointer Y.
+	*/
+	update(dt, currentX, currentY) {
+		if (!this._isTracking) return;
+		this._startTime += dt;
+		if (!this._longPressFired && this._startTime >= this.longPressMinDuration) {
+			const dx = currentX - this._startPos.x;
+			const dy = currentY - this._startPos.y;
+			if (Math.sqrt(dx * dx + dy * dy) <= this.tapMaxDistance) {
+				this._longPressFired = true;
+				this.onLongPress.emit({
+					x: currentX,
+					y: currentY
+				});
+			}
+		}
+	}
+	/**
+	* Feed a two-finger pinch update. Call when two touches are active.
+	* @param t1 First touch position.
+	* @param t2 Second touch position.
+	*/
+	pinchUpdate(t1, t2) {
+		const dx = t2.x - t1.x;
+		const dy = t2.y - t1.y;
+		const dist = Math.sqrt(dx * dx + dy * dy);
+		if (this._pinchTouches === null) {
+			this._pinchStartDistance = dist;
+			this._pinchTouches = [{ ...t1 }, { ...t2 }];
+			return;
+		}
+		if (this._pinchStartDistance > 0) {
+			const scale = dist / this._pinchStartDistance;
+			const center = {
+				x: (t1.x + t2.x) / 2,
+				y: (t1.y + t2.y) / 2
+			};
+			this.onPinch.emit({
+				scale,
+				center
+			});
+		}
+	}
+	/** Call when pinch ends (fewer than 2 touches). */
+	pinchEnd() {
+		this._pinchTouches = null;
+		this._pinchStartDistance = 0;
+	}
+};
+//#endregion
+//#region src/virtual-button.ts
+/** Create a default button state. */
+function createButtonState() {
+	return {
+		isPressed: false,
+		justPressed: false,
+		justReleased: false
+	};
+}
+/** Call at the start of each frame to reset per-frame flags. */
+function resetButtonFrame(state) {
+	state.justPressed = false;
+	state.justReleased = false;
+}
+/** Call when the button is pressed. */
+function pressButton(state) {
+	if (!state.isPressed) {
+		state.isPressed = true;
+		state.justPressed = true;
+	}
+}
+/** Call when the button is released. */
+function releaseButton(state) {
+	if (state.isPressed) {
+		state.isPressed = false;
+		state.justReleased = true;
+	}
+}
+//#endregion
+//#region src/keyboard.ts
+/** Create a fresh keyboard state. */
+function createKeyboard() {
+	const states = [];
+	const codeIndex = /* @__PURE__ */ new Map();
+	return {
+		isDown(code) {
+			const i = codeIndex.get(code);
+			if (i === void 0) return false;
+			return states[i]?.isPressed ?? false;
+		},
+		wasPressed(code) {
+			const i = codeIndex.get(code);
+			if (i === void 0) return false;
+			return states[i]?.justPressed ?? false;
+		},
+		wasReleased(code) {
+			const i = codeIndex.get(code);
+			if (i === void 0) return false;
+			return states[i]?.justReleased ?? false;
+		},
+		keyDown(code) {
+			let i = codeIndex.get(code);
+			if (i === void 0) {
+				i = states.length;
+				states.push(createButtonState());
+				codeIndex.set(code, i);
+			}
+			pressButton(states[i]);
+		},
+		keyUp(code) {
+			const i = codeIndex.get(code);
+			if (i === void 0) return;
+			releaseButton(states[i]);
+		},
+		reset() {
+			for (let i = 0; i < states.length; i++) resetButtonFrame(states[i]);
+		},
+		clear() {
+			for (let i = 0; i < states.length; i++) releaseButton(states[i]);
+		}
+	};
+}
+/** Free-function parity with `resetPointerFrame`. Delegates to `kb.reset()`. */
+function resetKeyboardFrame(kb) {
+	kb.reset();
+}
+/**
+* Web turnkey adapter: registers `keydown`, `keyup`, and `blur` listeners on
+* `target`. `blur` calls `kb.clear()` (stuck-key guard). Returns a detach fn.
+*
+* `target` is structural `{ addEventListener, removeEventListener }` — no DOM
+* types dep. On web, pass `window`; for mobile/RN, feed `keyDown`/`keyUp`
+* directly from a hardware-keyboard native module or an on-screen source.
+*
+* Does NOT call `preventDefault` — bare use lets Space/arrows scroll and Tab
+* move DOM focus. For game-mode input, attach your own listener that calls
+* `preventDefault` for game keys and forwards `kb.keyDown(ev.code)`.
+*/
+function attachKeyboardListeners(kb, target) {
+	const onKeyDown = (ev) => {
+		kb.keyDown(ev.code);
+	};
+	const onKeyUp = (ev) => {
+		kb.keyUp(ev.code);
+	};
+	const onBlur = (_ev) => {
+		kb.clear();
+	};
+	target.addEventListener("keydown", onKeyDown);
+	target.addEventListener("keyup", onKeyUp);
+	target.addEventListener("blur", onBlur);
+	return () => {
+		target.removeEventListener("keydown", onKeyDown);
+		target.removeEventListener("keyup", onKeyUp);
+		target.removeEventListener("blur", onBlur);
+	};
+}
+/** True if any bound code for `action` is currently held. */
+function isActionDown(kb, bindings, action) {
+	const codes = bindings[action];
+	if (!codes) return false;
+	for (let i = 0; i < codes.length; i++) if (kb.isDown(codes[i])) return true;
+	return false;
+}
+/** True if any bound code for `action` was pressed this frame. */
+function wasActionPressed(kb, bindings, action) {
+	const codes = bindings[action];
+	if (!codes) return false;
+	for (let i = 0; i < codes.length; i++) if (kb.wasPressed(codes[i])) return true;
+	return false;
+}
+/**
+* True if any bound code for `action` was released this frame AND no bound
+* code is still held. Release fires only when the last held bound key lifts.
+*/
+function wasActionReleased(kb, bindings, action) {
+	const codes = bindings[action];
+	if (!codes) return false;
+	let anyReleased = false;
+	for (let i = 0; i < codes.length; i++) {
+		if (kb.isDown(codes[i])) return false;
+		if (kb.wasReleased(codes[i])) anyReleased = true;
+	}
+	return anyReleased;
+}
+//#endregion
+//#region src/pointer.ts
+/** Create a default pointer state. */
+function createPointer() {
+	return {
+		position: {
+			x: 0,
+			y: 0
+		},
+		delta: {
+			x: 0,
+			y: 0
+		},
+		isDown: false,
+		justPressed: false,
+		justReleased: false
+	};
+}
+/**
+* Update pointer state for a new frame.
+* Call this at the start of each frame to clear per-frame flags.
+*/
+function resetPointerFrame(pointer) {
+	pointer.delta.x = 0;
+	pointer.delta.y = 0;
+	pointer.justPressed = false;
+	pointer.justReleased = false;
+}
+/** Feed a pointer-down event into the pointer state. */
+function pointerDown(pointer, x, y) {
+	const wasDown = pointer.isDown;
+	pointer.isDown = true;
+	if (!wasDown) pointer.justPressed = true;
+	pointer.delta.x += x - pointer.position.x;
+	pointer.delta.y += y - pointer.position.y;
+	pointer.position.x = x;
+	pointer.position.y = y;
+}
+/** Feed a pointer-move event into the pointer state. */
+function pointerMove(pointer, x, y) {
+	pointer.delta.x += x - pointer.position.x;
+	pointer.delta.y += y - pointer.position.y;
+	pointer.position.x = x;
+	pointer.position.y = y;
+}
+/** Feed a pointer-up event into the pointer state. */
+function pointerUp(pointer, x, y) {
+	pointer.isDown = false;
+	pointer.justReleased = true;
+	pointer.delta.x += x - pointer.position.x;
+	pointer.delta.y += y - pointer.position.y;
+	pointer.position.x = x;
+	pointer.position.y = y;
+}
+//#endregion
+//#region src/remap.ts
 function createIdentityRemap(buttonCount = 17, axisCount = 4) {
-  const buttons = new Array(buttonCount);
-  for (let i = 0; i < buttonCount; i++) buttons[i] = i;
-  const axes = new Array(axisCount);
-  for (let i = 0; i < axisCount; i++) axes[i] = { index: i, invert: false, scale: 1 };
-  return { buttons, axes };
+	const buttons = new Array(buttonCount);
+	for (let i = 0; i < buttonCount; i++) buttons[i] = i;
+	const axes = new Array(axisCount);
+	for (let i = 0; i < axisCount; i++) axes[i] = {
+		index: i,
+		invert: false,
+		scale: 1
+	};
+	return {
+		buttons,
+		axes
+	};
 }
+/** Apply a remap table to a raw snapshot, returning a new snapshot with logical ordering. */
 function applyRemap(snapshot, table) {
-  const buttons = new Array(table.buttons.length);
-  for (let logical = 0; logical < table.buttons.length; logical++) {
-    const physical = table.buttons[logical] ?? logical;
-    const src = snapshot.buttons[physical];
-    buttons[logical] = { pressed: src?.pressed ?? false, value: src?.value ?? 0 };
-  }
-  const axes = new Array(table.axes.length);
-  for (let logical = 0; logical < table.axes.length; logical++) {
-    const map = table.axes[logical] ?? { index: logical, invert: false, scale: 1 };
-    const raw = snapshot.axes[map.index] ?? 0;
-    axes[logical] = raw * map.scale * (map.invert ? -1 : 1);
-  }
-  return { id: snapshot.id, index: snapshot.index, timestamp: snapshot.timestamp, buttons, axes };
+	const buttons = new Array(table.buttons.length);
+	for (let logical = 0; logical < table.buttons.length; logical++) {
+		const physical = table.buttons[logical] ?? logical;
+		const src = snapshot.buttons[physical];
+		buttons[logical] = {
+			pressed: src?.pressed ?? false,
+			value: src?.value ?? 0
+		};
+	}
+	const axes = new Array(table.axes.length);
+	for (let logical = 0; logical < table.axes.length; logical++) {
+		const map = table.axes[logical] ?? {
+			index: logical,
+			invert: false,
+			scale: 1
+		};
+		axes[logical] = (snapshot.axes[map.index] ?? 0) * map.scale * (map.invert ? -1 : 1);
+	}
+	return {
+		id: snapshot.id,
+		index: snapshot.index,
+		timestamp: snapshot.timestamp,
+		buttons,
+		axes
+	};
 }
+/** Persist a remap table under the given key. Throws on invalid table shape. */
 async function saveRemap(store, key, table) {
-  await store.set(key, JSON.stringify(table));
+	await store.set(key, JSON.stringify(table));
 }
+/** Load a remap table. Returns `null` if absent or malformed. */
 async function loadRemap(store, key) {
-  const raw = await store.get(key);
-  if (raw === null) return null;
-  try {
-    const parsed = JSON.parse(raw);
-    if (!isRemapTable(parsed)) return null;
-    return parsed;
-  } catch {
-    return null;
-  }
+	const raw = await store.get(key);
+	if (raw === null) return null;
+	try {
+		const parsed = JSON.parse(raw);
+		if (!isRemapTable(parsed)) return null;
+		return parsed;
+	} catch {
+		return null;
+	}
 }
 function isRemapTable(value) {
-  if (typeof value !== "object" || value === null) return false;
-  const obj = value;
-  if (!Array.isArray(obj.buttons) || !Array.isArray(obj.axes)) return false;
-  for (const b of obj.buttons) if (typeof b !== "number") return false;
-  for (const a of obj.axes) {
-    if (typeof a !== "object" || a === null) return false;
-    const ax = a;
-    if (typeof ax.index !== "number" || typeof ax.invert !== "boolean" || typeof ax.scale !== "number") {
-      return false;
-    }
-  }
-  return true;
+	if (typeof value !== "object" || value === null) return false;
+	const obj = value;
+	if (!Array.isArray(obj.buttons) || !Array.isArray(obj.axes)) return false;
+	for (const b of obj.buttons) if (typeof b !== "number") return false;
+	for (const a of obj.axes) {
+		if (typeof a !== "object" || a === null) return false;
+		const ax = a;
+		if (typeof ax.index !== "number" || typeof ax.invert !== "boolean" || typeof ax.scale !== "number") return false;
+	}
+	return true;
 }
-
-// src/input-manager.ts
+//#endregion
+//#region src/input-manager.ts
+/**
+* InputManager provides a polling-based input model.
+*
+* Call `update()` once per frame (before game logic) to snapshot input state.
+* Feed events from the platform (RN touch/gesture handlers) via the on* methods.
+*/
 var InputManager = class {
-  /** Primary pointer (first touch or mouse). */
-  pointer = createPointer();
-  /** All active touch points. */
-  touches = [];
-  _touchMap = /* @__PURE__ */ new Map();
-  _gamepads = [];
-  _gamepadDeadZone = 0.15;
-  _gamepadRemaps = /* @__PURE__ */ new Map();
-  /** Call once per frame to reset per-frame flags. */
-  update() {
-    resetPointerFrame(this.pointer);
-    for (let i = 0; i < this._gamepads.length; i++) {
-      const pad = this._gamepads[i];
-      if (pad) resetGamepadFrame(pad);
-    }
-  }
-  /** Feed a touch/pointer begin event. */
-  onPointerDown(id, x, y) {
-    pointerDown(this.pointer, x, y);
-    this._addOrUpdateTouch(id, x, y, true);
-  }
-  /** Feed a touch/pointer move event. */
-  onPointerMove(id, x, y) {
-    pointerMove(this.pointer, x, y);
-    this._addOrUpdateTouch(id, x, y, true);
-  }
-  /** Feed a touch/pointer end event. */
-  onPointerUp(id, x, y) {
-    pointerUp(this.pointer, x, y);
-    this._removeTouch(id);
-  }
-  /** Access the gamepad state at `index`. Allocates on first access. */
-  gamepad(index) {
-    let pad = this._gamepads[index];
-    if (!pad) {
-      pad = createGamepadState(index);
-      this._gamepads[index] = pad;
-    }
-    return pad;
-  }
-  /** Dead zone in [0, 1). Axes at or below this magnitude read as 0. */
-  setGamepadDeadZone(deadZone) {
-    this._gamepadDeadZone = Math.max(0, Math.min(0.95, deadZone));
-  }
-  /** Install a remap table for a specific gamepad index. Pass `null` to clear. */
-  setGamepadRemap(index, table) {
-    if (table === null) this._gamepadRemaps.delete(index);
-    else this._gamepadRemaps.set(index, table);
-  }
-  /** Poll all gamepads from the given source, applying remap + dead zones. */
-  pollGamepads(source) {
-    const snapshots = source.poll();
-    for (let i = 0; i < snapshots.length; i++) {
-      const pad = this.gamepad(i);
-      const snap = snapshots[i] ?? null;
-      const remapped = snap !== null ? this._gamepadRemaps.get(i) ? applyRemap(snap, this._gamepadRemaps.get(i)) : snap : null;
-      updateGamepadFromSnapshot(pad, remapped, this._gamepadDeadZone);
-    }
-  }
-  _addOrUpdateTouch(id, x, y, isDown) {
-    let touch = this._touchMap.get(id);
-    if (!touch) {
-      touch = { id, position: { x, y }, isDown };
-      this._touchMap.set(id, touch);
-      this.touches.push(touch);
-    } else {
-      touch.position.x = x;
-      touch.position.y = y;
-      touch.isDown = isDown;
-    }
-  }
-  _removeTouch(id) {
-    const touch = this._touchMap.get(id);
-    if (!touch) return;
-    this._touchMap.delete(id);
-    const idx = this.touches.indexOf(touch);
-    if (idx !== -1) {
-      this.touches.splice(idx, 1);
-    }
-  }
+	/** Primary pointer (first touch or mouse). */
+	pointer = createPointer();
+	/** Buffered keyboard state. Feed via `attachKeyboardListeners` (web) or `keyboard.keyDown`/`keyUp` (mobile/RN). */
+	keyboard = createKeyboard();
+	/** All active touch points. */
+	touches = [];
+	_touchMap = /* @__PURE__ */ new Map();
+	_gamepads = [];
+	_gamepadDeadZone = .15;
+	_gamepadRemaps = /* @__PURE__ */ new Map();
+	/** Call once per frame to reset per-frame flags. */
+	update() {
+		resetPointerFrame(this.pointer);
+		resetKeyboardFrame(this.keyboard);
+		for (let i = 0; i < this._gamepads.length; i++) {
+			const pad = this._gamepads[i];
+			if (pad) resetGamepadFrame(pad);
+		}
+	}
+	/** Feed a touch/pointer begin event. */
+	onPointerDown(id, x, y) {
+		pointerDown(this.pointer, x, y);
+		this._addOrUpdateTouch(id, x, y, true);
+	}
+	/** Feed a touch/pointer move event. */
+	onPointerMove(id, x, y) {
+		pointerMove(this.pointer, x, y);
+		this._addOrUpdateTouch(id, x, y, true);
+	}
+	/** Feed a touch/pointer end event. */
+	onPointerUp(id, x, y) {
+		pointerUp(this.pointer, x, y);
+		this._removeTouch(id);
+	}
+	/** Access the gamepad state at `index`. Allocates on first access. */
+	gamepad(index) {
+		let pad = this._gamepads[index];
+		if (!pad) {
+			pad = createGamepadState(index);
+			this._gamepads[index] = pad;
+		}
+		return pad;
+	}
+	/** Dead zone in [0, 1). Axes at or below this magnitude read as 0. */
+	setGamepadDeadZone(deadZone) {
+		this._gamepadDeadZone = Math.max(0, Math.min(.95, deadZone));
+	}
+	/** Install a remap table for a specific gamepad index. Pass `null` to clear. */
+	setGamepadRemap(index, table) {
+		if (table === null) this._gamepadRemaps.delete(index);
+		else this._gamepadRemaps.set(index, table);
+	}
+	/** Poll all gamepads from the given source, applying remap + dead zones. */
+	pollGamepads(source) {
+		const snapshots = source.poll();
+		for (let i = 0; i < snapshots.length; i++) {
+			const pad = this.gamepad(i);
+			const snap = snapshots[i] ?? null;
+			updateGamepadFromSnapshot(pad, snap !== null ? this._gamepadRemaps.get(i) ? applyRemap(snap, this._gamepadRemaps.get(i)) : snap : null, this._gamepadDeadZone);
+		}
+	}
+	_addOrUpdateTouch(id, x, y, isDown) {
+		let touch = this._touchMap.get(id);
+		if (!touch) {
+			touch = {
+				id,
+				position: {
+					x,
+					y
+				},
+				isDown
+			};
+			this._touchMap.set(id, touch);
+			this.touches.push(touch);
+		} else {
+			touch.position.x = x;
+			touch.position.y = y;
+			touch.isDown = isDown;
+		}
+	}
+	_removeTouch(id) {
+		const touch = this._touchMap.get(id);
+		if (!touch) return;
+		this._touchMap.delete(id);
+		const idx = this.touches.indexOf(touch);
+		if (idx !== -1) this.touches.splice(idx, 1);
+	}
 };
-
-// src/gamepad-source.ts
-function createWebGamepadSource(nav) {
-  const source = nav ?? (typeof globalThis === "undefined" ? void 0 : globalThis.navigator);
-  return {
-    poll() {
-      if (!source?.getGamepads) return [];
-      const pads = source.getGamepads();
-      const out = new Array(pads.length);
-      for (let i = 0; i < pads.length; i++) {
-        const p = pads[i];
-        if (!p || !p.connected) {
-          out[i] = null;
-          continue;
-        }
-        out[i] = webGamepadToSnapshot(p);
-      }
-      return out;
-    }
-  };
-}
-function webGamepadToSnapshot(p) {
-  const buttons = new Array(p.buttons.length);
-  for (let i = 0; i < p.buttons.length; i++) {
-    const b = p.buttons[i];
-    buttons[i] = { pressed: b?.pressed ?? false, value: b?.value ?? 0 };
-  }
-  const axes = new Array(p.axes.length);
-  for (let i = 0; i < p.axes.length; i++) axes[i] = p.axes[i] ?? 0;
-  return { id: p.id, index: p.index, timestamp: p.timestamp, buttons, axes };
-}
-
-// src/gestures.ts
-var import_events = require("@flare-engine/events");
-var DEFAULT_TAP_MAX_DURATION = 0.3;
-var DEFAULT_TAP_MAX_DISTANCE = 20;
-var DEFAULT_LONG_PRESS_MIN_DURATION = 0.5;
-var DEFAULT_SWIPE_MIN_DISTANCE = 50;
-var DEFAULT_SWIPE_MAX_DURATION = 0.4;
-var GestureDetector = class {
-  onTap = new import_events.Signal();
-  onLongPress = new import_events.Signal();
-  onSwipe = new import_events.Signal();
-  onPinch = new import_events.Signal();
-  tapMaxDuration;
-  tapMaxDistance;
-  longPressMinDuration;
-  swipeMinDistance;
-  swipeMaxDuration;
-  // Single-touch tracking
-  _startPos = { x: 0, y: 0 };
-  _startTime = 0;
-  _isTracking = false;
-  _longPressFired = false;
-  // Pinch tracking
-  _pinchStartDistance = 0;
-  _pinchTouches = null;
-  constructor(config) {
-    this.tapMaxDuration = config?.tapMaxDuration ?? DEFAULT_TAP_MAX_DURATION;
-    this.tapMaxDistance = config?.tapMaxDistance ?? DEFAULT_TAP_MAX_DISTANCE;
-    this.longPressMinDuration = config?.longPressMinDuration ?? DEFAULT_LONG_PRESS_MIN_DURATION;
-    this.swipeMinDistance = config?.swipeMinDistance ?? DEFAULT_SWIPE_MIN_DISTANCE;
-    this.swipeMaxDuration = config?.swipeMaxDuration ?? DEFAULT_SWIPE_MAX_DURATION;
-  }
-  /** Feed a pointer-down event. */
-  pointerDown(x, y) {
-    this._startPos = { x, y };
-    this._startTime = 0;
-    this._isTracking = true;
-    this._longPressFired = false;
-  }
-  /** Feed a pointer-up event. */
-  pointerUp(x, y, elapsedSinceDown) {
-    if (!this._isTracking) return;
-    this._isTracking = false;
-    const dx = x - this._startPos.x;
-    const dy = y - this._startPos.y;
-    const dist = Math.sqrt(dx * dx + dy * dy);
-    const duration = elapsedSinceDown;
-    if (dist >= this.swipeMinDistance && duration <= this.swipeMaxDuration) {
-      const absDx = Math.abs(dx);
-      const absDy = Math.abs(dy);
-      let direction;
-      if (absDx > absDy) {
-        direction = dx > 0 ? "right" : "left";
-      } else {
-        direction = dy > 0 ? "down" : "up";
-      }
-      this.onSwipe.emit({ direction, distance: dist, duration });
-      return;
-    }
-    if (dist <= this.tapMaxDistance && duration <= this.tapMaxDuration) {
-      this.onTap.emit({ x, y });
-      return;
-    }
-  }
-  /**
-   * Update gesture tracking. Call each frame with dt.
-   * @param dt Delta time in seconds.
-   * @param currentX Current pointer X.
-   * @param currentY Current pointer Y.
-   */
-  update(dt, currentX, currentY) {
-    if (!this._isTracking) return;
-    this._startTime += dt;
-    if (!this._longPressFired && this._startTime >= this.longPressMinDuration) {
-      const dx = currentX - this._startPos.x;
-      const dy = currentY - this._startPos.y;
-      const dist = Math.sqrt(dx * dx + dy * dy);
-      if (dist <= this.tapMaxDistance) {
-        this._longPressFired = true;
-        this.onLongPress.emit({ x: currentX, y: currentY });
-      }
-    }
-  }
-  /**
-   * Feed a two-finger pinch update. Call when two touches are active.
-   * @param t1 First touch position.
-   * @param t2 Second touch position.
-   */
-  pinchUpdate(t1, t2) {
-    const dx = t2.x - t1.x;
-    const dy = t2.y - t1.y;
-    const dist = Math.sqrt(dx * dx + dy * dy);
-    if (this._pinchTouches === null) {
-      this._pinchStartDistance = dist;
-      this._pinchTouches = [{ ...t1 }, { ...t2 }];
-      return;
-    }
-    if (this._pinchStartDistance > 0) {
-      const scale = dist / this._pinchStartDistance;
-      const center = {
-        x: (t1.x + t2.x) / 2,
-        y: (t1.y + t2.y) / 2
-      };
-      this.onPinch.emit({ scale, center });
-    }
-  }
-  /** Call when pinch ends (fewer than 2 touches). */
-  pinchEnd() {
-    this._pinchTouches = null;
-    this._pinchStartDistance = 0;
-  }
-};
-
-// src/virtual-joystick.ts
-var DEFAULT_DEAD_ZONE = 10;
-var DEFAULT_MAX_RADIUS = 50;
+//#endregion
+//#region src/virtual-joystick.ts
+const DEFAULT_DEAD_ZONE = 10;
+const DEFAULT_MAX_RADIUS = 50;
+/** Create a default joystick state. */
 function createJoystickState() {
-  return {
-    active: false,
-    direction: { x: 0, y: 0 },
-    magnitude: 0,
-    offset: { x: 0, y: 0 }
-  };
+	return {
+		active: false,
+		direction: {
+			x: 0,
+			y: 0
+		},
+		magnitude: 0,
+		offset: {
+			x: 0,
+			y: 0
+		}
+	};
 }
+/**
+* Update joystick state from a touch event.
+*
+* @param state The joystick state to update.
+* @param centerX The joystick center X in screen pixels.
+* @param centerY The joystick center Y in screen pixels.
+* @param touchX The current touch X in screen pixels.
+* @param touchY The current touch Y in screen pixels.
+* @param config Joystick configuration.
+*/
 function updateJoystick(state, centerX, centerY, touchX, touchY, config) {
-  const deadZone = config?.deadZone ?? DEFAULT_DEAD_ZONE;
-  const maxRadius = config?.maxRadius ?? DEFAULT_MAX_RADIUS;
-  const dx = touchX - centerX;
-  const dy = touchY - centerY;
-  const dist = Math.sqrt(dx * dx + dy * dy);
-  state.active = true;
-  if (dist < deadZone) {
-    state.direction.x = 0;
-    state.direction.y = 0;
-    state.magnitude = 0;
-    state.offset.x = dx;
-    state.offset.y = dy;
-    return;
-  }
-  const clampedDist = Math.min(dist, maxRadius);
-  const normalizedDist = (clampedDist - deadZone) / (maxRadius - deadZone);
-  const invDist = 1 / dist;
-  state.direction.x = dx * invDist;
-  state.direction.y = dy * invDist;
-  state.magnitude = Math.min(normalizedDist, 1);
-  const scale = clampedDist / dist;
-  state.offset.x = dx * scale;
-  state.offset.y = dy * scale;
+	const deadZone = config?.deadZone ?? DEFAULT_DEAD_ZONE;
+	const maxRadius = config?.maxRadius ?? DEFAULT_MAX_RADIUS;
+	const dx = touchX - centerX;
+	const dy = touchY - centerY;
+	const dist = Math.sqrt(dx * dx + dy * dy);
+	state.active = true;
+	if (dist < deadZone) {
+		state.direction.x = 0;
+		state.direction.y = 0;
+		state.magnitude = 0;
+		state.offset.x = dx;
+		state.offset.y = dy;
+		return;
+	}
+	const clampedDist = Math.min(dist, maxRadius);
+	const normalizedDist = (clampedDist - deadZone) / (maxRadius - deadZone);
+	const invDist = 1 / dist;
+	state.direction.x = dx * invDist;
+	state.direction.y = dy * invDist;
+	state.magnitude = Math.min(normalizedDist, 1);
+	const scale = clampedDist / dist;
+	state.offset.x = dx * scale;
+	state.offset.y = dy * scale;
 }
+/** Reset joystick state when touch is released. */
 function releaseJoystick(state) {
-  state.active = false;
-  state.direction.x = 0;
-  state.direction.y = 0;
-  state.magnitude = 0;
-  state.offset.x = 0;
-  state.offset.y = 0;
+	state.active = false;
+	state.direction.x = 0;
+	state.direction.y = 0;
+	state.magnitude = 0;
+	state.offset.x = 0;
+	state.offset.y = 0;
 }
+//#endregion
+exports.GamepadAxis = GamepadAxis;
+exports.GamepadButton = GamepadButton;
+exports.GestureDetector = GestureDetector;
+exports.InputManager = InputManager;
+exports.applyRemap = applyRemap;
+exports.attachKeyboardListeners = attachKeyboardListeners;
+exports.createButtonState = createButtonState;
+exports.createGamepadState = createGamepadState;
+exports.createIdentityRemap = createIdentityRemap;
+exports.createJoystickState = createJoystickState;
+exports.createKeyboard = createKeyboard;
+exports.createPointer = createPointer;
+exports.createWebGamepadSource = createWebGamepadSource;
+exports.getAxis = getAxis;
+exports.isActionDown = isActionDown;
+exports.isButtonDown = isButtonDown;
+exports.loadRemap = loadRemap;
+exports.pointerDown = pointerDown;
+exports.pointerMove = pointerMove;
+exports.pointerUp = pointerUp;
+exports.pressButton = pressButton;
+exports.releaseButton = releaseButton;
+exports.releaseJoystick = releaseJoystick;
+exports.resetButtonFrame = resetButtonFrame;
+exports.resetGamepadFrame = resetGamepadFrame;
+exports.resetKeyboardFrame = resetKeyboardFrame;
+exports.resetPointerFrame = resetPointerFrame;
+exports.saveRemap = saveRemap;
+exports.updateGamepadFromSnapshot = updateGamepadFromSnapshot;
+exports.updateJoystick = updateJoystick;
+exports.wasActionPressed = wasActionPressed;
+exports.wasActionReleased = wasActionReleased;
+exports.wasButtonPressed = wasButtonPressed;
+exports.wasButtonReleased = wasButtonReleased;
 
-// src/virtual-button.ts
-function createButtonState() {
-  return {
-    isPressed: false,
-    justPressed: false,
-    justReleased: false
-  };
-}
-function resetButtonFrame(state) {
-  state.justPressed = false;
-  state.justReleased = false;
-}
-function pressButton(state) {
-  if (!state.isPressed) {
-    state.isPressed = true;
-    state.justPressed = true;
-  }
-}
-function releaseButton(state) {
-  if (state.isPressed) {
-    state.isPressed = false;
-    state.justReleased = true;
-  }
-}
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  GamepadAxis,
-  GamepadButton,
-  GestureDetector,
-  InputManager,
-  applyRemap,
-  createButtonState,
-  createGamepadState,
-  createIdentityRemap,
-  createJoystickState,
-  createPointer,
-  createWebGamepadSource,
-  getAxis,
-  isButtonDown,
-  loadRemap,
-  pointerDown,
-  pointerMove,
-  pointerUp,
-  pressButton,
-  releaseButton,
-  releaseJoystick,
-  resetButtonFrame,
-  resetGamepadFrame,
-  resetPointerFrame,
-  saveRemap,
-  updateGamepadFromSnapshot,
-  updateJoystick,
-  wasButtonPressed,
-  wasButtonReleased
-});
 //# sourceMappingURL=index.js.map