@diffenderfer-games/hub 2.0.0-next.0 → 2.0.0-next.1

package/src/input/edges.ts

@@ -1,55 +1,55 @@
-/**
- * Edge detection for polled buttons: a plain rising edge, and a rising edge
- * that repeats while held (menu navigation: a first step, a pause, then steady
- * steps).
- */
-
-/** Delay before a held direction starts repeating. */
-const FIRST_REPEAT_DELAY_MS = 320;
-/** Interval between repeats while held. */
-const REPEAT_INTERVAL_MS = 130;
-
-/** A monotonic clock in ms. */
-export function nowMs(): number {
-  return typeof performance === 'undefined' ? Date.now() : performance.now();
-}
-
-/** Rising edges of named polled buttons. */
-export class RisingEdges {
-  private readonly wasPressed = new Map<string, boolean>();
-
-  /** Whether `key` went from released to pressed since the last call for it. */
-  rose(key: string, isPressed: boolean): boolean {
-    const wasPressedBefore = this.wasPressed.get(key) === true;
-    this.wasPressed.set(key, isPressed);
-    return isPressed && !wasPressedBefore;
-  }
-}
-
-/** Rising edges that repeat while held. */
-export class RepeatingEdges {
-  private readonly timers = new Map<string, { isHeld: boolean; nextAt: number }>();
-
-  /** Whether `key` fires now: on the press, then after a delay, then steadily while held. */
-  fires(key: string, isPressed: boolean, at: number = nowMs()): boolean {
-    let timer = this.timers.get(key);
-    if (timer === undefined) {
-      timer = { isHeld: false, nextAt: 0 };
-      this.timers.set(key, timer);
-    }
-    if (!isPressed) {
-      timer.isHeld = false;
-      return false;
-    }
-    if (!timer.isHeld) {
-      timer.isHeld = true;
-      timer.nextAt = at + FIRST_REPEAT_DELAY_MS;
-      return true;
-    }
-    if (at >= timer.nextAt) {
-      timer.nextAt = at + REPEAT_INTERVAL_MS;
-      return true;
-    }
-    return false;
-  }
-}
+/**
+ * Edge detection for polled buttons: a plain rising edge, and a rising edge
+ * that repeats while held (menu navigation: a first step, a pause, then steady
+ * steps).
+ */
+
+/** Delay before a held direction starts repeating. */
+const FIRST_REPEAT_DELAY_MS = 320;
+/** Interval between repeats while held. */
+const REPEAT_INTERVAL_MS = 130;
+
+/** A monotonic clock in ms. */
+export function nowMs(): number {
+  return typeof performance === 'undefined' ? Date.now() : performance.now();
+}
+
+/** Rising edges of named polled buttons. */
+export class RisingEdges {
+  private readonly wasPressed = new Map<string, boolean>();
+
+  /** Whether `key` went from released to pressed since the last call for it. */
+  rose(key: string, isPressed: boolean): boolean {
+    const wasPressedBefore = this.wasPressed.get(key) === true;
+    this.wasPressed.set(key, isPressed);
+    return isPressed && !wasPressedBefore;
+  }
+}
+
+/** Rising edges that repeat while held. */
+export class RepeatingEdges {
+  private readonly timers = new Map<string, { isHeld: boolean; nextAt: number }>();
+
+  /** Whether `key` fires now: on the press, then after a delay, then steadily while held. */
+  fires(key: string, isPressed: boolean, at: number = nowMs()): boolean {
+    let timer = this.timers.get(key);
+    if (timer === undefined) {
+      timer = { isHeld: false, nextAt: 0 };
+      this.timers.set(key, timer);
+    }
+    if (!isPressed) {
+      timer.isHeld = false;
+      return false;
+    }
+    if (!timer.isHeld) {
+      timer.isHeld = true;
+      timer.nextAt = at + FIRST_REPEAT_DELAY_MS;
+      return true;
+    }
+    if (at >= timer.nextAt) {
+      timer.nextAt = at + REPEAT_INTERVAL_MS;
+      return true;
+    }
+    return false;
+  }
+}

package/src/input/gamepad.ts

@@ -1,61 +1,61 @@
-/**
- * Reading standard gamepads: button indices, the stick deadzone and the
- * directions a pad is pointing.
- */
-
-/** Standard-gamepad button indices. */
-export const PAD_BUTTON = {
-  A: 0, B: 1, X: 2, Y: 3, LB: 4, RB: 5, LT: 6, RT: 7, SELECT: 8, START: 9, UP: 12, DOWN: 13, LEFT: 14, RIGHT: 15,
-} as const;
-
-/** Stick deflection below this is ignored. */
-export const AXIS_DEADZONE = 0.35;
-
-/** A screen direction. */
-export type Direction = 'up' | 'down' | 'left' | 'right';
-
-/** Which directions are held. */
-export type HeldDirections = Record<Direction, boolean>;
-
-/** The connected gamepads (the browser's list has holes). */
-export function readGamepads(): Gamepad[] {
-  if (typeof navigator === 'undefined' || typeof navigator.getGamepads !== 'function') {
-    return [];
-  }
-  return navigator.getGamepads().filter((pad): pad is Gamepad => pad !== null);
-}
-
-/** Whether `pad` holds button `index`. */
-export function isPadButtonPressed(pad: Gamepad, index: number): boolean {
-  return pad.buttons[index]?.pressed === true;
-}
-
-/** Whether any pad holds button `index`. */
-export function isAnyPadButtonPressed(pads: readonly Gamepad[], index: number): boolean {
-  return pads.some((pad) => isPadButtonPressed(pad, index));
-}
-
-/** The directions one pad points (left stick past `deadzone`, or the d-pad). */
-export function padDirections(pad: Gamepad, deadzone: number): HeldDirections {
-  const horizontal = pad.axes[0] ?? 0;
-  const vertical = pad.axes[1] ?? 0;
-  return {
-    up: vertical < -deadzone || isPadButtonPressed(pad, PAD_BUTTON.UP),
-    down: vertical > deadzone || isPadButtonPressed(pad, PAD_BUTTON.DOWN),
-    left: horizontal < -deadzone || isPadButtonPressed(pad, PAD_BUTTON.LEFT),
-    right: horizontal > deadzone || isPadButtonPressed(pad, PAD_BUTTON.RIGHT),
-  };
-}
-
-/** The directions any pad points. */
-export function anyPadDirections(pads: readonly Gamepad[], deadzone: number): HeldDirections {
-  const held: HeldDirections = { up: false, down: false, left: false, right: false };
-  for (const pad of pads) {
-    const directions = padDirections(pad, deadzone);
-    held.up ||= directions.up;
-    held.down ||= directions.down;
-    held.left ||= directions.left;
-    held.right ||= directions.right;
-  }
-  return held;
-}
+/**
+ * Reading standard gamepads: button indices, the stick deadzone and the
+ * directions a pad is pointing.
+ */
+
+/** Standard-gamepad button indices. */
+export const PAD_BUTTON = {
+  A: 0, B: 1, X: 2, Y: 3, LB: 4, RB: 5, LT: 6, RT: 7, SELECT: 8, START: 9, UP: 12, DOWN: 13, LEFT: 14, RIGHT: 15,
+} as const;
+
+/** Stick deflection below this is ignored. */
+export const AXIS_DEADZONE = 0.35;
+
+/** A screen direction. */
+export type Direction = 'up' | 'down' | 'left' | 'right';
+
+/** Which directions are held. */
+export type HeldDirections = Record<Direction, boolean>;
+
+/** The connected gamepads (the browser's list has holes). */
+export function readGamepads(): Gamepad[] {
+  if (typeof navigator === 'undefined' || typeof navigator.getGamepads !== 'function') {
+    return [];
+  }
+  return navigator.getGamepads().filter((pad): pad is Gamepad => pad !== null);
+}
+
+/** Whether `pad` holds button `index`. */
+export function isPadButtonPressed(pad: Gamepad, index: number): boolean {
+  return pad.buttons[index]?.pressed === true;
+}
+
+/** Whether any pad holds button `index`. */
+export function isAnyPadButtonPressed(pads: readonly Gamepad[], index: number): boolean {
+  return pads.some((pad) => isPadButtonPressed(pad, index));
+}
+
+/** The directions one pad points (left stick past `deadzone`, or the d-pad). */
+export function padDirections(pad: Gamepad, deadzone: number): HeldDirections {
+  const horizontal = pad.axes[0] ?? 0;
+  const vertical = pad.axes[1] ?? 0;
+  return {
+    up: vertical < -deadzone || isPadButtonPressed(pad, PAD_BUTTON.UP),
+    down: vertical > deadzone || isPadButtonPressed(pad, PAD_BUTTON.DOWN),
+    left: horizontal < -deadzone || isPadButtonPressed(pad, PAD_BUTTON.LEFT),
+    right: horizontal > deadzone || isPadButtonPressed(pad, PAD_BUTTON.RIGHT),
+  };
+}
+
+/** The directions any pad points. */
+export function anyPadDirections(pads: readonly Gamepad[], deadzone: number): HeldDirections {
+  const held: HeldDirections = { up: false, down: false, left: false, right: false };
+  for (const pad of pads) {
+    const directions = padDirections(pad, deadzone);
+    held.up ||= directions.up;
+    held.down ||= directions.down;
+    held.left ||= directions.left;
+    held.right ||= directions.right;
+  }
+  return held;
+}

package/src/input/input-events.ts

@@ -1,32 +1,32 @@
-/**
- * The input system's events (`hub.input.on`): typed listeners per event,
- * isolated so one failing listener can't stop the frame loop.
- */
-import type { InputEvents } from './types';
-
-/** Listeners by event name. */
-export class InputEventHub {
-  private readonly listeners: { [Name in keyof InputEvents]: Set<(payload: InputEvents[Name]) => void> } = {
-    focus: new Set(), blur: new Set(), act: new Set(), sourcechange: new Set(), navigate: new Set(),
-  };
-
-  /** Subscribe. Returns the unsubscribe function. */
-  on<Name extends keyof InputEvents>(event: Name, listener: (payload: InputEvents[Name]) => void): () => void {
-    const registered = this.listeners[event];
-    registered.add(listener);
-    return () => {
-      registered.delete(listener);
-    };
-  }
-
-  /** Deliver an event to every listener. */
-  emit<Name extends keyof InputEvents>(event: Name, payload: InputEvents[Name]): void {
-    for (const listener of [...this.listeners[event]]) {
-      try {
-        listener(payload);
-      } catch {
-        // A game's listener failing must not stop the frame loop.
-      }
-    }
-  }
-}
+/**
+ * The input system's events (`hub.input.on`): typed listeners per event,
+ * isolated so one failing listener can't stop the frame loop.
+ */
+import type { InputEvents } from './types';
+
+/** Listeners by event name. */
+export class InputEventHub {
+  private readonly listeners: { [Name in keyof InputEvents]: Set<(payload: InputEvents[Name]) => void> } = {
+    focus: new Set(), blur: new Set(), act: new Set(), sourcechange: new Set(), navigate: new Set(),
+  };
+
+  /** Subscribe. Returns the unsubscribe function. */
+  on<Name extends keyof InputEvents>(event: Name, listener: (payload: InputEvents[Name]) => void): () => void {
+    const registered = this.listeners[event];
+    registered.add(listener);
+    return () => {
+      registered.delete(listener);
+    };
+  }
+
+  /** Deliver an event to every listener. */
+  emit<Name extends keyof InputEvents>(event: Name, payload: InputEvents[Name]): void {
+    for (const listener of [...this.listeners[event]]) {
+      try {
+        listener(payload);
+      } catch {
+        // A game's listener failing must not stop the frame loop.
+      }
+    }
+  }
+}

package/src/input/input-registry.ts

@@ -1,164 +1,164 @@
-/**
- * The declared inputs, groups and axes, and their readings: each input's raw
- * value this frame and last frame, from which edges, axes and vectors follow.
- */
-import type { DeviceState } from './device-state';
-import { clampUnit, readRawValue } from './source-values';
-import type { AxisDef, InputConfig, InputDef, InputReading, InputSource, Vector } from './types';
-
-/** One input's live state. */
-interface LiveInput {
-  definition: InputDef;
-  readonly group: string;
-  raw: number;
-  previous: number;
-}
-
-/** Inputs cross this to count as pressed. */
-const PRESS_THRESHOLD = 0.5;
-
-/** One side of an axis definition as -1..1. */
-function readAxisSide(side: AxisDef['x'], valueOf: (name: string) => number): number {
-  if (side === undefined) {
-    return 0;
-  }
-  if (typeof side === 'string') {
-    return valueOf(side);
-  }
-  return clampUnit(valueOf(side[1])) - clampUnit(valueOf(side[0]));
-}
-
-/** The declared inputs and their readings. */
-export class InputRegistry {
-  private readonly inputs = new Map<string, LiveInput>();
-  private readonly enabledGroups = new Map<string, boolean>();
-  private readonly axes = new Map<string, AxisDef>();
-
-  /** Replace the declared inputs. Groups keep an enabled state set before; new ones start as declared. */
-  declare(config: InputConfig, bindingOf: (name: string, declared: InputDef) => InputDef): void {
-    this.inputs.clear();
-    this.axes.clear();
-    for (const [group, groupDefinition] of Object.entries(config.groups)) {
-      if (!this.enabledGroups.has(group)) {
-        this.enabledGroups.set(group, groupDefinition.enabled ?? false);
-      }
-      for (const [name, definition] of Object.entries(groupDefinition.inputs)) {
-        this.inputs.set(name, { definition: bindingOf(name, definition), group, raw: 0, previous: 0 });
-      }
-      for (const [name, axis] of Object.entries(groupDefinition.axes ?? {})) {
-        this.axes.set(name, axis);
-      }
-    }
-  }
-
-  /** The group an input belongs to. */
-  groupOf(name: string): string | undefined {
-    return this.inputs.get(name)?.group;
-  }
-
-  /** Replace one input's sources (after a rebind). */
-  redefine(name: string, definition: InputDef): void {
-    const input = this.inputs.get(name);
-    if (input !== undefined) {
-      input.definition = definition;
-    }
-  }
-
-  /** Turn a group on or off. On: held sources don't fire a phantom `down`. Off: its inputs read 0. */
-  setGroupEnabled(group: string, isEnabled: boolean, devices: DeviceState, source: InputSource): void {
-    this.enabledGroups.set(group, isEnabled);
-    for (const input of this.inputs.values()) {
-      if (input.group !== group) {
-        continue;
-      }
-      input.raw = isEnabled ? readRawValue(devices, input.definition, source) : 0;
-      if (isEnabled) {
-        input.previous = input.raw;
-      }
-    }
-  }
-
-  /** Whether a group is on. */
-  isEnabled(group: string): boolean {
-    return this.enabledGroups.get(group) === true;
-  }
-
-  /** The groups that are on. */
-  enabledGroupNames(): Set<string> {
-    return new Set([...this.enabledGroups].filter(([, isOn]) => isOn).map(([group]) => group));
-  }
-
-  /** Take this frame's readings (inputs of disabled groups read 0). */
-  sample(devices: DeviceState, source: InputSource): void {
-    for (const input of this.inputs.values()) {
-      input.previous = input.raw;
-      input.raw = this.isEnabled(input.group) ? readRawValue(devices, input.definition, source) : 0;
-    }
-  }
-
-  /** Every input reads 0 this frame (the hub menu is open). */
-  silence(): void {
-    for (const input of this.inputs.values()) {
-      input.previous = input.raw;
-      input.raw = 0;
-    }
-  }
-
-  /** An input's value, 0..1. */
-  value(name: string): number {
-    return this.inputs.get(name)?.raw ?? 0;
-  }
-
-  /** Whether an input crossed the press threshold upward this frame. */
-  wentDown(name: string): boolean {
-    const input = this.inputs.get(name);
-    return input !== undefined && input.previous < PRESS_THRESHOLD && input.raw >= PRESS_THRESHOLD;
-  }
-
-  /** Whether an input crossed the press threshold downward this frame. */
-  wentUp(name: string): boolean {
-    const input = this.inputs.get(name);
-    return input !== undefined && input.previous >= PRESS_THRESHOLD && input.raw < PRESS_THRESHOLD;
-  }
-
-  /** Whether an input is held. */
-  isPressed(name: string): boolean {
-    return this.value(name) >= PRESS_THRESHOLD;
-  }
-
-  /** An input's full reading. */
-  reading(name: string): InputReading {
-    const raw = this.value(name);
-    return { value: raw, raw, isDown: this.wentDown(name), isUp: this.wentUp(name) };
-  }
-
-  /** A named axis (or an ad-hoc negative/positive pair) as -1..1. */
-  axis(name: string, positive?: string): number {
-    if (positive !== undefined) {
-      return clampUnit(this.value(positive)) - clampUnit(this.value(name));
-    }
-    const axis = this.axes.get(name);
-    return axis === undefined ? this.value(name) : readAxisSide(axis.x, (input) => this.value(input));
-  }
-
-  /** A named axis pair as a vector clamped to the unit circle. */
-  vector(name: string): Vector {
-    const axis = this.axes.get(name);
-    if (axis === undefined) {
-      return { x: 0, y: 0, mag: 0 };
-    }
-    let horizontal = readAxisSide(axis.x, (input) => this.value(input));
-    let vertical = readAxisSide(axis.y, (input) => this.value(input));
-    const magnitude = Math.hypot(horizontal, vertical);
-    if (magnitude > 1) {
-      horizontal /= magnitude;
-      vertical /= magnitude;
-    }
-    return { x: horizontal, y: vertical, mag: Math.min(magnitude, 1) };
-  }
-
-  /** An input's current sources (for the binding label). */
-  definitionOf(name: string): InputDef | undefined {
-    return this.inputs.get(name)?.definition;
-  }
-}
+/**
+ * The declared inputs, groups and axes, and their readings: each input's raw
+ * value this frame and last frame, from which edges, axes and vectors follow.
+ */
+import type { DeviceState } from './device-state';
+import { clampUnit, readRawValue } from './source-values';
+import type { AxisDef, InputConfig, InputDef, InputReading, InputSource, Vector } from './types';
+
+/** One input's live state. */
+interface LiveInput {
+  definition: InputDef;
+  readonly group: string;
+  raw: number;
+  previous: number;
+}
+
+/** Inputs cross this to count as pressed. */
+const PRESS_THRESHOLD = 0.5;
+
+/** One side of an axis definition as -1..1. */
+function readAxisSide(side: AxisDef['x'], valueOf: (name: string) => number): number {
+  if (side === undefined) {
+    return 0;
+  }
+  if (typeof side === 'string') {
+    return valueOf(side);
+  }
+  return clampUnit(valueOf(side[1])) - clampUnit(valueOf(side[0]));
+}
+
+/** The declared inputs and their readings. */
+export class InputRegistry {
+  private readonly inputs = new Map<string, LiveInput>();
+  private readonly enabledGroups = new Map<string, boolean>();
+  private readonly axes = new Map<string, AxisDef>();
+
+  /** Replace the declared inputs. Groups keep an enabled state set before; new ones start as declared. */
+  declare(config: InputConfig, bindingOf: (name: string, declared: InputDef) => InputDef): void {
+    this.inputs.clear();
+    this.axes.clear();
+    for (const [group, groupDefinition] of Object.entries(config.groups)) {
+      if (!this.enabledGroups.has(group)) {
+        this.enabledGroups.set(group, groupDefinition.enabled ?? false);
+      }
+      for (const [name, definition] of Object.entries(groupDefinition.inputs)) {
+        this.inputs.set(name, { definition: bindingOf(name, definition), group, raw: 0, previous: 0 });
+      }
+      for (const [name, axis] of Object.entries(groupDefinition.axes ?? {})) {
+        this.axes.set(name, axis);
+      }
+    }
+  }
+
+  /** The group an input belongs to. */
+  groupOf(name: string): string | undefined {
+    return this.inputs.get(name)?.group;
+  }
+
+  /** Replace one input's sources (after a rebind). */
+  redefine(name: string, definition: InputDef): void {
+    const input = this.inputs.get(name);
+    if (input !== undefined) {
+      input.definition = definition;
+    }
+  }
+
+  /** Turn a group on or off. On: held sources don't fire a phantom `down`. Off: its inputs read 0. */
+  setGroupEnabled(group: string, isEnabled: boolean, devices: DeviceState, source: InputSource): void {
+    this.enabledGroups.set(group, isEnabled);
+    for (const input of this.inputs.values()) {
+      if (input.group !== group) {
+        continue;
+      }
+      input.raw = isEnabled ? readRawValue(devices, input.definition, source) : 0;
+      if (isEnabled) {
+        input.previous = input.raw;
+      }
+    }
+  }
+
+  /** Whether a group is on. */
+  isEnabled(group: string): boolean {
+    return this.enabledGroups.get(group) === true;
+  }
+
+  /** The groups that are on. */
+  enabledGroupNames(): Set<string> {
+    return new Set([...this.enabledGroups].filter(([, isOn]) => isOn).map(([group]) => group));
+  }
+
+  /** Take this frame's readings (inputs of disabled groups read 0). */
+  sample(devices: DeviceState, source: InputSource): void {
+    for (const input of this.inputs.values()) {
+      input.previous = input.raw;
+      input.raw = this.isEnabled(input.group) ? readRawValue(devices, input.definition, source) : 0;
+    }
+  }
+
+  /** Every input reads 0 this frame (the hub menu is open). */
+  silence(): void {
+    for (const input of this.inputs.values()) {
+      input.previous = input.raw;
+      input.raw = 0;
+    }
+  }
+
+  /** An input's value, 0..1. */
+  value(name: string): number {
+    return this.inputs.get(name)?.raw ?? 0;
+  }
+
+  /** Whether an input crossed the press threshold upward this frame. */
+  wentDown(name: string): boolean {
+    const input = this.inputs.get(name);
+    return input !== undefined && input.previous < PRESS_THRESHOLD && input.raw >= PRESS_THRESHOLD;
+  }
+
+  /** Whether an input crossed the press threshold downward this frame. */
+  wentUp(name: string): boolean {
+    const input = this.inputs.get(name);
+    return input !== undefined && input.previous >= PRESS_THRESHOLD && input.raw < PRESS_THRESHOLD;
+  }
+
+  /** Whether an input is held. */
+  isPressed(name: string): boolean {
+    return this.value(name) >= PRESS_THRESHOLD;
+  }
+
+  /** An input's full reading. */
+  reading(name: string): InputReading {
+    const raw = this.value(name);
+    return { value: raw, raw, isDown: this.wentDown(name), isUp: this.wentUp(name) };
+  }
+
+  /** A named axis (or an ad-hoc negative/positive pair) as -1..1. */
+  axis(name: string, positive?: string): number {
+    if (positive !== undefined) {
+      return clampUnit(this.value(positive)) - clampUnit(this.value(name));
+    }
+    const axis = this.axes.get(name);
+    return axis === undefined ? this.value(name) : readAxisSide(axis.x, (input) => this.value(input));
+  }
+
+  /** A named axis pair as a vector clamped to the unit circle. */
+  vector(name: string): Vector {
+    const axis = this.axes.get(name);
+    if (axis === undefined) {
+      return { x: 0, y: 0, mag: 0 };
+    }
+    let horizontal = readAxisSide(axis.x, (input) => this.value(input));
+    let vertical = readAxisSide(axis.y, (input) => this.value(input));
+    const magnitude = Math.hypot(horizontal, vertical);
+    if (magnitude > 1) {
+      horizontal /= magnitude;
+      vertical /= magnitude;
+    }
+    return { x: horizontal, y: vertical, mag: Math.min(magnitude, 1) };
+  }
+
+  /** An input's current sources (for the binding label). */
+  definitionOf(name: string): InputDef | undefined {
+    return this.inputs.get(name)?.definition;
+  }
+}