@al8b/input 0.1.0

package/dist/core/input-manager.mjs

@@ -0,0 +1,701 @@
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+
+// src/core/input-manager.ts
+import { APIErrorCode, reportRuntimeError } from "@al8b/diagnostics";
+
+// src/devices/gamepad.ts
+var createState = /* @__PURE__ */ __name(() => ({
+  press: {},
+  release: {}
+}), "createState");
+var BUTTONS_MAP = {
+  0: "A",
+  1: "B",
+  2: "X",
+  3: "Y",
+  4: "LB",
+  5: "RB",
+  8: "VIEW",
+  9: "MENU",
+  10: "LS",
+  11: "RS",
+  12: "DPAD_UP",
+  13: "DPAD_DOWN",
+  14: "DPAD_LEFT",
+  15: "DPAD_RIGHT"
+};
+var TRIGGERS_MAP = {
+  6: "LT",
+  7: "RT"
+};
+var ensureState = /* @__PURE__ */ __name((state) => {
+  if (!state) {
+    return createState();
+  }
+  state.press ??= {};
+  state.release ??= {};
+  return state;
+}, "ensureState");
+var GamepadInput = class {
+  static {
+    __name(this, "GamepadInput");
+  }
+  status;
+  previous;
+  count = 0;
+  constructor() {
+    this.status = createState();
+    this.previous = {
+      global: createState()
+    };
+  }
+  update() {
+    const pads = this.getGamepads();
+    if (!pads) {
+      this.count = 0;
+      return;
+    }
+    let padCount = 0;
+    for (let i = 0; i < pads.length; i++) {
+      const pad = pads[i];
+      if (!pad) {
+        break;
+      }
+      padCount++;
+      this.status[i] = ensureState(this.status[i]);
+      this.previous[i] = ensureState(this.previous[i]);
+      for (const [index, name] of Object.entries(BUTTONS_MAP)) {
+        const idx = Number(index);
+        const button = pad.buttons[idx];
+        if (button) {
+          this.status[i][name] = button.pressed ? 1 : 0;
+        }
+      }
+      for (const [index, name] of Object.entries(TRIGGERS_MAP)) {
+        const idx = Number(index);
+        const trigger = pad.buttons[idx];
+        if (trigger) {
+          this.status[i][name] = trigger.value ?? 0;
+        }
+      }
+      if (pad.axes.length >= 2) {
+        this.updateStick(pad.axes[0], -pad.axes[1], this.status[i], "LEFT");
+      }
+      if (pad.axes.length >= 4) {
+        this.updateStick(pad.axes[2], -pad.axes[3], this.status[i], "RIGHT");
+      }
+    }
+    this.aggregateStatus(pads, padCount);
+    this.count = padCount;
+    this.updateChanges(this.status, this.previous.global);
+    for (let i = 0; i < padCount; i++) {
+      this.updateChanges(this.status[i], this.previous[i]);
+    }
+    for (let i = padCount; i < 4; i++) {
+      delete this.status[i];
+      delete this.previous[i];
+    }
+  }
+  getGamepads() {
+    if (typeof navigator === "undefined" || !navigator.getGamepads) {
+      return null;
+    }
+    try {
+      return navigator.getGamepads();
+    } catch {
+      return null;
+    }
+  }
+  updateStick(x, y, target, prefix) {
+    const radius = Math.sqrt(x * x + y * y);
+    const angle = Math.floor((Math.atan2(y, x) + Math.PI * 2) % (Math.PI * 2) / (Math.PI * 2) * 360);
+    target[`${prefix}_STICK_ANGLE`] = angle;
+    target[`${prefix}_STICK_AMOUNT`] = radius;
+    target[`${prefix}_STICK_UP`] = y > 0.5 ? 1 : 0;
+    target[`${prefix}_STICK_DOWN`] = y < -0.5 ? 1 : 0;
+    target[`${prefix}_STICK_LEFT`] = x < -0.5 ? 1 : 0;
+    target[`${prefix}_STICK_RIGHT`] = x > 0.5 ? 1 : 0;
+  }
+  aggregateStatus(pads, padCount) {
+    for (const [index, name] of Object.entries(BUTTONS_MAP)) {
+      this.status[name] = 0;
+      const idx = Number(index);
+      for (const pad of pads) {
+        if (!pad) break;
+        if (pad.buttons[idx]?.pressed) {
+          this.status[name] = 1;
+          break;
+        }
+      }
+    }
+    for (const [index, name] of Object.entries(TRIGGERS_MAP)) {
+      this.status[name] = 0;
+      const idx = Number(index);
+      for (const pad of pads) {
+        if (!pad) break;
+        const button = pad.buttons[idx];
+        if (button) {
+          this.status[name] = button.value ?? 0;
+        }
+      }
+    }
+    this.status.UP = 0;
+    this.status.DOWN = 0;
+    this.status.LEFT = 0;
+    this.status.RIGHT = 0;
+    this.status.LEFT_STICK_UP = 0;
+    this.status.LEFT_STICK_DOWN = 0;
+    this.status.LEFT_STICK_LEFT = 0;
+    this.status.LEFT_STICK_RIGHT = 0;
+    this.status.RIGHT_STICK_UP = 0;
+    this.status.RIGHT_STICK_DOWN = 0;
+    this.status.RIGHT_STICK_LEFT = 0;
+    this.status.RIGHT_STICK_RIGHT = 0;
+    this.status.LEFT_STICK_ANGLE = 0;
+    this.status.LEFT_STICK_AMOUNT = 0;
+    this.status.RIGHT_STICK_ANGLE = 0;
+    this.status.RIGHT_STICK_AMOUNT = 0;
+    this.status.RT = 0;
+    this.status.LT = 0;
+    for (let i = 0; i < padCount; i++) {
+      const padState = this.status[i];
+      if (!padState) continue;
+      padState.UP = padState.DPAD_UP || padState.LEFT_STICK_UP || padState.RIGHT_STICK_UP || 0 ? 1 : 0;
+      padState.DOWN = padState.DPAD_DOWN || padState.LEFT_STICK_DOWN || padState.RIGHT_STICK_DOWN || 0 ? 1 : 0;
+      padState.LEFT = padState.DPAD_LEFT || padState.LEFT_STICK_LEFT || padState.RIGHT_STICK_LEFT || 0 ? 1 : 0;
+      padState.RIGHT = padState.DPAD_RIGHT || padState.LEFT_STICK_RIGHT || padState.RIGHT_STICK_RIGHT || 0 ? 1 : 0;
+      if (padState.UP) this.status.UP = 1;
+      if (padState.DOWN) this.status.DOWN = 1;
+      if (padState.LEFT) this.status.LEFT = 1;
+      if (padState.RIGHT) this.status.RIGHT = 1;
+      if (padState.LEFT_STICK_UP) this.status.LEFT_STICK_UP = 1;
+      if (padState.LEFT_STICK_DOWN) this.status.LEFT_STICK_DOWN = 1;
+      if (padState.LEFT_STICK_LEFT) this.status.LEFT_STICK_LEFT = 1;
+      if (padState.LEFT_STICK_RIGHT) this.status.LEFT_STICK_RIGHT = 1;
+      if (padState.RIGHT_STICK_UP) this.status.RIGHT_STICK_UP = 1;
+      if (padState.RIGHT_STICK_DOWN) this.status.RIGHT_STICK_DOWN = 1;
+      if (padState.RIGHT_STICK_LEFT) this.status.RIGHT_STICK_LEFT = 1;
+      if (padState.RIGHT_STICK_RIGHT) this.status.RIGHT_STICK_RIGHT = 1;
+      if (padState.LT) this.status.LT = padState.LT;
+      if (padState.RT) this.status.RT = padState.RT;
+      if ((padState.LEFT_STICK_AMOUNT ?? 0) > (this.status.LEFT_STICK_AMOUNT ?? 0)) {
+        this.status.LEFT_STICK_AMOUNT = padState.LEFT_STICK_AMOUNT;
+        this.status.LEFT_STICK_ANGLE = padState.LEFT_STICK_ANGLE;
+      }
+      if ((padState.RIGHT_STICK_AMOUNT ?? 0) > (this.status.RIGHT_STICK_AMOUNT ?? 0)) {
+        this.status.RIGHT_STICK_AMOUNT = padState.RIGHT_STICK_AMOUNT;
+        this.status.RIGHT_STICK_ANGLE = padState.RIGHT_STICK_ANGLE;
+      }
+    }
+  }
+  updateChanges(current, previous) {
+    for (const key in current.press) {
+      current.press[key] = 0;
+    }
+    for (const key in current.release) {
+      current.release[key] = 0;
+    }
+    for (const key in previous) {
+      if (key === "press" || key === "release") continue;
+      if (previous[key] && !current[key]) {
+        current.release[key] = 1;
+      }
+    }
+    for (const key in current) {
+      if (key === "press" || key === "release") continue;
+      if (current[key] && !previous[key]) {
+        current.press[key] = 1;
+      }
+    }
+    for (const key in previous) {
+      if (key === "press" || key === "release") continue;
+      previous[key] = 0;
+    }
+    for (const key in current) {
+      if (key === "press" || key === "release") continue;
+      previous[key] = current[key];
+    }
+  }
+};
+
+// src/shared/constants.ts
+var NORMALIZED_SCALE = 200;
+var OUT_OF_BOUNDS = -1e4;
+var PREVENT_DEFAULT_REGEX = /Escape|(F\d+)/;
+var TOUCH_MOUSE_ID = "mouse";
+
+// src/shared/utils.ts
+var hasDocument = typeof document !== "undefined";
+var computeRelativePosition = /* @__PURE__ */ __name((canvas, clientX, clientY) => {
+  const rect = canvas.getBoundingClientRect();
+  const min = Math.min(canvas.clientWidth, canvas.clientHeight) || 1;
+  const x = (clientX - rect.left - canvas.clientWidth / 2) / min * NORMALIZED_SCALE;
+  const y = (canvas.clientHeight / 2 - (clientY - rect.top)) / min * NORMALIZED_SCALE;
+  return {
+    x,
+    y
+  };
+}, "computeRelativePosition");
+
+// src/devices/keyboard.ts
+var KeyboardInput = class {
+  static {
+    __name(this, "KeyboardInput");
+  }
+  state = {
+    press: {},
+    release: {},
+    UP: 0,
+    DOWN: 0,
+    LEFT: 0,
+    RIGHT: 0
+  };
+  previous = {};
+  // Track only keys that changed since last update() — avoids O(n) iteration of all keys
+  dirtyKeys = /* @__PURE__ */ new Set();
+  constructor(target = hasDocument ? document : void 0) {
+    if (!target) {
+      return;
+    }
+    target.addEventListener("keydown", (event) => this.handleKeyDown(event));
+    target.addEventListener("keyup", (event) => this.handleKeyUp(event));
+  }
+  convertCode(code) {
+    let res = "";
+    let low = false;
+    for (let i = 0; i < code.length; i++) {
+      const c = code.charAt(i);
+      if (c === c.toUpperCase() && low) {
+        res += "_";
+        low = false;
+      } else {
+        low = true;
+      }
+      res += c.toUpperCase();
+    }
+    return res;
+  }
+  handleKeyDown(event) {
+    if (!(event.altKey || event.ctrlKey || event.metaKey || PREVENT_DEFAULT_REGEX.test(event.key))) {
+      event.preventDefault();
+    }
+    const codeKey = this.convertCode(event.code);
+    const upperKey = event.key.toUpperCase();
+    this.state[codeKey] = 1;
+    this.state[upperKey] = 1;
+    this.dirtyKeys.add(codeKey);
+    this.dirtyKeys.add(upperKey);
+    this.updateDirectional();
+  }
+  handleKeyUp(event) {
+    const codeKey = this.convertCode(event.code);
+    const upperKey = event.key.toUpperCase();
+    this.state[codeKey] = 0;
+    this.state[upperKey] = 0;
+    this.dirtyKeys.add(codeKey);
+    this.dirtyKeys.add(upperKey);
+    this.updateDirectional();
+  }
+  updateDirectional() {
+    this.state.UP = this.state.KEY_W || this.state.ARROW_UP || 0;
+    this.state.DOWN = this.state.KEY_S || this.state.ARROW_DOWN || 0;
+    this.state.LEFT = this.state.KEY_A || this.state.ARROW_LEFT || 0;
+    this.state.RIGHT = this.state.KEY_D || this.state.ARROW_RIGHT || 0;
+  }
+  update() {
+    for (const key of this.dirtyKeys) {
+      if (this.state.press[key]) this.state.press[key] = 0;
+      if (this.state.release[key]) this.state.release[key] = 0;
+    }
+    for (const key of this.dirtyKeys) {
+      const current = this.state[key];
+      const prev = this.previous[key] || 0;
+      if (current && !prev) {
+        this.state.press[key] = 1;
+      } else if (!current && prev) {
+        this.state.release[key] = 1;
+      }
+      this.previous[key] = current;
+    }
+    this.dirtyKeys.clear();
+  }
+  reset() {
+    for (const key in this.state) {
+      if (key === "press" || key === "release") continue;
+      this.state[key] = 0;
+    }
+    for (const key in this.previous) {
+      this.previous[key] = 0;
+    }
+    this.dirtyKeys.clear();
+  }
+};
+
+// src/devices/mouse.ts
+var MouseInput = class {
+  static {
+    __name(this, "MouseInput");
+  }
+  state = {
+    x: OUT_OF_BOUNDS,
+    y: OUT_OF_BOUNDS,
+    pressed: 0,
+    left: 0,
+    middle: 0,
+    right: 0,
+    press: 0,
+    release: 0,
+    wheel: 0
+  };
+  previousPressed = false;
+  wheel = 0;
+  canvas;
+  removeListeners;
+  constructor(canvas) {
+    if (canvas) {
+      this.setCanvas(canvas);
+    }
+  }
+  setCanvas(canvas) {
+    this.detach();
+    this.canvas = canvas;
+    this.attach();
+  }
+  syncFromTouch(x, y, touching) {
+    this.state.x = x;
+    this.state.y = y;
+    if (touching) {
+      this.state.left = 1;
+      this.state.middle = 0;
+      this.state.right = 0;
+      this.state.pressed = 1;
+    } else {
+      this.state.left = 0;
+      this.state.middle = 0;
+      this.state.right = 0;
+      this.state.pressed = 0;
+    }
+  }
+  update() {
+    if (this.state.pressed && !this.previousPressed) {
+      this.previousPressed = true;
+      this.state.press = 1;
+    } else {
+      this.state.press = 0;
+    }
+    if (!this.state.pressed && this.previousPressed) {
+      this.previousPressed = false;
+      this.state.release = 1;
+    } else {
+      this.state.release = 0;
+    }
+    this.state.wheel = this.wheel;
+    this.wheel = 0;
+  }
+  attach() {
+    if (!hasDocument) {
+      return;
+    }
+    const target = document;
+    const onDown = /* @__PURE__ */ __name((event) => this.handleMouseDown(event), "onDown");
+    const onMove = /* @__PURE__ */ __name((event) => this.handleMouseMove(event), "onMove");
+    const onUp = /* @__PURE__ */ __name((event) => this.handleMouseUp(event), "onUp");
+    const onWheel = /* @__PURE__ */ __name((event) => this.handleWheel(event), "onWheel");
+    const onDomWheel = /* @__PURE__ */ __name((event) => this.handleWheel(event), "onDomWheel");
+    target.addEventListener("mousedown", onDown, {
+      passive: false
+    });
+    target.addEventListener("mousemove", onMove, {
+      passive: false
+    });
+    target.addEventListener("mouseup", onUp, {
+      passive: false
+    });
+    target.addEventListener("mousewheel", onWheel, {
+      passive: false
+    });
+    target.addEventListener("DOMMouseScroll", onDomWheel, {
+      passive: false
+    });
+    this.removeListeners = () => {
+      target.removeEventListener("mousedown", onDown);
+      target.removeEventListener("mousemove", onMove);
+      target.removeEventListener("mouseup", onUp);
+      target.removeEventListener("mousewheel", onWheel);
+      target.removeEventListener("DOMMouseScroll", onDomWheel);
+    };
+  }
+  detach() {
+    this.removeListeners?.();
+    this.removeListeners = void 0;
+    this.canvas = void 0;
+  }
+  handleMouseDown(event) {
+    if (!this.canvas) return;
+    event.preventDefault();
+    const { x, y } = computeRelativePosition(this.canvas, event.clientX, event.clientY);
+    this.state.x = x;
+    this.state.y = y;
+    switch (event.button) {
+      case 0:
+        this.state.left = 1;
+        break;
+      case 1:
+        this.state.middle = 1;
+        break;
+      case 2:
+        this.state.right = 1;
+        break;
+    }
+    this.state.pressed = Math.min(1, this.state.left + this.state.right + this.state.middle);
+  }
+  handleMouseMove(event) {
+    if (!this.canvas) return;
+    event.preventDefault();
+    const { x, y } = computeRelativePosition(this.canvas, event.clientX, event.clientY);
+    this.state.x = x;
+    this.state.y = y;
+  }
+  handleMouseUp(event) {
+    if (!this.canvas) return;
+    event.preventDefault();
+    const { x, y } = computeRelativePosition(this.canvas, event.clientX, event.clientY);
+    this.state.x = x;
+    this.state.y = y;
+    switch (event.button) {
+      case 0:
+        this.state.left = 0;
+        break;
+      case 1:
+        this.state.middle = 0;
+        break;
+      case 2:
+        this.state.right = 0;
+        break;
+    }
+    this.state.pressed = Math.min(1, this.state.left + this.state.right + this.state.middle);
+  }
+  handleWheel(event) {
+    const wheelEvent = event;
+    if (typeof wheelEvent.deltaY === "number" && wheelEvent.deltaY !== 0) {
+      this.wheel = wheelEvent.deltaY > 0 ? -1 : 1;
+    } else if (typeof wheelEvent.wheelDelta === "number" && wheelEvent.wheelDelta !== 0) {
+      this.wheel = wheelEvent.wheelDelta < 0 ? -1 : 1;
+    } else if (typeof wheelEvent.detail === "number" && wheelEvent.detail !== 0) {
+      this.wheel = wheelEvent.detail > 0 ? -1 : 1;
+    } else {
+      this.wheel = 0;
+    }
+    event.preventDefault();
+  }
+};
+
+// src/devices/touch.ts
+var TouchInput = class {
+  static {
+    __name(this, "TouchInput");
+  }
+  mouse;
+  state = {
+    touching: 0,
+    x: 0,
+    y: 0,
+    press: 0,
+    release: 0,
+    touches: []
+  };
+  touches = /* @__PURE__ */ new Map();
+  previousTouching = false;
+  canvas;
+  removeListeners;
+  constructor(mouse, canvas) {
+    this.mouse = mouse;
+    if (canvas) {
+      this.setCanvas(canvas);
+    }
+  }
+  setCanvas(canvas) {
+    this.detach();
+    this.canvas = canvas;
+    this.attach();
+  }
+  update() {
+    this.syncMouseTouch();
+    const list = [];
+    for (const [id, { x, y }] of this.touches.entries()) {
+      list.push({
+        id,
+        x,
+        y
+      });
+      this.state.x = x;
+      this.state.y = y;
+    }
+    this.state.touches = list;
+    this.state.touching = this.touches.size > 0 ? 1 : 0;
+    if (this.state.touching && !this.previousTouching) {
+      this.previousTouching = true;
+      this.state.press = 1;
+    } else {
+      this.state.press = 0;
+    }
+    if (!this.state.touching && this.previousTouching) {
+      this.previousTouching = false;
+      this.state.release = 1;
+    } else {
+      this.state.release = 0;
+    }
+  }
+  syncMouseTouch() {
+    const mouseState = this.mouse.state;
+    if (mouseState.pressed) {
+      this.touches.set(TOUCH_MOUSE_ID, {
+        x: mouseState.x,
+        y: mouseState.y
+      });
+    } else {
+      this.touches.delete(TOUCH_MOUSE_ID);
+    }
+  }
+  attach() {
+    if (!hasDocument) return;
+    const onStart = /* @__PURE__ */ __name((event) => this.handleTouchStart(event), "onStart");
+    const onMove = /* @__PURE__ */ __name((event) => this.handleTouchMove(event), "onMove");
+    const onEnd = /* @__PURE__ */ __name((event) => this.handleTouchEnd(event), "onEnd");
+    document.addEventListener("touchstart", onStart, {
+      passive: false
+    });
+    document.addEventListener("touchmove", onMove, {
+      passive: false
+    });
+    document.addEventListener("touchend", onEnd, {
+      passive: false
+    });
+    document.addEventListener("touchcancel", onEnd, {
+      passive: false
+    });
+    this.removeListeners = () => {
+      document.removeEventListener("touchstart", onStart);
+      document.removeEventListener("touchmove", onMove);
+      document.removeEventListener("touchend", onEnd);
+      document.removeEventListener("touchcancel", onEnd);
+    };
+  }
+  detach() {
+    this.removeListeners?.();
+    this.removeListeners = void 0;
+    this.canvas = void 0;
+    this.touches.clear();
+  }
+  handleTouchStart(event) {
+    if (!this.canvas) return;
+    event.preventDefault();
+    event.stopPropagation();
+    for (let i = 0; i < event.changedTouches.length; i++) {
+      const t = event.changedTouches[i];
+      const { x, y } = computeRelativePosition(this.canvas, t.clientX, t.clientY);
+      this.touches.set(t.identifier, {
+        x,
+        y
+      });
+      this.mouse.syncFromTouch(x, y, true);
+    }
+  }
+  handleTouchMove(event) {
+    if (!this.canvas) return;
+    event.preventDefault();
+    event.stopPropagation();
+    for (let i = 0; i < event.changedTouches.length; i++) {
+      const t = event.changedTouches[i];
+      if (!this.touches.has(t.identifier)) continue;
+      const { x, y } = computeRelativePosition(this.canvas, t.clientX, t.clientY);
+      this.touches.set(t.identifier, {
+        x,
+        y
+      });
+      this.mouse.syncFromTouch(x, y, true);
+    }
+  }
+  handleTouchEnd(event) {
+    if (!this.canvas) return;
+    event.preventDefault();
+    event.stopPropagation();
+    for (let i = 0; i < event.changedTouches.length; i++) {
+      const t = event.changedTouches[i];
+      this.touches.delete(t.identifier);
+    }
+    this.mouse.syncFromTouch(this.state.x, this.state.y, false);
+  }
+};
+
+// src/core/input-manager.ts
+var Input = class {
+  static {
+    __name(this, "Input");
+  }
+  keyboard;
+  mouse;
+  touch;
+  gamepad;
+  runtime;
+  constructor(canvas, runtime) {
+    this.runtime = runtime;
+    this.keyboard = new KeyboardInput();
+    this.mouse = new MouseInput(canvas);
+    this.touch = new TouchInput(this.mouse, canvas);
+    this.gamepad = new GamepadInput();
+  }
+  /**
+  * Poll all devices for state updates.
+  */
+  update() {
+    this.keyboard.update();
+    this.mouse.update();
+    this.touch.update();
+    this.gamepad.update();
+  }
+  getKeyboard() {
+    if (!this.keyboard || !this.keyboard.state) {
+      reportRuntimeError(this.runtime?.listener, APIErrorCode.E7052, {
+        error: "Keyboard state not available"
+      });
+      return {};
+    }
+    return this.keyboard.state;
+  }
+  getMouse() {
+    if (!this.mouse || !this.mouse.state) {
+      reportRuntimeError(this.runtime?.listener, APIErrorCode.E7052, {
+        error: "Mouse state not available"
+      });
+      return {};
+    }
+    return this.mouse.state;
+  }
+  getTouch() {
+    if (!this.touch || !this.touch.state) {
+      reportRuntimeError(this.runtime?.listener, APIErrorCode.E7052, {
+        error: "Touch state not available"
+      });
+      return {};
+    }
+    return this.touch.state;
+  }
+  getGamepad() {
+    if (!this.gamepad || !navigator.getGamepads) {
+      reportRuntimeError(this.runtime?.listener, APIErrorCode.E7051, {
+        device: "gamepad"
+      });
+    }
+    return this.gamepad;
+  }
+  setCanvas(canvas) {
+    this.mouse.setCanvas(canvas);
+    this.touch.setCanvas(canvas);
+  }
+};
+export {
+  Input
+};
+//# sourceMappingURL=input-manager.mjs.map