@caperjs/core 0.1.1 → 0.1.2

package/src/plugins/input/InputPlugin.ts

@@ -16,6 +16,7 @@ export type InputManagerOptions = {
 
 export interface IInputPlugin extends IPlugin<InputManagerOptions> {
   readonly controls: Controls;
+  readonly lastUsedController: InputController | null;
   activeGamepads: Map<string, Gamepad>;
   activeControllers: Set<string>;
   options: InputManagerOptions;
@@ -23,6 +24,7 @@ export interface IInputPlugin extends IPlugin<InputManagerOptions> {
   onGamepadDisconnected: Signal<(gamepad: Gamepad) => void>;
   onControllerActivated: Signal<(controller: string) => void>;
   onControllerDeactivated: Signal<(controller: string) => void>;
+  onControllerChanged: Signal<(controller: InputController) => void>;
 
   isControllerActive(controller: InputController): boolean;
 
@@ -44,11 +46,20 @@ export class InputPlugin extends Plugin<InputManagerOptions> implements IInputPl
   // properties
   public activeGamepads = new Map<string, Gamepad>();
   public activeControllers = new Set<string>([]);
+  private _lastUsedController: InputController | null = null;
+  private _canvas: HTMLCanvasElement | null = null;
   // signals
   public onGamepadConnected: Signal<(gamepad: Gamepad) => void> = new Signal<(gamepad: Gamepad) => void>();
   public onGamepadDisconnected: Signal<(gamepad: Gamepad) => void> = new Signal<(gamepad: Gamepad) => void>();
   public onControllerActivated: Signal<(controller: string) => void> = new Signal<(controller: string) => void>();
   public onControllerDeactivated: Signal<(controller: string) => void> = new Signal<(controller: string) => void>();
+  public onControllerChanged: Signal<(controller: InputController) => void> = new Signal<
+    (controller: InputController) => void
+  >();
+
+  get lastUsedController(): InputController | null {
+    return this._lastUsedController;
+  }
 
   isActionActive(action: Action): boolean {
     return this.controls.isActionActive(action);
@@ -58,8 +69,9 @@ export class InputPlugin extends Plugin<InputManagerOptions> implements IInputPl
     this._options = { ...defaultOptions, ...options };
 
     app.stage.eventMode = 'static';
-    app.stage.on('touchstart', this._onTouchStart);
-    app.stage.on('globalmousemove', this._onMouseMove);
+    this._canvas = app.canvas as HTMLCanvasElement;
+    this._canvas.addEventListener('pointerdown', this._onPointerDown);
+    this._canvas.addEventListener('pointermove', this._onPointerMove);
     window.addEventListener('keydown', this._onKeyDown);
     window.addEventListener('gamepadconnected', this._onGamepadConnected);
     window.addEventListener('gamepaddisconnected', this._onGamepadDisconnected);
@@ -77,12 +89,23 @@ export class InputPlugin extends Plugin<InputManagerOptions> implements IInputPl
 
   destroy(): void {
     // unregister all event listeners
-    this.app.stage.off('touchstart', this._onTouchStart);
-    this.app.stage.off('globalmousemove', this._onMouseMove);
+    if (this._canvas) {
+      this._canvas.removeEventListener('pointerdown', this._onPointerDown);
+      this._canvas.removeEventListener('pointermove', this._onPointerMove);
+      this._canvas = null;
+    }
     window.removeEventListener('keydown', this._onKeyDown);
     window.removeEventListener('gamepadconnected', this._onGamepadConnected);
     window.removeEventListener('gamepaddisconnected', this._onGamepadDisconnected);
 
+    this.controls.destroy();
+
+    this.onGamepadConnected.disconnectAll();
+    this.onGamepadDisconnected.disconnectAll();
+    this.onControllerActivated.disconnectAll();
+    this.onControllerDeactivated.disconnectAll();
+    this.onControllerChanged.disconnectAll();
+
     super.destroy();
   }
 
@@ -95,16 +118,36 @@ export class InputPlugin extends Plugin<InputManagerOptions> implements IInputPl
   }
 
   protected getCoreSignals(): string[] {
-    return ['onGamepadConnected', 'onGamepadDisconnected', 'onControllerActivated', 'onControllerDeactivated'];
+    return [
+      'onGamepadConnected',
+      'onGamepadDisconnected',
+      'onControllerActivated',
+      'onControllerDeactivated',
+      'onControllerChanged',
+    ];
+  }
+
+  private _isInputControllerType(value: string): value is InputController {
+    return (Object.values(InputControllerTypes) as string[]).includes(value);
   }
 
   private _activateController(inputController: string): void {
-    if (this.activeControllers.has(inputController)) {
-      return;
+    const isNewController = !this.activeControllers.has(inputController);
+    if (isNewController) {
+      this.activeControllers.add(inputController);
+    }
+
+    // only the four InputControllerTypes values are valid "last used" values —
+    // a raw gamepad device id (see _onGamepadConnected) must never land here
+    if (this._isInputControllerType(inputController) && inputController !== this._lastUsedController) {
+      this._lastUsedController = inputController;
+      this.onControllerChanged.emit(inputController);
+    }
+
+    if (isNewController) {
+      // emit the controller activated signal
+      this.onControllerActivated.emit(inputController);
     }
-    this.activeControllers.add(inputController);
-    // emit the controller activated signal
-    this.onControllerActivated.emit(inputController);
   }
 
   private _deactivateController(inputController: InputController): void {
@@ -125,12 +168,16 @@ export class InputPlugin extends Plugin<InputManagerOptions> implements IInputPl
     this.activeGamepads.delete(gamepadId);
   }
 
-  private _onTouchStart(): void {
-    this._activateController(InputControllerTypes.Touch);
+  private _onPointerDown(event: PointerEvent): void {
+    if (event.pointerType === 'touch') {
+      this._activateController(InputControllerTypes.Touch);
+    }
   }
 
-  private _onMouseMove(): void {
-    this._activateController(InputControllerTypes.Mouse);
+  private _onPointerMove(event: PointerEvent): void {
+    if (event.pointerType === 'mouse') {
+      this._activateController(InputControllerTypes.Mouse);
+    }
   }
 
   private _onKeyDown(): void {

package/src/plugins/input/interfaces.ts

@@ -1,6 +1,6 @@
 import { ActionContext, ActionMap, UserActions, UserButtons } from '../actions';
 import { IKeyboardControlScheme, KeyboardControls } from './keyboard';
-import { ITouchControlScheme, TouchControls } from './touch';
+import { ITouchControlScheme, VirtualControls } from './touch';
 import { AbstractControlScheme, ControlsActionMap, KeyboardControlsMap, TouchControlsMap } from './types';
 
 export interface ControlsAction {
@@ -17,12 +17,13 @@ export interface IGamepadControlScheme extends AbstractControlScheme<'buttonDown
 export interface ControlScheme {
   keyboard?: IKeyboardControlScheme;
   touch?: ITouchControlScheme;
-  gamepad?: IGamepadControlScheme;
 }
 
 export interface IControls {
   readonly keyboard: KeyboardControls;
-  readonly touch: TouchControls;
+  /** @deprecated Use {@link IControls.virtual} instead. */
+  readonly touch: VirtualControls;
+  readonly virtual: VirtualControls;
 
   isActionActive(action: string): boolean;
 
@@ -33,5 +34,6 @@ export interface IControls {
 
 export interface UserControls<U extends UserActions = UserActions, B extends UserButtons = UserButtons> {
   keyboard: Partial<KeyboardControlsMap<U>>;
+  /** Virtual on-screen buttons (joystick/buttons) — despite the key name, this is not touchscreen input. */
   touch: Partial<TouchControlsMap<U, B>>;
 }

package/src/plugins/input/touch/{TouchControls.ts → VirtualControls.ts}

@@ -8,7 +8,7 @@ import { type IButton, type IJoystick } from '../../../ui';
 import type { Action } from '../../actions';
 import { AbstractControls } from '../AbstractControls';
 
-export class TouchControls extends WithSignals(AbstractControls) {
+export class VirtualControls extends WithSignals(AbstractControls) {
   protected scheme: Partial<TouchControlsMap>;
   private _buttons: Set<IButton> = new Set();
   private _joystickMap: Partial<JoystickControlsScheme>;
@@ -235,3 +235,6 @@ export class TouchControls extends WithSignals(AbstractControls) {
     }
   }
 }
+
+/** @deprecated Use {@link VirtualControls} instead. */
+export { VirtualControls as TouchControls };

package/src/plugins/input/touch/index.ts

@@ -1,3 +1,3 @@
 export * from './constants';
 export * from './interfaces';
-export * from './TouchControls';
+export * from './VirtualControls';

package/src/utils/bind.test.ts

@@ -0,0 +1,99 @@
+import { describe, expect, it } from 'vitest';
+import { bindAllMethods } from './bind';
+
+/**
+ * `bindAllMethods` walks up the prototype chain binding every method, and stops
+ * at the first class marked with `__caper_method_binding_root`. The marker MUST
+ * be `static`: the walk tests it with
+ * `hasOwnProperty(prototype.constructor, ...)`, and an instance field never
+ * lands on the constructor — so declaring it non-static silently disables the
+ * guard and the walk runs all the way to `Object.prototype`, binding (and
+ * copying onto every instance) every method of the base class. For a caper
+ * `Container` that base is PixiJS's `Container`: ~70 extra bound closures and
+ * own properties per display object.
+ */
+
+/** Stands in for the foreign base we must NOT bind into (i.e. PixiJS). */
+class Foreign {
+  foreignMethod(): unknown {
+    return this;
+  }
+}
+
+class Root extends Foreign {
+  private static readonly __caper_method_binding_root = true;
+
+  rootMethod(): unknown {
+    return this;
+  }
+}
+
+class Leaf extends Root {
+  constructor() {
+    super();
+    bindAllMethods(this);
+  }
+
+  leafMethod(): unknown {
+    return this;
+  }
+}
+
+/** The pre-fix declaration: an instance field, which the guard cannot see. */
+class BrokenRoot extends Foreign {
+  private readonly __caper_method_binding_root = true;
+
+  rootMethod(): unknown {
+    return this;
+  }
+}
+
+class BrokenLeaf extends BrokenRoot {
+  constructor() {
+    super();
+    bindAllMethods(this);
+  }
+}
+
+describe('bindAllMethods', () => {
+  it('binds methods declared at and below the leaf', () => {
+    const leaf = new Leaf();
+    const { leafMethod, rootMethod } = leaf;
+
+    expect(leafMethod()).toBe(leaf);
+    expect(rootMethod()).toBe(leaf);
+  });
+
+  it('stops at the static root marker, leaving the foreign base unbound', () => {
+    const leaf = new Leaf();
+    const { foreignMethod } = leaf;
+
+    // Detached and never bound — strict-mode `this` is undefined.
+    expect(foreignMethod()).toBeUndefined();
+    expect(Object.prototype.hasOwnProperty.call(leaf, 'foreignMethod')).toBe(false);
+  });
+
+  it('does not copy the foreign base onto the instance', () => {
+    const leaf = new Leaf();
+    const own = Object.getOwnPropertyNames(leaf).filter((k) => typeof (leaf as never)[k] === 'function');
+
+    expect(own).toContain('leafMethod');
+    expect(own).toContain('rootMethod');
+    expect(own).not.toContain('foreignMethod');
+  });
+
+  it('a NON-static marker fails to stop the walk (the bug this guards)', () => {
+    const broken = new BrokenLeaf();
+
+    // The guard never fires, so the foreign base gets bound and copied on.
+    expect(Object.prototype.hasOwnProperty.call(broken, 'foreignMethod')).toBe(true);
+    expect(broken.foreignMethod()).toBe(broken);
+  });
+
+  it('subclasses do not re-trigger the guard via an inherited static', () => {
+    // `hasOwnProperty` is own-only, so `Leaf` inheriting Root's static does not
+    // stop the walk before Leaf's own methods are collected.
+    expect(Object.prototype.hasOwnProperty.call(Leaf, '__caper_method_binding_root')).toBe(false);
+    expect(Object.prototype.hasOwnProperty.call(Root, '__caper_method_binding_root')).toBe(true);
+  });
+});

package/src/version.ts

@@ -1,3 +1,3 @@
 // This file is auto-generated during the build process.
-export const version: string = '0.1.1';
+export const version: string = '0.1.2';
 export const pixiVersion: string = '8.19.0';

package/LICENSE

@@ -1,22 +0,0 @@
-MIT License
-
-Copyright (c) Relish Interactive
-Copyright (c) 2026 Anthony Sapp
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.

package/lib/plugins/input/touch/TouchControls.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"TouchControls.d.ts","sourceRoot":"","sources":["../../../../src/plugins/input/touch/TouchControls.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAA6C,gBAAgB,EAAuB,MAAM,UAAU,CAAC;AAGjH,OAAO,EAAE,WAAW,EAAE,MAAM,2BAA2B,CAAC;AAExD,OAAO,EAAE,KAAK,OAAO,EAAE,KAAK,SAAS,EAAE,MAAM,aAAa,CAAC;AAC3D,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,eAAe,CAAC;AAC5C,OAAO,EAAE,gBAAgB,EAAE,MAAM,qBAAqB,CAAC;;AAEvD,qBAAa,aAAc,SAAQ,kBAA6B;IAC9D,SAAS,CAAC,MAAM,EAAE,OAAO,CAAC,gBAAgB,CAAC,CAAC;IAC5C,OAAO,CAAC,QAAQ,CAA2B;IAC3C,OAAO,CAAC,YAAY,CAAkC;IACtD,OAAO,CAAC,cAAc,CAA+B;IACrD,OAAO,CAAC,YAAY,CAA+B;IACnD,OAAO,CAAC,aAAa,CAAkB;IACvC,OAAO,CAAC,kBAAkB,CAA0B;IACpD,OAAO,CAAC,yBAAyB,CAA6C;IAC9E,OAAO,CAAC,oBAAoB,CAAkC;IAC9D,OAAO,CAAC,kBAAkB,CAAkC;IAC5D,OAAO,CAAC,gBAAgB,CAAoC;;IAO5D,OAAO,CAAC,SAAS,CAAY;IAE7B,IAAI,QAAQ,IAAI,SAAS,CAExB;IAED,IAAI,QAAQ,CAAC,KAAK,EAAE,SAAS,EAE5B;IAED,IAAI,GAAG,gBAEN;IAED,SAAS,CAAC,MAAM,EAAE,OAAO;IAazB,YAAY,CAAC,MAAM,EAAE,OAAO;IAWrB,UAAU,CAAC,MAAM,EAAE,OAAO,CAAC,gBAAgB,CAAC,GAAG,IAAI;IASnD,OAAO;IAId,cAAc,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO;IAqBvC,OAAO,CAAC,YAAY;IAoEpB,OAAO,CAAC,iBAAiB;IAIzB,OAAO,CAAC,eAAe;IAYvB,OAAO,CAAC,OAAO;CAoDhB"}