@caperjs/core 0.2.4 → 0.3.0

package/src/plugins/WebEventsPlugin.test.ts

@@ -9,6 +9,7 @@ vi.mock('../core/Application', () => ({
   Application: { getInstance: () => ({ renderer: { canvas: null } }) },
 }));
 
+import { Signal } from '../signals';
 import { WebEventsPlugin } from './WebEventsPlugin';
 
 type FakeVisualViewport = EventTarget & { scale: number };
@@ -73,3 +74,34 @@ describe('WebEventsPlugin visualViewport resize', () => {
     expect(() => plugin.initialize()).not.toThrow();
   });
 });
+
+describe('WebEventsPlugin destroy', () => {
+  let plugin: WebEventsPlugin;
+
+  beforeEach(() => {
+    plugin = new WebEventsPlugin();
+  });
+
+  it('stops handling orientationchange after destroy', () => {
+    const spy = vi.spyOn(plugin as any, '_onOrientationChanged');
+    plugin.initialize();
+
+    window.dispatchEvent(new Event('orientationchange'));
+    expect(spy).toHaveBeenCalledTimes(1);
+
+    plugin.destroy();
+    window.dispatchEvent(new Event('orientationchange'));
+    expect(spy).toHaveBeenCalledTimes(1);
+  });
+
+  it('disconnects tracked signal connections on destroy', () => {
+    const signal = new Signal<() => void>();
+    const handler = vi.fn();
+    plugin.addSignalConnection(signal.connect(handler));
+
+    plugin.destroy();
+    signal.emit();
+
+    expect(handler).not.toHaveBeenCalled();
+  });
+});

package/src/plugins/WebEventsPlugin.ts

@@ -61,7 +61,9 @@ export class WebEventsPlugin extends Plugin implements IWebEventsPlugin {
     document.removeEventListener('fullscreenchange', this._onResize);
     window.removeEventListener('pagehide', this._onPageHide, false);
     window.removeEventListener('pageshow', this._onPageShow, false);
+    window.removeEventListener('orientationchange', this._onOrientationChanged);
     window.visualViewport?.removeEventListener('resize', this._onVisualViewportResize);
+    super.destroy();
   }
 
   protected getCoreSignals(): string[] {

package/src/plugins/actions/ActionsPlugin.test.ts

@@ -0,0 +1,68 @@
+import { describe, expect, it, vi } from 'vitest';
+
+// ActionsPlugin -> Plugin.ts transitively imports Application → Pixi display graph. Stub it.
+vi.mock('../../core', () => ({
+  coreFunctionRegistry: {},
+  coreSignalRegistry: {},
+}));
+vi.mock('../../core/Application', () => ({
+  Application: { getInstance: () => ({}) },
+}));
+
+import type { IApplication } from '../../core';
+import { ActionsPlugin } from './ActionsPlugin';
+
+function makePlugin(actions: Record<string, { context: string | string[] }>) {
+  const plugin = new ActionsPlugin();
+  plugin.initialize({}, { config: { actions } } as unknown as IApplication);
+  return plugin;
+}
+
+describe('ActionsPlugin', () => {
+  it('does not dispatch an action whose context merely contains the current context', () => {
+    const plugin = makePlugin({ foo: { context: 'popup' } });
+    const handler = vi.fn();
+    plugin.getAction('foo').connect(handler);
+
+    plugin.setActionContext('pop');
+    plugin.sendAction('foo');
+
+    expect(handler).not.toHaveBeenCalled();
+  });
+
+  it('dispatches an action when the string context matches exactly', () => {
+    const plugin = makePlugin({ foo: { context: 'popup' } });
+    const handler = vi.fn();
+    plugin.getAction('foo').connect(handler);
+
+    plugin.setActionContext('popup');
+    plugin.sendAction('foo');
+
+    expect(handler).toHaveBeenCalledTimes(1);
+  });
+
+  it('dispatches an action with a wildcard context in any context', () => {
+    const plugin = makePlugin({ foo: { context: '*' } });
+    const handler = vi.fn();
+    plugin.getAction('foo').connect(handler);
+
+    plugin.setActionContext('anything');
+    plugin.sendAction('foo');
+
+    expect(handler).toHaveBeenCalledTimes(1);
+  });
+
+  it('dispatches an action when an array context includes the current context', () => {
+    const plugin = makePlugin({ foo: { context: ['menu', 'popup'] } });
+    const handler = vi.fn();
+    plugin.getAction('foo').connect(handler);
+
+    plugin.setActionContext('menu');
+    plugin.sendAction('foo');
+    expect(handler).toHaveBeenCalledTimes(1);
+
+    plugin.setActionContext('men');
+    plugin.sendAction('foo');
+    expect(handler).toHaveBeenCalledTimes(1);
+  });
+});

package/src/plugins/actions/ActionsPlugin.ts

@@ -80,11 +80,11 @@ export class ActionsPlugin extends Plugin<IActionsPluginOptions> implements IAct
 
     // check if action is allowed for current context
     // send action if allowed
-    if (
-      this._actions[actionId]?.context === '*' ||
-      this._actions[actionId]?.context === this.context ||
-      this._actions[actionId]?.context?.includes(this.context)
-    ) {
+    const actionContext = this._actions[actionId]!.context;
+    const allowed = Array.isArray(actionContext)
+      ? actionContext.includes(this.context)
+      : actionContext === this.context || actionContext === '*';
+    if (allowed) {
       const detail: ActionDetail<TActionData> = { id: actionId, context: this.context, data };
       this.getAction<TActionData>(actionId).emit(detail);
       // notify automation / observers of the dispatched (allowed) action

package/src/plugins/audio/AudioChannel.test.ts

@@ -80,6 +80,25 @@ describe('AudioChannel', () => {
     expect(media.volume).toBeCloseTo(0.8 * 0.5 * 1);
   });
 
+  it('destroy() stops/destroys every tracked instance and clears them', () => {
+    const manager = createManager();
+    const channel = new AudioChannel('sfx', manager);
+
+    const instance1 = channel.add('boom', new AudioInstance('boom', channel, manager));
+    const media1 = createMedia();
+    instance1.media = media1 as never;
+
+    const instance2 = channel.add('splat', new AudioInstance('splat', channel, manager));
+    const media2 = createMedia();
+    instance2.media = media2 as never;
+
+    channel.destroy();
+
+    expect(media1.stop).toHaveBeenCalled();
+    expect(media2.stop).toHaveBeenCalled();
+    expect(channel.instances).toEqual([]);
+  });
+
   it('remove(id) stops all instances tracked under that alias', () => {
     const manager = createManager();
     const channel = new AudioChannel('sfx', manager);

package/src/plugins/audio/AudioChannel.ts

@@ -160,5 +160,12 @@ export class AudioChannel<C extends ChannelName = ChannelName> {
     this.volume = this._volume;
   }
 
-  destroy() {}
+  destroy() {
+    this._sounds.forEach((bucket) => {
+      // destroy() -> stop() -> emits onEnd, whose handler may call
+      // removeInstance() and mutate `bucket` mid-iteration. Iterate a copy.
+      [...bucket].forEach((instance) => instance.destroy());
+    });
+    this._sounds.clear();
+  }
 }

package/src/plugins/audio/AudioManagerPlugin.test.ts

@@ -0,0 +1,41 @@
+import { sound } from '@pixi/sound';
+import { describe, expect, it, vi } from 'vitest';
+
+// AudioManagerPlugin -> Plugin.ts transitively imports Application → Pixi display graph. Stub it.
+vi.mock('../../core', () => ({
+  coreFunctionRegistry: {},
+  coreSignalRegistry: {},
+}));
+vi.mock('../../core/Application', () => ({
+  Application: { getInstance: () => ({}) },
+}));
+
+import { AudioManagerPlugin } from './AudioManagerPlugin';
+
+describe('AudioManagerPlugin', () => {
+  it('destroy() disconnects onChannelMuted along with the other signals', () => {
+    const manager = new AudioManagerPlugin();
+    const handler = vi.fn();
+    manager.onChannelMuted.connect(handler);
+
+    manager.destroy();
+
+    manager.onChannelMuted.emit({ channel: {} as never, muted: true });
+    expect(handler).not.toHaveBeenCalled();
+  });
+
+  it('caches a resolved sound id under the original id so probing is not repeated', () => {
+    const exists = vi.spyOn(sound, 'exists').mockImplementation((id: string) => id === 'foo.mp3');
+    const manager = new AudioManagerPlugin();
+
+    const resolved = (manager as any)._verifySoundId('foo');
+    expect(resolved).toBe('foo.mp3');
+    expect(((manager as any)._idMap as Map<string, string>).get('foo')).toBe('foo.mp3');
+
+    exists.mockClear();
+    expect((manager as any)._verifySoundId('foo')).toBe('foo.mp3');
+    expect(exists).not.toHaveBeenCalled();
+
+    exists.mockRestore();
+  });
+});

package/src/plugins/audio/AudioManagerPlugin.ts

@@ -272,6 +272,7 @@ export class AudioManagerPlugin<C extends ChannelName = ChannelName> extends Plu
     this.onMuted.disconnectAll();
     this.onMasterVolumeChanged.disconnectAll();
     this.onChannelVolumeChanged.disconnectAll();
+    this.onChannelMuted.disconnectAll();
 
     super.destroy();
   }
@@ -701,7 +702,7 @@ export class AudioManagerPlugin<C extends ChannelName = ChannelName> extends Plu
     }
     for (let id of soundId) {
       if (this._idMap.has(id)) {
-        soundId = this._idMap.get(id) as string;
+        id = this._idMap.get(id) as string;
       }
       const channel = this._channels.get(channelName);
       if (channel) {
@@ -795,7 +796,7 @@ export class AudioManagerPlugin<C extends ChannelName = ChannelName> extends Plu
         }
       }
     }
-    this._idMap.set(soundId, soundId);
+    this._idMap.set(originalSoundId, soundId);
     return soundId;
   }
 

package/src/plugins/audio/VoiceOverPlugin.ts

@@ -1,3 +1,4 @@
+import { gsap } from 'gsap';
 import { Signal } from '../../signals';
 import { Logger } from '../../utils';
 import type { IPlugin } from '../Plugin';

package/src/plugins/captions/CaptionsPlugin.test.ts

@@ -0,0 +1,40 @@
+import { Assets } from 'pixi.js';
+import { describe, expect, it, vi } from 'vitest';
+
+// CaptionsPlugin -> Plugin.ts transitively imports Application → Pixi display graph. Stub it.
+vi.mock('../../core', () => ({
+  coreFunctionRegistry: {},
+  coreSignalRegistry: {},
+}));
+vi.mock('../../core/Application', () => ({
+  Application: { getInstance: () => ({}) },
+}));
+
+import { CaptionsPlugin } from './CaptionsPlugin';
+
+describe('CaptionsPlugin', () => {
+  it('loadLocale returns early when the locale is already loaded', async () => {
+    const load = vi.spyOn(Assets, 'load').mockResolvedValue({});
+    const plugin = new CaptionsPlugin();
+    (plugin as any)._locale = 'en';
+    (plugin as any)._dicts = { en: { hello: 'hello' } };
+    (plugin as any)._options = { files: [{ id: 'en', json: 'en.json' }] };
+
+    await plugin.loadLocale('en');
+
+    expect(load).not.toHaveBeenCalled();
+    load.mockRestore();
+  });
+
+  it('loadLocale still loads the current locale when its dictionary is missing', async () => {
+    const load = vi.spyOn(Assets, 'load').mockResolvedValue({ a: 1 });
+    const plugin = new CaptionsPlugin();
+    (plugin as any)._locale = 'en';
+    (plugin as any)._options = { files: [{ id: 'en', json: 'en.json' }] };
+
+    await plugin.loadLocale('en');
+
+    expect(load).toHaveBeenCalledWith('en.json');
+    load.mockRestore();
+  });
+});

package/src/plugins/captions/CaptionsPlugin.ts

@@ -327,7 +327,7 @@ export class CaptionsPlugin extends Plugin<CaptionsOptions> implements ICaptions
    * @returns Promise<void>
    */
   async loadLocale(localeId: string) {
-    if (this._locale === 'localeId') {
+    if (this._dicts[localeId]) {
       return;
     }
     const file = this._options.files.find((file) => localeId === file.id);

package/src/plugins/focus/FocusManagerPlugin.test.ts

@@ -0,0 +1,71 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+
+const mockApp = vi.hoisted(() => ({
+  config: { focus: {} },
+  renderer: {
+    accessibility: {
+      isActive: false,
+      destroy: vi.fn(),
+      postrender: vi.fn(),
+      _deactivate: vi.fn(),
+    },
+  },
+  scenes: { onSceneChangeStart: { connect: vi.fn() } },
+  ticker: { addOnce: vi.fn(), add: vi.fn(), remove: vi.fn() },
+}));
+
+// FocusManagerPlugin transitively imports Application → Pixi display graph. Stub it.
+vi.mock('../../core', () => ({
+  coreFunctionRegistry: {},
+  coreSignalRegistry: {},
+}));
+vi.mock('../../core/Application', () => ({
+  Application: { getInstance: () => mockApp },
+}));
+
+import { FocusManagerPlugin } from './FocusManagerPlugin';
+
+describe('FocusManagerPlugin destroy', () => {
+  let plugin: FocusManagerPlugin;
+
+  beforeEach(() => {
+    plugin = new FocusManagerPlugin();
+  });
+
+  it('stops handling window keydown after destroy', () => {
+    const spy = vi.spyOn(plugin as any, '_onKeyDown');
+    plugin.initialize({}, mockApp as never);
+
+    window.dispatchEvent(new KeyboardEvent('keydown', { key: 'Tab' }));
+    expect(spy).toHaveBeenCalledTimes(1);
+
+    plugin.destroy();
+    window.dispatchEvent(new KeyboardEvent('keydown', { key: 'Tab' }));
+    expect(spy).toHaveBeenCalledTimes(1);
+  });
+
+  it('stops handling window keyup after destroy', () => {
+    const spy = vi.spyOn(plugin as any, '_onKeyUp');
+    plugin.initialize({}, mockApp as never);
+
+    window.dispatchEvent(new KeyboardEvent('keyup', { key: 'Enter' }));
+    expect(spy).toHaveBeenCalledTimes(1);
+
+    plugin.destroy();
+    window.dispatchEvent(new KeyboardEvent('keyup', { key: 'Enter' }));
+    expect(spy).toHaveBeenCalledTimes(1);
+  });
+
+  it('stops handling the capture-phase document mousemove after destroy', () => {
+    const spy = vi.spyOn(plugin as any, '_onMouseMove');
+    plugin.initialize({}, mockApp as never);
+    (plugin as any)._activate();
+
+    document.dispatchEvent(new MouseEvent('mousemove'));
+    expect(spy).toHaveBeenCalledTimes(1);
+
+    plugin.destroy();
+    document.dispatchEvent(new MouseEvent('mousemove'));
+    expect(spy).toHaveBeenCalledTimes(1);
+  });
+});

package/src/plugins/focus/FocusManagerPlugin.ts

@@ -734,6 +734,13 @@ export class FocusManagerPlugin extends Plugin<FocusManagerPluginOptions> implem
   private _removeGlobalListeners() {
     globalThis.document.removeEventListener('mousemove', this._handleGlobalMouseMove);
     globalThis.document.removeEventListener('pointerdown', this._handleGlobalPointerDown);
+    // keydown is added by _setupKeyboardListeners (window) and again, when pixi
+    // accessibility is off, by _updatePixiAccessibility (globalThis)
+    window.removeEventListener('keydown', this._onKeyDown, false);
+    globalThis.removeEventListener('keydown', this._onKeyDown, false);
+    globalThis.removeEventListener('keyup', this._onKeyUp, false);
+    // capture-phase listener added by _activate()
+    globalThis.document.removeEventListener('mousemove', this._onMouseMove, true);
   }
 
   private _handleGlobalMouseMove() {

package/src/plugins/input/AbstractControls.ts

@@ -12,4 +12,10 @@ export class AbstractControls {
   initialize(scheme: Partial<ControlsActionMap>) {
     this.scheme = scheme;
   }
+
+  /**
+   * Terminates the destroy chain — subclasses are built on WithSignals, whose destroy()
+   * calls super.destroy().
+   */
+  destroy(): void {}
 }

package/src/plugins/input/Controls.test.ts

@@ -0,0 +1,149 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+
+import { Signal } from '../../signals';
+
+// Controls → KeyboardControls / VirtualControls reach for the Application singleton.
+const mocks = vi.hoisted(() => ({ app: null as any }));
+
+vi.mock('../../core/Application', () => ({
+  Application: { getInstance: () => mocks.app },
+}));
+
+import type { IButton } from '../../ui';
+import { Controls } from './Controls';
+
+type FakeApp = {
+  ticker: { add: ReturnType<typeof vi.fn>; remove: ReturnType<typeof vi.fn> };
+  actionContext: string;
+  actionsPlugin: { getActions: () => Record<string, { context: string; input: string[] }> };
+  signal: { onActionContextChanged: Signal<() => void> };
+  keyboard: {
+    keysDown: Set<string>;
+    onKeyDown: () => Signal<(detail: any) => void>;
+    onKeyUp: () => Signal<(detail: any) => void>;
+  };
+  action: ReturnType<typeof vi.fn>;
+};
+
+let app: FakeApp;
+let keyDown: Signal<(detail: any) => void>;
+let keyUp: Signal<(detail: any) => void>;
+let actions: Record<string, { context: string; input: string[] }>;
+
+function pressKey(key: string) {
+  app.keyboard.keysDown.add(key);
+  keyDown.emit({ event: { key }, key });
+}
+
+function makeButton(id: string): IButton {
+  return {
+    id,
+    onDown: new Signal<() => void>(),
+    onUp: new Signal<() => void>(),
+    onUpOutside: new Signal<() => void>(),
+    onDestroy: new Signal<() => void>(),
+  } as unknown as IButton;
+}
+
+beforeEach(() => {
+  keyDown = new Signal();
+  keyUp = new Signal();
+  actions = {
+    move_left: { context: '*', input: [] },
+    jump: { context: '*', input: [] },
+  };
+  app = {
+    ticker: { add: vi.fn(), remove: vi.fn() },
+    actionContext: 'default',
+    actionsPlugin: { getActions: () => actions },
+    signal: { onActionContextChanged: new Signal<() => void>() },
+    keyboard: {
+      keysDown: new Set<string>(),
+      onKeyDown: () => keyDown,
+      onKeyUp: () => keyUp,
+    },
+    action: vi.fn(),
+  };
+  mocks.app = app;
+});
+
+describe('Controls teardown', () => {
+  it('destroys configured control schemes without throwing and removes ticker callbacks', () => {
+    const controls = new Controls();
+    controls.initialize({
+      keyboard: { down: { move_left: 'A' } },
+      touch: { down: { jump: 'btn-a' } },
+    } as any);
+    controls.connect();
+
+    expect(app.ticker.add).toHaveBeenCalledTimes(2);
+    expect(() => controls.destroy()).not.toThrow();
+    expect(app.ticker.remove).toHaveBeenCalledTimes(2);
+  });
+});
+
+describe('Controls combinations', () => {
+  it('reports a keyboard combination active when both keys are down', () => {
+    const controls = new Controls();
+    controls.initialize({ keyboard: { down: { move_left: ['A+B'] } } } as any);
+    controls.connect();
+
+    expect(controls.isActionActive('move_left')).toBe(false);
+
+    pressKey('A');
+    expect(controls.isActionActive('move_left')).toBe(false);
+
+    pressKey('B');
+    expect(controls.isActionActive('move_left')).toBe(true);
+  });
+
+  it('reports a virtual button combination active when both buttons are down', () => {
+    const controls = new Controls();
+    controls.initialize({ touch: { down: { jump: ['btn-a+btn-b'] } } } as any);
+    controls.connect();
+
+    const a = makeButton('btn-a');
+    const b = makeButton('btn-b');
+    controls.virtual.addButton(a);
+    controls.virtual.addButton(b);
+
+    a.onDown.emit();
+    expect(controls.isActionActive('jump')).toBe(false);
+
+    b.onDown.emit();
+    expect(controls.isActionActive('jump')).toBe(true);
+  });
+});
+
+describe('Controls with an unmapped action in the scheme', () => {
+  it('does not throw on initialize or on an action context change', () => {
+    const controls = new Controls();
+
+    expect(() =>
+      controls.initialize({
+        keyboard: { down: { not_an_action: 'A' } },
+        touch: { down: { not_an_action: 'btn-a' }, up: { also_not_an_action: 'btn-b' } },
+      } as any),
+    ).not.toThrow();
+
+    controls.connect();
+
+    expect(() => app.signal.onActionContextChanged.emit()).not.toThrow();
+  });
+});
+
+describe('VirtualControls.removeButton', () => {
+  it('stops a removed button from driving action state', () => {
+    const controls = new Controls();
+    controls.initialize({ touch: { down: { jump: 'btn-a' } } } as any);
+    controls.connect();
+
+    const button = makeButton('btn-a');
+    controls.virtual.addButton(button);
+    controls.virtual.removeButton(button);
+
+    button.onDown.emit();
+
+    expect(controls.isActionActive('jump')).toBe(false);
+  });
+});

package/src/plugins/input/keyboard/KeyboardContols.ts

@@ -1,6 +1,6 @@
 import { Application } from '../../../core/Application';
 import { WithSignals } from '../../../mixins/signals';
-import { bindAllMethods } from '../../../utils';
+import { bindAllMethods, Logger } from '../../../utils';
 import type { Action } from '../../actions';
 import { normalizeKey, type KeyboardEventDetail } from '../../KeyboardPlugin';
 import { AbstractControls } from '../AbstractControls';
@@ -15,6 +15,7 @@ export class KeyboardControls extends WithSignals(AbstractControls) {
   private _keyCombinationsMap: Map<string[], Action> = new Map();
   private _activeDownKeys: Map<string, Action> = new Map();
   private _activeUpKeys: Map<string, Action> = new Map();
+  private _warnedMissingActions: Set<string> = new Set();
 
   constructor() {
     super();
@@ -31,11 +32,9 @@ export class KeyboardControls extends WithSignals(AbstractControls) {
       return false;
     }
     if (Array.isArray(controlsAction)) {
-      return (
-        this._keyCombinationsMap.has(controlsAction) || controlsAction.some((key) => this._singleDownKeys.has(key))
-      );
+      return controlsAction.some((key) => this._isInputActive(key));
     } else {
-      return this._singleDownKeys.has(controlsAction);
+      return this._isInputActive(controlsAction);
     }
   }
 
@@ -57,6 +56,27 @@ export class KeyboardControls extends WithSignals(AbstractControls) {
     this.app.ticker.add(this._update);
   }
 
+  public destroy(): void {
+    this.app.ticker.remove(this._update);
+    super.destroy();
+  }
+
+  /** A single key, or a `+` separated combination requiring every key to be down. */
+  private _isInputActive(input: string): boolean {
+    if (input.includes('+')) {
+      return input.split('+').every((key) => this._singleDownKeys.has(key));
+    }
+    return this._singleDownKeys.has(input);
+  }
+
+  private _warnMissingAction(key: string) {
+    if (this._warnedMissingActions.has(key)) {
+      return;
+    }
+    this._warnedMissingActions.add(key);
+    Logger.warn(`KeyboardControls: scheme references unknown action "${key}"`);
+  }
+
   private _sortActions() {
     const actions = this.app.actionsPlugin.getActions();
     this._keyCombinations = [];
@@ -68,6 +88,10 @@ export class KeyboardControls extends WithSignals(AbstractControls) {
     keys.forEach((key) => {
       const item = this._keyDownMap[key];
       const action = actions[key];
+      if (!action) {
+        this._warnMissingAction(key);
+        return;
+      }
       if (
         action.context !== '*' &&
         action.context !== this.app.actionContext &&

package/src/plugins/input/touch/VirtualControls.test.ts

@@ -0,0 +1,38 @@
+import { describe, expect, it, vi } from 'vitest';
+
+// VirtualControls reaches the app through Application.getInstance(). Stub it.
+// The stub app is filled in after the imports (getInstance is only called lazily).
+const holder = vi.hoisted(() => ({ app: null as any }));
+vi.mock('../../../core/Application', () => ({
+  Application: { getInstance: () => holder.app },
+}));
+
+import { Signal } from '../../../signals';
+import { VirtualControls } from './VirtualControls';
+
+describe('VirtualControls', () => {
+  it('stops reacting to action context changes after destroy', () => {
+    const onActionContextChanged = new Signal<(context: string) => void>();
+    holder.app = {
+      signal: { onActionContextChanged },
+      ticker: { add: vi.fn(), remove: vi.fn() },
+      actionsPlugin: { getActions: () => ({}) },
+      actionContext: 'default',
+    };
+
+    const controls = new VirtualControls();
+    const sortActions = vi.fn();
+    (controls as any)._sortActions = sortActions;
+
+    controls.initialize({});
+    const callsAfterInit = sortActions.mock.calls.length;
+
+    onActionContextChanged.emit('menu');
+    expect(sortActions).toHaveBeenCalledTimes(callsAfterInit + 1);
+
+    controls.destroy();
+
+    onActionContextChanged.emit('game');
+    expect(sortActions).toHaveBeenCalledTimes(callsAfterInit + 1);
+  });
+});