@caperjs/core 0.1.1 → 0.2.0

package/src/plugins/input/Controls.ts

@@ -4,11 +4,12 @@ import { bindAllMethods } from '../../utils';
 import { Action } from '../actions';
 import { IControls, UserControls } from './interfaces';
 import { KeyboardControls } from './keyboard';
-import { TouchControls } from './touch';
+import { VirtualControls } from './touch';
 
 export class Controls implements IControls {
   keyboard: KeyboardControls;
-  touch: TouchControls;
+  /** @deprecated Use {@link Controls.virtual} instead. */
+  touch: VirtualControls;
 
   constructor() {
     bindAllMethods(this);
@@ -18,6 +19,11 @@ export class Controls implements IControls {
     return Application.getInstance();
   }
 
+  /** Virtual on-screen buttons (joystick/buttons) — the same instance as {@link Controls.touch}. */
+  get virtual(): VirtualControls {
+    return this.touch;
+  }
+
   destroy() {
     if (this.keyboard) {
       this.keyboard.destroy();
@@ -39,7 +45,7 @@ export class Controls implements IControls {
     }
 
     if (scheme.touch) {
-      this.touch = new TouchControls();
+      this.touch = new VirtualControls();
       this.touch.initialize(scheme.touch);
     }
   }

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/types/caper-app.d.ts

@@ -0,0 +1 @@
+/* caper.config.ts not found, skipping augmentation. */

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.2.0';
 export const pixiVersion: string = '8.19.0';

package/templates/app/default/package.template.json

@@ -5,13 +5,17 @@
   "main": "index.html",
   "scripts": {
     "clean": "rimraf .assetpack .cache dist",
-    "start": "~PACKAGE_MANAGER~ clean && caper start",
-    "dev": "~PACKAGE_MANAGER~ clean && caper dev",
-    "preview": "~PACKAGE_MANAGER~ clean && caper preview",
-    "build": "~PACKAGE_MANAGER~ clean && caper build",
+    "start": "~PACKAGE_MANAGER~ clean && vite",
+    "dev": "~PACKAGE_MANAGER~ clean && vite",
+    "preview": "~PACKAGE_MANAGER~ clean && vite build && vite preview",
+    "build": "~PACKAGE_MANAGER~ clean && vite build",
     "test": "echo \"Error: no test specified\" && exit 1"
   },
   "dependencies": {
     "@caperjs/core": "latest"
+  },
+  "devDependencies": {
+    "vite": "^8.1.3",
+    "workbox-window": "^7.4.0"
   }
 }

package/templates/app/default/vite.config.ts

@@ -0,0 +1,15 @@
+import { caper } from '@caperjs/core/vite';
+import { defineConfig } from 'vite';
+
+/**
+ * Caper contributes its plugins and its config defaults through `caper()`, and
+ * only fills in what this file leaves unset — so anything you set here wins.
+ *
+ * Options:
+ *   caper({ assets: { ... } })  AssetPack overrides, merged over caper's defaults
+ *                               (`assets: false` turns the asset pipeline off)
+ *   caper({ pwa: { manifest } }) makes the game installable, service worker included
+ */
+export default defineConfig({
+  plugins: [caper()],
+});

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/cli/vite.mjs

@@ -1,55 +0,0 @@
-import { build, createServer, loadConfigFromFile, mergeConfig, preview } from 'vite';
-import { defaultConfig } from '../config/vite.mjs';
-
-async function getMergedViteConfig(command, mode) {
-  // Load user's vite.config.js file if it exists
-  const userConfig = await loadConfigFromFile({
-    command,
-    mode,
-  });
-
-  // Merge user config with default config
-  const mergedConfig = mergeConfig(defaultConfig, userConfig?.config || {});
-
-  // Remove duplicate plugins by name, preferring user's config over default, while preserving order.
-  if (mergedConfig.plugins) {
-    const seen = new Set();
-    mergedConfig.plugins = mergedConfig.plugins
-      .flat()
-      .reverse()
-      .filter((plugin) => {
-        if (!plugin || !plugin.name) {
-          // Keep plugins without a name (e.g., some Vite internal plugins)
-          return true;
-        }
-        if (seen.has(plugin.name)) {
-          return false;
-        }
-        seen.add(plugin.name);
-        return true;
-      })
-      .reverse();
-  }
-
-  return mergedConfig;
-}
-
-export async function startDevServer() {
-  const config = await getMergedViteConfig('serve', 'development');
-  const server = await createServer(config);
-  await server.listen();
-
-  server.printUrls();
-}
-
-export async function runBuild() {
-  const config = await getMergedViteConfig('build', 'production');
-  await build(config);
-}
-
-export async function runPreview() {
-  const config = await getMergedViteConfig('build', 'production');
-  await build(config);
-  const server = await preview(config);
-  server.printUrls();
-}