@yagejs/input 0.1.0

package/dist/index.js

@@ -0,0 +1,657 @@
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+
+// src/InputPlugin.ts
+import { DebugRegistryKey } from "@yagejs/debug/api";
+
+// src/InputManager.ts
+import { Vec2 } from "@yagejs/core";
+var InputManager = class {
+  static {
+    __name(this, "InputManager");
+  }
+  pressedKeys = /* @__PURE__ */ new Set();
+  justPressedKeys = /* @__PURE__ */ new Set();
+  justReleasedKeys = /* @__PURE__ */ new Set();
+  holdStart = /* @__PURE__ */ new Map();
+  actionMap = /* @__PURE__ */ new Map();
+  defaultBindings = /* @__PURE__ */ new Map();
+  groups = /* @__PURE__ */ new Map();
+  actionGroups = /* @__PURE__ */ new Map();
+  disabledGroups = /* @__PURE__ */ new Set();
+  pointerScreenPos = Vec2.ZERO;
+  pointerDownState = false;
+  camera = null;
+  elapsedMs = 0;
+  listenResolve = null;
+  // -- Action-based queries --
+  /** Whether any key mapped to this action is currently held. */
+  isPressed(action) {
+    if (!this.isActionEnabled(action)) return false;
+    return this.anyKeyInSet(action, this.pressedKeys);
+  }
+  /** Whether any key mapped to this action was pressed this frame. */
+  isJustPressed(action) {
+    if (!this.isActionEnabled(action)) return false;
+    return this.anyKeyInSet(action, this.justPressedKeys);
+  }
+  /** Whether any key mapped to this action was released this frame. */
+  isJustReleased(action) {
+    if (!this.isActionEnabled(action)) return false;
+    return this.anyKeyInSet(action, this.justReleasedKeys);
+  }
+  /** Returns true if any key bound to the action exists in the given set. */
+  anyKeyInSet(action, set) {
+    const keys = this.actionMap.get(action);
+    if (!keys) return false;
+    for (const key of keys) {
+      if (set.has(key)) return true;
+    }
+    return false;
+  }
+  /** Milliseconds the action has been held. Returns 0 if not held. */
+  getHoldDuration(action) {
+    if (!this.isActionEnabled(action)) return 0;
+    const keys = this.actionMap.get(action);
+    if (!keys) return 0;
+    let maxDuration = 0;
+    for (const key of keys) {
+      const start = this.holdStart.get(key);
+      if (start !== void 0) {
+        maxDuration = Math.max(maxDuration, this.elapsedMs - start);
+      }
+    }
+    return maxDuration;
+  }
+  /** Whether the action has been held for at least `minTime` ms. */
+  isHeldFor(action, minTime) {
+    return this.getHoldDuration(action) >= minTime;
+  }
+  // -- Axis helpers --
+  /** Returns -1, 0, or 1 based on negative/positive action states. */
+  getAxis(negative, positive) {
+    const neg = this.isPressed(negative) ? 1 : 0;
+    const pos = this.isPressed(positive) ? 1 : 0;
+    return pos - neg;
+  }
+  /** Returns a Vec2 from four directional actions. Not normalized. */
+  getVector(left, right, up, down) {
+    const x = this.getAxis(left, right);
+    const y = this.getAxis(up, down);
+    return new Vec2(x, y);
+  }
+  // -- Pointer --
+  /** Pointer position in world coordinates (via Camera), or screen coords if no camera. */
+  getPointerPosition() {
+    if (this.camera) {
+      const w = this.camera.screenToWorld(
+        this.pointerScreenPos.x,
+        this.pointerScreenPos.y
+      );
+      return new Vec2(w.x, w.y);
+    }
+    return this.pointerScreenPos;
+  }
+  /** Raw pointer position in screen coordinates. */
+  getPointerScreenPosition() {
+    return this.pointerScreenPos;
+  }
+  /** Whether any pointer button is currently held. */
+  isPointerDown() {
+    return this.pointerDownState;
+  }
+  // -- Runtime action map management --
+  /** Replace the entire action map and store it as the default for {@link resetBindings}. */
+  setActionMap(actions) {
+    this.actionMap.clear();
+    this.defaultBindings.clear();
+    for (const [action, keys] of Object.entries(actions)) {
+      this.actionMap.set(action, [...keys]);
+      this.defaultBindings.set(action, [...keys]);
+    }
+  }
+  /** Add a key binding to an action. Creates the action if it doesn't exist. */
+  bindKey(action, key) {
+    let keys = this.actionMap.get(action);
+    if (!keys) {
+      keys = [];
+      this.actionMap.set(action, keys);
+    }
+    if (!keys.includes(key)) {
+      keys.push(key);
+    }
+  }
+  /** Remove a key binding from an action. */
+  unbindKey(action, key) {
+    const keys = this.actionMap.get(action);
+    if (!keys) return;
+    const idx = keys.indexOf(key);
+    if (idx !== -1) keys.splice(idx, 1);
+  }
+  // -- Binding queries --
+  /** Returns the current key bindings for an action, or an empty array if unmapped. */
+  getBindings(action) {
+    return this.actionMap.get(action) ?? [];
+  }
+  /** Returns all action names that have the given key bound. */
+  getActionsForKey(key) {
+    const result = [];
+    for (const [action, keys] of this.actionMap) {
+      if (keys.includes(key)) result.push(action);
+    }
+    return result;
+  }
+  // -- Rebinding --
+  /**
+   * Rebind a key to an action with optional conflict detection.
+   * Conflicts are only detected between actions sharing at least one group.
+   */
+  rebind(action, key, opts) {
+    const conflict = opts?.conflict ?? "reject";
+    const slot = opts?.slot;
+    const conflictAction = this.findConflictInGroups(action, key);
+    if (conflictAction && conflict === "reject") {
+      return { ok: false, conflict: { action: conflictAction, key } };
+    }
+    if (conflictAction && conflict === "replace") {
+      this.unbindKey(conflictAction, key);
+    }
+    let keys = this.actionMap.get(action);
+    if (!keys) {
+      keys = [];
+      this.actionMap.set(action, keys);
+    }
+    const existingIdx = keys.indexOf(key);
+    let targetSlot = slot;
+    if (targetSlot !== void 0 && existingIdx !== -1 && existingIdx !== targetSlot) {
+      keys.splice(existingIdx, 1);
+      if (targetSlot > existingIdx) targetSlot--;
+    }
+    if (targetSlot !== void 0 && targetSlot < keys.length) {
+      keys[targetSlot] = key;
+    } else if (!keys.includes(key)) {
+      keys.push(key);
+    }
+    return { ok: true };
+  }
+  /**
+   * Finds the first action that uses the given key AND shares at least one
+   * group with the target action. Ungrouped actions never conflict.
+   */
+  findConflictInGroups(action, key) {
+    const myGroups = this.actionGroups.get(action);
+    if (!myGroups || myGroups.size === 0) return null;
+    for (const [otherAction, otherKeys] of this.actionMap) {
+      if (otherAction === action) continue;
+      if (!otherKeys.includes(key)) continue;
+      const otherGroups = this.actionGroups.get(otherAction);
+      if (!otherGroups) continue;
+      for (const g of myGroups) {
+        if (otherGroups.has(g)) return otherAction;
+      }
+    }
+    return null;
+  }
+  // -- Binding persistence --
+  /** Reset bindings to defaults. If an action name is provided, only reset that action. */
+  resetBindings(action) {
+    if (action !== void 0) {
+      const defaults = this.defaultBindings.get(action);
+      if (defaults) {
+        this.actionMap.set(action, [...defaults]);
+      }
+    } else {
+      this.actionMap.clear();
+      for (const [a, keys] of this.defaultBindings) {
+        this.actionMap.set(a, [...keys]);
+      }
+    }
+  }
+  /** Export the current bindings as a plain object for serialization. */
+  exportBindings() {
+    const result = {};
+    for (const [action, keys] of this.actionMap) {
+      result[action] = [...keys];
+    }
+    return result;
+  }
+  /** Load bindings from a plain object. Resets to defaults first, then overlays the provided map. */
+  loadBindings(map) {
+    this.resetBindings();
+    for (const [action, keys] of Object.entries(map)) {
+      this.actionMap.set(action, [...keys]);
+    }
+  }
+  // -- Group management --
+  /** Configure input groups. Group name -> array of action names. */
+  setGroups(groups) {
+    this.groups.clear();
+    this.actionGroups.clear();
+    for (const [name, actions] of Object.entries(groups)) {
+      this.groups.set(name, new Set(actions));
+      for (const action of actions) {
+        let set = this.actionGroups.get(action);
+        if (!set) {
+          set = /* @__PURE__ */ new Set();
+          this.actionGroups.set(action, set);
+        }
+        set.add(name);
+      }
+    }
+  }
+  /** Enable a group by name. */
+  enableGroup(name) {
+    this.disabledGroups.delete(name);
+  }
+  /** Disable a group by name. Actions only in disabled groups become inactive. */
+  disableGroup(name) {
+    this.disabledGroups.add(name);
+  }
+  /** Set exactly these groups as active; all others are disabled. */
+  setActiveGroups(names) {
+    this.disabledGroups.clear();
+    for (const group of this.groups.keys()) {
+      if (!names.includes(group)) {
+        this.disabledGroups.add(group);
+      }
+    }
+  }
+  /** Whether a group is currently enabled. Returns true for unknown group names. */
+  isGroupEnabled(name) {
+    return !this.disabledGroups.has(name);
+  }
+  /** Get all configured group names. */
+  getGroups() {
+    return Array.from(this.groups.keys());
+  }
+  /** Get the action names belonging to a group. Returns empty array for unknown groups. */
+  getGroupActions(name) {
+    const set = this.groups.get(name);
+    return set ? Array.from(set) : [];
+  }
+  /** Returns true if the action is ungrouped or any of its groups is enabled. */
+  isActionEnabled(action) {
+    const groupSet = this.actionGroups.get(action);
+    if (!groupSet || groupSet.size === 0) return true;
+    for (const group of groupSet) {
+      if (!this.disabledGroups.has(group)) return true;
+    }
+    return false;
+  }
+  // -- Key listening --
+  /** Returns a promise that resolves with the next key code pressed. Intercepts the key. */
+  listenForNextKey() {
+    this.cancelListen();
+    return new Promise((resolve) => {
+      this.listenResolve = resolve;
+    });
+  }
+  /** Cancel an active {@link listenForNextKey}. Resolves the pending promise with `null`. */
+  cancelListen() {
+    if (this.listenResolve) {
+      const resolve = this.listenResolve;
+      this.listenResolve = null;
+      resolve(null);
+    }
+  }
+  // -- Internal methods (called by InputPlugin / Systems) --
+  /** @internal */
+  _onKeyDown(code) {
+    if (this.listenResolve) {
+      const resolve = this.listenResolve;
+      this.listenResolve = null;
+      resolve(code);
+      return;
+    }
+    if (!this.pressedKeys.has(code)) {
+      this.pressedKeys.add(code);
+      this.justPressedKeys.add(code);
+      this.holdStart.set(code, this.elapsedMs);
+    }
+  }
+  /** @internal */
+  _onKeyUp(code) {
+    if (this.pressedKeys.has(code)) {
+      this.pressedKeys.delete(code);
+      this.justReleasedKeys.add(code);
+      this.holdStart.delete(code);
+    }
+  }
+  /** @internal */
+  _onPointerMove(screenX, screenY) {
+    this.pointerScreenPos = new Vec2(screenX, screenY);
+  }
+  /** @internal */
+  _onPointerDown() {
+    this.pointerDownState = true;
+  }
+  /** @internal */
+  _onPointerUp() {
+    this.pointerDownState = false;
+  }
+  /** @internal Clear per-frame justPressed/justReleased flags. */
+  _clearFrameState() {
+    this.justPressedKeys.clear();
+    this.justReleasedKeys.clear();
+  }
+  /** @internal Set camera for pointer world-coord conversion. */
+  _setCamera(camera) {
+    this.camera = camera;
+  }
+  /** Get all configured action names. */
+  getActionNames() {
+    return Array.from(this.actionMap.keys());
+  }
+  /** @internal Advance the elapsed game-time clock. Called by InputPollSystem. */
+  _advanceTime(dtMs) {
+    this.elapsedMs += dtMs;
+  }
+};
+
+// src/types.ts
+import { ServiceKey } from "@yagejs/core";
+var InputManagerKey = new ServiceKey("inputManager");
+
+// src/InputPollSystem.ts
+import { System, Phase } from "@yagejs/core";
+var InputPollSystem = class extends System {
+  static {
+    __name(this, "InputPollSystem");
+  }
+  phase = Phase.EarlyUpdate;
+  priority = -100;
+  update(dt) {
+    this.use(InputManagerKey)._advanceTime(dt);
+  }
+};
+
+// src/InputClearSystem.ts
+import { System as System2, Phase as Phase2 } from "@yagejs/core";
+var InputClearSystem = class extends System2 {
+  static {
+    __name(this, "InputClearSystem");
+  }
+  phase = Phase2.EndOfFrame;
+  priority = 9e3;
+  update() {
+    this.use(InputManagerKey)._clearFrameState();
+  }
+};
+
+// src/InputDebugContributor.ts
+var CROSSHAIR_SIZE = 10;
+var CROSSHAIR_COLOR = 16711935;
+var InputDebugContributor = class {
+  constructor(manager) {
+    this.manager = manager;
+  }
+  manager;
+  static {
+    __name(this, "InputDebugContributor");
+  }
+  name = "input";
+  flags = ["actions", "pointer"];
+  drawWorld(api) {
+    if (!api.isFlagEnabled("pointer")) return;
+    const pos = this.manager.getPointerPosition();
+    const g = api.acquireGraphics();
+    if (!g) return;
+    const size = CROSSHAIR_SIZE / api.cameraZoom;
+    const lineWidth = 1 / api.cameraZoom;
+    g.moveTo(pos.x - size, pos.y).lineTo(pos.x + size, pos.y).moveTo(pos.x, pos.y - size).lineTo(pos.x, pos.y + size).stroke({ width: lineWidth, color: CROSSHAIR_COLOR });
+  }
+  drawHud(api) {
+    if (!api.isFlagEnabled("actions")) return;
+    const pressed = this.manager.getActionNames().filter((action) => this.manager.isPressed(action));
+    const label = pressed.length > 0 ? pressed.join(", ") : "(none)";
+    api.addLine(`Input: ${label}`);
+    const groups = this.manager.getGroups();
+    if (groups.length > 0) {
+      const disabled = groups.filter((g) => !this.manager.isGroupEnabled(g));
+      if (disabled.length > 0) {
+        api.addLine(`Disabled groups: ${disabled.join(", ")}`);
+      }
+    }
+  }
+};
+
+// src/InputPlugin.ts
+var MOUSE_BUTTON_MAP = {
+  0: "MouseLeft",
+  1: "MouseMiddle",
+  2: "MouseRight"
+};
+var InputPlugin = class {
+  static {
+    __name(this, "InputPlugin");
+  }
+  name = "input";
+  version = "2.0.0";
+  config;
+  manager;
+  context;
+  cleanupFns = [];
+  constructor(config) {
+    this.config = config ?? {};
+  }
+  install(context) {
+    this.context = context;
+    this.manager = new InputManager();
+    if (this.config.actions) {
+      this.manager.setActionMap(this.config.actions);
+    }
+    if (this.config.groups) {
+      this.manager.setGroups(this.config.groups);
+    }
+    if (this.config.cameraKey) {
+      const camera = context.tryResolve(this.config.cameraKey);
+      if (camera) {
+        this.manager._setCamera(camera);
+      }
+    }
+    const renderer = this.config.rendererKey ? context.tryResolve(this.config.rendererKey) : void 0;
+    const pointerTarget = this.config.target ?? renderer?.canvas ?? document;
+    const pointerElement = this.config.target ?? renderer?.canvas ?? null;
+    const preventSet = new Set(this.config.preventDefaultKeys ?? []);
+    const onKeyDown = /* @__PURE__ */ __name((e) => {
+      const ke = e;
+      if (ke.repeat) return;
+      if (preventSet.has(ke.code)) ke.preventDefault();
+      this.manager._onKeyDown(ke.code);
+    }, "onKeyDown");
+    const onKeyUp = /* @__PURE__ */ __name((e) => {
+      const ke = e;
+      if (preventSet.has(ke.code)) ke.preventDefault();
+      this.manager._onKeyUp(ke.code);
+    }, "onKeyUp");
+    window.addEventListener("keydown", onKeyDown);
+    window.addEventListener("keyup", onKeyUp);
+    this.cleanupFns.push(
+      () => window.removeEventListener("keydown", onKeyDown),
+      () => window.removeEventListener("keyup", onKeyUp)
+    );
+    const onPointerMove = /* @__PURE__ */ __name((e) => {
+      const pe = e;
+      if (pointerElement) {
+        const rect = pointerElement.getBoundingClientRect();
+        this.manager._onPointerMove(pe.clientX - rect.left, pe.clientY - rect.top);
+      } else {
+        this.manager._onPointerMove(pe.clientX, pe.clientY);
+      }
+    }, "onPointerMove");
+    const onPointerDown = /* @__PURE__ */ __name((e) => {
+      const pe = e;
+      this.manager._onPointerDown();
+      const mouseKey = MOUSE_BUTTON_MAP[pe.button];
+      if (mouseKey) this.manager._onKeyDown(mouseKey);
+    }, "onPointerDown");
+    const onPointerUp = /* @__PURE__ */ __name((e) => {
+      const pe = e;
+      this.manager._onPointerUp();
+      const mouseKey = MOUSE_BUTTON_MAP[pe.button];
+      if (mouseKey) this.manager._onKeyUp(mouseKey);
+    }, "onPointerUp");
+    const onPointerCancel = /* @__PURE__ */ __name(() => {
+      this.manager._onPointerUp();
+      this.manager._onKeyUp("MouseLeft");
+      this.manager._onKeyUp("MouseMiddle");
+      this.manager._onKeyUp("MouseRight");
+    }, "onPointerCancel");
+    pointerTarget.addEventListener("pointerdown", onPointerDown);
+    window.addEventListener("pointermove", onPointerMove);
+    window.addEventListener("pointerup", onPointerUp);
+    window.addEventListener("pointercancel", onPointerCancel);
+    this.cleanupFns.push(
+      () => pointerTarget.removeEventListener("pointerdown", onPointerDown),
+      () => window.removeEventListener("pointermove", onPointerMove),
+      () => window.removeEventListener("pointerup", onPointerUp),
+      () => window.removeEventListener("pointercancel", onPointerCancel)
+    );
+    context.register(InputManagerKey, this.manager);
+  }
+  registerSystems(scheduler) {
+    scheduler.add(new InputPollSystem());
+    scheduler.add(new InputClearSystem());
+  }
+  onStart() {
+    const registry = this.context.tryResolve(DebugRegistryKey);
+    registry?.register(new InputDebugContributor(this.manager));
+  }
+  onDestroy() {
+    for (const cleanup of this.cleanupFns) {
+      cleanup();
+    }
+    this.cleanupFns.length = 0;
+  }
+};
+
+// src/keyDisplayNames.ts
+var KEY_DISPLAY_NAMES = {
+  // Letters
+  KeyA: "A",
+  KeyB: "B",
+  KeyC: "C",
+  KeyD: "D",
+  KeyE: "E",
+  KeyF: "F",
+  KeyG: "G",
+  KeyH: "H",
+  KeyI: "I",
+  KeyJ: "J",
+  KeyK: "K",
+  KeyL: "L",
+  KeyM: "M",
+  KeyN: "N",
+  KeyO: "O",
+  KeyP: "P",
+  KeyQ: "Q",
+  KeyR: "R",
+  KeyS: "S",
+  KeyT: "T",
+  KeyU: "U",
+  KeyV: "V",
+  KeyW: "W",
+  KeyX: "X",
+  KeyY: "Y",
+  KeyZ: "Z",
+  // Digits
+  Digit0: "0",
+  Digit1: "1",
+  Digit2: "2",
+  Digit3: "3",
+  Digit4: "4",
+  Digit5: "5",
+  Digit6: "6",
+  Digit7: "7",
+  Digit8: "8",
+  Digit9: "9",
+  // Function keys
+  F1: "F1",
+  F2: "F2",
+  F3: "F3",
+  F4: "F4",
+  F5: "F5",
+  F6: "F6",
+  F7: "F7",
+  F8: "F8",
+  F9: "F9",
+  F10: "F10",
+  F11: "F11",
+  F12: "F12",
+  // Modifiers
+  ShiftLeft: "Left Shift",
+  ShiftRight: "Right Shift",
+  ControlLeft: "Left Ctrl",
+  ControlRight: "Right Ctrl",
+  AltLeft: "Left Alt",
+  AltRight: "Right Alt",
+  MetaLeft: "Left Meta",
+  MetaRight: "Right Meta",
+  // Arrows
+  ArrowUp: "Up",
+  ArrowDown: "Down",
+  ArrowLeft: "Left",
+  ArrowRight: "Right",
+  // Common keys
+  Space: "Space",
+  Enter: "Enter",
+  Escape: "Esc",
+  Tab: "Tab",
+  Backspace: "Backspace",
+  Delete: "Delete",
+  Insert: "Insert",
+  Home: "Home",
+  End: "End",
+  PageUp: "Page Up",
+  PageDown: "Page Down",
+  CapsLock: "Caps Lock",
+  NumLock: "Num Lock",
+  ScrollLock: "Scroll Lock",
+  PrintScreen: "Print Screen",
+  Pause: "Pause",
+  ContextMenu: "Menu",
+  // Punctuation / symbols
+  Backquote: "`",
+  Minus: "-",
+  Equal: "=",
+  BracketLeft: "[",
+  BracketRight: "]",
+  Backslash: "\\",
+  Semicolon: ";",
+  Quote: "'",
+  Comma: ",",
+  Period: ".",
+  Slash: "/",
+  // Numpad
+  Numpad0: "Numpad 0",
+  Numpad1: "Numpad 1",
+  Numpad2: "Numpad 2",
+  Numpad3: "Numpad 3",
+  Numpad4: "Numpad 4",
+  Numpad5: "Numpad 5",
+  Numpad6: "Numpad 6",
+  Numpad7: "Numpad 7",
+  Numpad8: "Numpad 8",
+  Numpad9: "Numpad 9",
+  NumpadAdd: "Numpad +",
+  NumpadSubtract: "Numpad -",
+  NumpadMultiply: "Numpad *",
+  NumpadDivide: "Numpad /",
+  NumpadDecimal: "Numpad .",
+  NumpadEnter: "Numpad Enter",
+  // Mouse buttons (synthetic codes from InputPlugin)
+  MouseLeft: "Left Click",
+  MouseMiddle: "Middle Click",
+  MouseRight: "Right Click"
+};
+function getKeyDisplayName(code) {
+  return KEY_DISPLAY_NAMES[code] ?? code;
+}
+__name(getKeyDisplayName, "getKeyDisplayName");
+export {
+  InputManager,
+  InputManagerKey,
+  InputPlugin,
+  getKeyDisplayName
+};
+//# sourceMappingURL=index.js.map