@caperjs/core 0.2.3 → 0.3.0

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);
+  });
+});

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

@@ -1,9 +1,10 @@
-import { bindAllMethods } from '../../../utils';
+import { bindAllMethods, Logger } from '../../../utils';
 import type { ControlsActionMap, JoystickControlsScheme, TouchControlsMap, TouchControlsScheme } from '../types';
 
 import { JoystickDirection } from '..';
 import { Application } from '../../../core/Application';
 import { WithSignals } from '../../../mixins/signals';
+import type { SignalConnection } from '../../../signals';
 import type { IButton, IJoystick } from '../../../ui';
 import type { Action } from '../../actions';
 import { AbstractControls } from '../AbstractControls';
@@ -20,6 +21,8 @@ export class VirtualControls extends WithSignals(AbstractControls) {
   private _activeButtonDownIds: Map<string, Action> = new Map();
   private _activeButtonUpIds: Map<string, Action> = new Map();
   private _combinationsMap: Map<string[], Action> = new Map();
+  private _buttonConnections: Map<IButton, SignalConnection[]> = new Map();
+  private _warnedMissingActions: Set<string> = new Set();
 
   constructor() {
     super();
@@ -44,12 +47,14 @@ export class VirtualControls extends WithSignals(AbstractControls) {
     if (!button || this._buttons.has(button)) {
       return;
     }
-    this.addSignalConnection(
+    const connections = [
       button.onDown.connect(() => this._handleButtonDown(button)),
       button.onUp.connect(() => this._handleButtonUp(button)),
       button.onUpOutside.connect(() => this._handleButtonUp(button)),
       button.onDestroy.connect(() => this.removeButton(button)),
-    );
+    ];
+    this.addSignalConnection(...connections);
+    this._buttonConnections.set(button, connections);
     this._buttons.add(button);
   }
 
@@ -57,10 +62,10 @@ export class VirtualControls extends WithSignals(AbstractControls) {
     if (!button || !this._buttons.has(button)) {
       return;
     }
-    button.onDown.disconnect(() => this._handleButtonDown(button));
-    button.onUp.disconnect(() => this._handleButtonUp(button));
-    button.onUpOutside.disconnect(() => this._handleButtonUp(button));
-    button.onDestroy.disconnect(() => this.removeButton(button));
+    // signals disconnect by identity — disconnect the connections made in addButton
+    this._buttonConnections.get(button)?.forEach((connection) => connection.disconnect());
+    this._buttonConnections.delete(button);
+    this._singleDownButtons.delete(button.id!);
     this._buttons.delete(button);
   }
 
@@ -69,7 +74,7 @@ export class VirtualControls extends WithSignals(AbstractControls) {
     this._buttonDownMap = scheme.down || {};
     this._buttonUpMap = scheme.up || {};
     this._joystickMap = scheme.joystick || {};
-    this.app.signal.onActionContextChanged.connect(this._sortActions);
+    this.addSignalConnection(this.app.signal.onActionContextChanged.connect(this._sortActions));
     this._sortActions();
   }
 
@@ -77,13 +82,18 @@ export class VirtualControls extends WithSignals(AbstractControls) {
     this.app.ticker.add(this._update);
   }
 
+  public destroy(): void {
+    this.app.ticker.remove(this._update);
+    super.destroy();
+  }
+
   isActionActive(action: Action): boolean {
     const buttonAction = this.scheme['down']?.[action] ?? null;
     if (buttonAction) {
       if (Array.isArray(buttonAction)) {
-        return this._combinationsMap.has(buttonAction);
+        return buttonAction.some((input) => this._isInputActive(input));
       } else {
-        return this._singleDownButtons.has(buttonAction);
+        return this._isInputActive(buttonAction);
       }
     } else {
       const joystickAction = this.scheme['joystick']?.[action] ?? null;
@@ -98,6 +108,22 @@ export class VirtualControls extends WithSignals(AbstractControls) {
     return false;
   }
 
+  /** A single button id, or a `+` separated combination requiring every input to be down. */
+  private _isInputActive(input: string): boolean {
+    if (input.includes('+')) {
+      return input.split('+').every((id) => this._singleDownButtons.has(id) || this._joystick?.direction === id);
+    }
+    return this._singleDownButtons.has(input);
+  }
+
+  private _warnMissingAction(key: string) {
+    if (this._warnedMissingActions.has(key)) {
+      return;
+    }
+    this._warnedMissingActions.add(key);
+    Logger.warn(`VirtualControls: scheme references unknown action "${key}"`);
+  }
+
   private _sortActions() {
     const actions = this.app.actionsPlugin.getActions();
     this._combinations = [];
@@ -110,6 +136,10 @@ export class VirtualControls extends WithSignals(AbstractControls) {
     buttons.forEach((key) => {
       const item = this._buttonDownMap[key];
       const action = actions[key];
+      if (!action) {
+        this._warnMissingAction(key);
+        return;
+      }
       if (
         action.context !== '*' &&
         action.context !== this.app.actionContext &&
@@ -141,6 +171,10 @@ export class VirtualControls extends WithSignals(AbstractControls) {
     buttons.forEach((key) => {
       const item = this._buttonUpMap[key];
       const action = actions[key];
+      if (!action) {
+        this._warnMissingAction(key);
+        return;
+      }
       if (
         action.context !== '*' &&
         action.context !== this.app.actionContext &&

package/src/plugins/spine/SpinePlugin.ts

@@ -1,6 +1,6 @@
 import { extensions } from 'pixi.js';
 import { Plugin } from '../Plugin';
-import { Spine, spineLoaderExtension, SpinePipe, spineTextureAtlasLoader } from './pixi-spine';
+import { Spine, spineLoaderExtension, spineTextureAtlasLoader } from './pixi-spine';
 
 export class SpinePlugin extends Plugin {
   public readonly id = 'SpinePlugin';
@@ -8,7 +8,7 @@ export class SpinePlugin extends Plugin {
   public async initialize() {
     extensions.add(spineTextureAtlasLoader);
     extensions.add(spineLoaderExtension);
-    extensions.add(SpinePipe);
+    // SpinePipe and DarkTintBatcher register themselves at module scope in ./pixi-spine
     (window as any).Spine = Spine;
   }
 }

package/src/store/Store.test.ts

@@ -143,4 +143,19 @@ describe('Store', () => {
     expect(saveA).toHaveBeenCalledWith('k', 1);
     expect(saveB).toHaveBeenCalledWith('k', 1);
   });
+
+  it('save with "*" anywhere in an adapter array fans out to every storage-capable plugin', async () => {
+    const saveA = vi.fn(async () => 'a');
+    const saveB = vi.fn(async () => 'b');
+    const store = new Store().initialize(
+      makeApp([
+        { id: 'a', save: saveA, load: async () => undefined },
+        { id: 'b', save: saveB, load: async () => undefined },
+        { id: 'c' }, // not storage-capable → must be skipped
+      ]),
+    );
+    await store.save(['a', '*'] as never, 'k', 1);
+    expect(saveA).toHaveBeenCalledWith('k', 1);
+    expect(saveB).toHaveBeenCalledWith('k', 1);
+  });
 });

package/src/store/Store.ts

@@ -126,7 +126,10 @@ export class Store implements IStore {
       keys = adapterId as string[] | Partial<AdapterSaveConfig>[];
     }
 
-    if ((keys[0] as string) === '*' || (keys[0] as Partial<AdapterSaveConfig>)?.adapterId === '*') {
+    const hasStarKey = keys.some(
+      (k) => (k as string) === '*' || (k as Partial<AdapterSaveConfig>)?.adapterId === '*',
+    );
+    if (hasStarKey) {
       keys = this.allAdapterIds();
     }
 

package/src/ui/Button.test.ts

@@ -0,0 +1,248 @@
+import { describe, expect, it, vi } from 'vitest';
+
+// Button transitively imports Application → Pixi display graph. Stub it — these
+// tests drive the press-state machine directly and never touch the app singleton.
+vi.mock('../core/Application', () => ({
+  Application: { getInstance: () => ({}) },
+}));
+
+import { Button } from './Button';
+import { Signal } from '../signals';
+
+/**
+ * Builds a Button instance without running the real constructor (which drags in
+ * Factory/Interactive/Focusable mixin construction and a real Pixi Sprite). Only
+ * the fields the handlers under test actually touch are hand-initialized.
+ */
+function makeButton() {
+  const button = Object.create(Button.prototype) as Button;
+
+  // Pixi's Container (via eventemitter3) normally initializes these in its own
+  // constructor, which this hand-rolled instance never runs; `on`/`off` throw
+  // without them.
+  (button as any)._events = Object.create(null);
+  (button as any)._eventsCount = 0;
+
+  (button as any).config = {
+    id: 'button',
+    textures: { default: '' },
+    sheet: undefined,
+    enabled: true,
+    cursor: 'default',
+    disabledCursor: 'not-allowed',
+  };
+
+  (button as any)._enabled = true;
+  button.isDown = false;
+  button.isOver = false;
+  (button as any)._pointerId = undefined;
+  (button as any).isKeyDown = false;
+  (button as any).cursor = 'default';
+  (button as any).focusEnabled = true;
+
+  (button as any).view = { texture: undefined };
+  (button as any).make = { texture: vi.fn(() => 'texture') };
+  (button as any)._isDownCallbacks = new Map();
+  (button as any)._isDownListenerAdded = false;
+
+  button.onDown = new Signal();
+  button.onUp = new Signal();
+  button.onUpOutside = new Signal();
+  button.onOut = new Signal();
+  button.onOver = new Signal();
+  button.onClick = new Signal();
+  button.onEnabled = new Signal();
+  button.onDisabled = new Signal();
+  button.onKeyboardEvent = new Signal();
+  button.onDestroy = new Signal();
+
+  return button;
+}
+
+describe('Button press-state machine', () => {
+  it('recovers from a press that is disabled mid-press', () => {
+    const button = makeButton();
+    const onDown = vi.fn();
+    button.onDown.connect(onDown);
+
+    (button as any).handlePointerDown({ pointerId: 1 });
+    expect(button.isDown).toBe(true);
+
+    button.enabled = false;
+    expect(button.isDown).toBe(false);
+    expect((button as any)._pointerId).toBeUndefined();
+
+    button.enabled = true;
+    (button as any).handlePointerDown({ pointerId: 2 });
+
+    expect(onDown).toHaveBeenCalledTimes(2);
+    expect(button.isDown).toBe(true);
+  });
+
+  it('clears press state on pointerupoutside while disabled and does not emit onUpOutside', () => {
+    const button = makeButton();
+    const onUpOutside = vi.fn();
+    button.onUpOutside.connect(onUpOutside);
+
+    // Arm a stale press, then disable without going through the enabled setter,
+    // to exercise the handler's own cleanup path directly.
+    button.isDown = true;
+    (button as any)._pointerId = 1;
+    (button as any)._enabled = false;
+
+    (button as any).handlePointerUpOutside({ pointerId: 1 });
+
+    expect(button.isDown).toBe(false);
+    expect((button as any)._pointerId).toBeUndefined();
+    expect(onUpOutside).not.toHaveBeenCalled();
+  });
+
+  it('removes the window pointerup listener on destroy', () => {
+    const button = makeButton();
+    (button as any).handlePointerDown({ pointerId: 1 });
+
+    // Stub out the real mixin chain's destroy() (Focusable → Interactive →
+    // WithSignals → Factory → real Pixi Container.destroy) so this test isolates
+    // Button.destroy()'s own added cleanup without needing a fully-constructed
+    // Container underneath.
+    const superDestroy = vi
+      .spyOn(Object.getPrototypeOf(Button.prototype), 'destroy')
+      .mockImplementation(() => {});
+    const removeSpy = vi.spyOn(window, 'removeEventListener');
+
+    button.destroy();
+
+    expect(removeSpy).toHaveBeenCalledWith('pointerup', (button as any).handlePointerUpOutside);
+    expect(superDestroy).toHaveBeenCalled();
+    expect(button.isDown).toBe(false);
+    expect((button as any)._pointerId).toBeUndefined();
+
+    removeSpy.mockRestore();
+    superDestroy.mockRestore();
+  });
+
+  it('does not click after a cancelled press (disabled then re-enabled)', () => {
+    const button = makeButton();
+    const onClick = vi.fn();
+    button.onClick.connect(onClick);
+
+    (button as any).handlePointerDown({ pointerId: 1 });
+    button.enabled = false;
+    button.enabled = true;
+
+    // A real pointer-driven click event carries the same pointerId as the press.
+    (button as any).handleClick({ pointerId: 1 });
+
+    expect(onClick).not.toHaveBeenCalled();
+  });
+
+  it('clicks normally after a press', () => {
+    const button = makeButton();
+    const onClick = vi.fn();
+    button.onClick.connect(onClick);
+
+    (button as any).handlePointerDown({ pointerId: 1 });
+    (button as any).handleClick({ pointerId: 1 });
+
+    expect(onClick).toHaveBeenCalledTimes(1);
+  });
+
+  it('dispatches a click action with no data without throwing, attaching the button to the payload', () => {
+    const button = makeButton();
+    (button as any).config.actions = { click: { id: 'foo' } };
+    const action = vi.fn();
+    Object.defineProperty(button, 'app', { value: { action }, configurable: true });
+
+    (button as any).handlePointerDown({ pointerId: 1 });
+    expect(() => (button as any).handleClick({ pointerId: 1 })).not.toThrow();
+
+    expect(action).toHaveBeenCalledWith('foo', { button });
+  });
+
+  it('still clicks for a synthetic keyboard activation (no pointerId)', () => {
+    const button = makeButton();
+    const onClick = vi.fn();
+    button.onClick.connect(onClick);
+
+    // Mimics FocusManagerPlugin's synthetic pointerdown on Enter/Space keydown.
+    (button as any).handlePointerDown({ type: 'pointerdown' });
+    (button as any).handleClick();
+
+    expect(onClick).toHaveBeenCalledTimes(1);
+  });
+
+  it('fires onClick exactly once for a single accessibility activation delivered as click+tap', () => {
+    const button = makeButton();
+    const onClick = vi.fn();
+    button.onClick.connect(onClick);
+
+    // AccessibilitySystem dispatches ONE shared FederatedEvent instance as both
+    // 'click' and 'tap' — Button connects both to handleClick.
+    const a11yEvent = { type: 'click' };
+    (button as any).handleClick(a11yEvent);
+    (button as any).handleClick(a11yEvent);
+
+    expect(onClick).toHaveBeenCalledTimes(1);
+  });
+
+  it('suppresses a cancelled pointer-driven click even without a prior press in this test', () => {
+    const button = makeButton();
+    const onClick = vi.fn();
+    button.onClick.connect(onClick);
+
+    // isDown is false (no press) — a click event carrying a pointerId must be treated
+    // as a cancelled press and suppressed.
+    (button as any).handleClick({ pointerId: 5 });
+
+    expect(onClick).not.toHaveBeenCalled();
+  });
+
+  it('fires onClick for each of two distinct accessibility activations', () => {
+    const button = makeButton();
+    const onClick = vi.fn();
+    button.onClick.connect(onClick);
+
+    (button as any).handleClick({ type: 'click' });
+    (button as any).handleClick({ type: 'click' });
+
+    expect(onClick).toHaveBeenCalledTimes(2);
+  });
+
+  it('toggles the ticker listener on for the first isDown callback and off when the last is removed', () => {
+    const button = makeButton();
+    const add = vi.fn();
+    const remove = vi.fn();
+    Object.defineProperty(button, 'app', { value: { ticker: { add, remove } }, configurable: true });
+
+    button.addIsDownCallback('a', () => {});
+    button.addIsDownCallback('b', () => {});
+
+    expect(add).toHaveBeenCalledTimes(1);
+    expect(remove).not.toHaveBeenCalled();
+
+    button.removeIsDownCallback('a');
+    expect(remove).not.toHaveBeenCalled();
+
+    button.removeIsDownCallback('b');
+    expect(remove).toHaveBeenCalledTimes(1);
+  });
+
+  it('removes the ticker listener on destroy when one is active', () => {
+    const button = makeButton();
+    const add = vi.fn();
+    const remove = vi.fn();
+    Object.defineProperty(button, 'app', { value: { ticker: { add, remove } }, configurable: true });
+
+    button.addIsDownCallback('a', () => {});
+
+    const superDestroy = vi
+      .spyOn(Object.getPrototypeOf(Button.prototype), 'destroy')
+      .mockImplementation(() => {});
+
+    button.destroy();
+
+    expect(remove).toHaveBeenCalledTimes(1);
+
+    superDestroy.mockRestore();
+  });
+});

package/src/ui/Button.ts

@@ -121,6 +121,7 @@ export class Button extends _Button implements IButton {
   private _isDownListenerAdded: boolean = false;
   private _pointerId?: number;
   private _textLabel?: Text | HTMLText | BitmapText;
+  private _lastClickEvent?: FederatedEvent;
 
   /**
    * The text label of the button.
@@ -190,6 +191,8 @@ export class Button extends _Button implements IButton {
       this.onInteraction('tap').connect(this.handleClick, -1),
       this.onInteraction('pointerdown').connect(this.handlePointerDown, -1),
     );
+
+    this.on('removed', this._resetPressState);
   }
 
   // enabled state
@@ -213,6 +216,7 @@ export class Button extends _Button implements IButton {
       });
       this.onEnabled.emit();
     } else {
+      this._resetPressState();
       this.view.texture = this.make.texture({
         asset: this.config.textures.disabled || this.config.textures.default,
         sheet: this.config.sheet ?? undefined,
@@ -221,6 +225,18 @@ export class Button extends _Button implements IButton {
     }
   }
 
+  /**
+   * Clears any in-progress press: removes the window-level release listener and
+   * resets press tracking. Called when the button is disabled, removed, or
+   * destroyed mid-press so a stale pointerId can't block future presses.
+   */
+  private _resetPressState() {
+    window.removeEventListener('pointerup', this.handlePointerUpOutside);
+    this.off('pointerupoutside', this.handlePointerUpOutside);
+    this.isDown = false;
+    this._pointerId = undefined;
+  }
+
   public addLabel<T extends Text | HTMLText | BitmapText>(
     config: (Partial<TextProps | HTMLTextProps> & { type?: 'text' | 'html' | 'bitmap' }) | T,
   ): T {
@@ -264,6 +280,11 @@ export class Button extends _Button implements IButton {
 
   destroy(options?: DestroyOptions) {
     this.onDestroy.emit();
+    this._resetPressState();
+    if (this._isDownListenerAdded) {
+      this.app.ticker.remove(this._handleIsDownCallbacks);
+      this._isDownListenerAdded = false;
+    }
     super.destroy(options);
   }
 
@@ -290,6 +311,7 @@ export class Button extends _Button implements IButton {
 
   removeIsDownCallback(callbackId: string) {
     this._isDownCallbacks.delete(callbackId);
+    this._checkIsDownCallbacks();
   }
 
   setTexture(textureId: ButtonTextureId, texture: TextureAsset) {
@@ -395,10 +417,20 @@ export class Button extends _Button implements IButton {
     this._pointerId = undefined;
   }
 
-  protected handleClick() {
+  protected handleClick(e?: FederatedEvent) {
     if (!this._enabled) {
       return;
     }
+    const pointerId = (e as FederatedPointerEvent | undefined)?.pointerId;
+    if (pointerId !== undefined && !this.isDown) {
+      // a pointer press that was cancelled (e.g. disabled mid-press) must not click
+      return;
+    }
+    if (e !== undefined && e === this._lastClickEvent) {
+      // accessibility dispatches one event instance as both 'click' and 'tap'
+      return;
+    }
+    this._lastClickEvent = e;
     this.isDown = false;
     this.onClick.emit();
     if (this.config.sounds?.click) {
@@ -413,23 +445,23 @@ export class Button extends _Button implements IButton {
    *  Handles the pointer up event.
    */
   protected handlePointerUpOutside(e: PointerEvent | FederatedPointerEvent) {
-    if (!this._enabled || e.pointerId !== this._pointerId) {
+    if (e.pointerId !== this._pointerId) {
       return;
     }
-    window.removeEventListener('pointerup', this.handlePointerUpOutside);
-    this.off('pointerupoutside', this.handlePointerUpOutside);
-    this.view.texture = this.make.texture({ asset: this.config.textures.default, sheet: this.config.sheet });
-    this.isDown = false;
+    const wasEnabled = this._enabled;
+    this._resetPressState();
     this.isOver = false;
-    this.onUpOutside.emit();
-
-    this._pointerId = undefined;
+    if (wasEnabled) {
+      this.view.texture = this.make.texture({ asset: this.config.textures.default, sheet: this.config.sheet });
+      this.onUpOutside.emit();
+    }
   }
 
   private _doAction(action: ButtonActionOrCallback) {
     if (typeof action === 'function') {
       void action();
     } else {
+      action.data ??= {};
       if (!action.data.button) {
         action.data.button = this;
       }
@@ -442,7 +474,7 @@ export class Button extends _Button implements IButton {
     if (!this._isDownListenerAdded && this._isDownCallbacks.size > 0) {
       this._isDownListenerAdded = true;
       this.app.ticker.add(this._handleIsDownCallbacks);
-    } else {
+    } else if (this._isDownListenerAdded && this._isDownCallbacks.size === 0) {
       this.app.ticker.remove(this._handleIsDownCallbacks);
       this._isDownListenerAdded = false;
     }