@vpmedia/phaser 1.123.0 → 1.124.0

package/src/phaser/core/input.ts

@@ -14,6 +14,7 @@ import type { Game } from './game.js';
 import type { DisplayObject } from '../display/display_object.js';
 import type { InputEvent } from './input_event.js';
 import type { CandidateHandler, PointerMoveCallback } from './callback.js';
+import type { InputHandler } from './input_handler.js';
 
 const MAX_POINTERS = 10;
 
@@ -50,7 +51,7 @@ export class Input {
   public pointer7!: Pointer | null;
   public pointer8!: Pointer | null;
   public pointer9!: Pointer | null;
-  public pointer10!: any;
+  public pointer10!: Pointer | null;
   public pointers!: Pointer[];
   public activePointer!: Pointer;
   public mousePointer!: Pointer;
@@ -63,7 +64,7 @@ export class Input {
   public onTap!: Signal;
   public onHold!: Signal;
   public minPriorityID!: number;
-  public interactiveItems!: ArraySet;
+  public interactiveItems!: ArraySet<InputHandler>;
   public _localPoint!: Point;
   public _pollCounter!: number;
   public _oldPosition!: Point;
@@ -118,7 +119,7 @@ export class Input {
     this.onTap = null!;
     this.onHold = null!;
     this.minPriorityID = 0;
-    this.interactiveItems = new ArraySet();
+    this.interactiveItems = new ArraySet<InputHandler>();
     this._localPoint = new Point();
     this._pollCounter = 0;
     this._oldPosition = null!;
@@ -291,7 +292,7 @@ export class Input {
    * @param {MouseEvent|TouchEvent|PointerEvent} event - TBD.
    * @returns {Pointer} TBD.
    */
-  public startPointer(event: InputEvent) {
+  public startPointer(event: InputEvent): Pointer | null {
     if (this.maxPointers >= 0 && this.countActivePointers(this.maxPointers) >= this.maxPointers) {
       return null;
     }
@@ -315,7 +316,7 @@ export class Input {
    * @param {MouseEvent|TouchEvent|PointerEvent} event - TBD.
    * @returns {Pointer} TBD.
    */
-  public updatePointer(event: InputEvent) {
+  public updatePointer(event: InputEvent): Pointer | null {
     if (this.pointer1.active && this.pointer1.identifier === event.identifier) {
       return this.pointer1.move(event);
     }
@@ -336,7 +337,7 @@ export class Input {
    * @param {MouseEvent|TouchEvent|PointerEvent} event - TBD.
    * @returns {Pointer} TBD.
    */
-  public stopPointer(event: InputEvent) {
+  public stopPointer(event: InputEvent): Pointer | null {
     if (this.pointer1.active && this.pointer1.identifier === event.identifier) {
       return this.pointer1.stop(event);
     }
@@ -489,7 +490,7 @@ export class Input {
   /**
    * TBD.
    */
-  public set x(value) {
+  public set x(value: number) {
     this._x = Math.floor(value);
   }
 
@@ -504,7 +505,7 @@ export class Input {
   /**
    * TBD.
    */
-  public set y(value) {
+  public set y(value: number) {
     this._y = Math.floor(value);
   }
 

package/src/phaser/core/input_handler.test.ts

@@ -9,28 +9,28 @@ const createSprite = (): Image =>
     game: {
       time: { time: 0 },
       canvas: { style: { cursor: 'default' } },
-      input: { interactiveItems: { add: () => undefined, remove: () => undefined } },
+      input: { interactiveItems: { add: (): undefined => undefined, remove: (): undefined => undefined } },
     },
     events: {
-      onAddedToGroup: { add: () => undefined },
-      onRemovedFromGroup: { add: () => undefined },
+      onAddedToGroup: { add: (): undefined => undefined },
+      onRemovedFromGroup: { add: (): undefined => undefined },
     },
   }) as unknown as Image;
 
-describe('InputHandler', () => {
-  describe('pointerData', () => {
-    it('seeds pointer 0 from the constructor', () => {
+describe('InputHandler', (): void => {
+  describe('pointerData', (): void => {
+    it('seeds pointer 0 from the constructor', (): void => {
       const handler = new InputHandler(createSprite());
       expect(handler._pointerData).toHaveLength(1);
       expect(handler.pointerData(0).id).toBe(0);
     });
 
-    it('returns the same record on repeat access', () => {
+    it('returns the same record on repeat access', (): void => {
       const handler = new InputHandler(createSprite());
       expect(handler.pointerData(0)).toBe(handler.pointerData(0));
     });
 
-    it('creates a record on first access of an unseeded pointer', () => {
+    it('creates a record on first access of an unseeded pointer', (): void => {
       const handler = new InputHandler(createSprite());
       const data = handler.pointerData(7);
       expect(data.id).toBe(7);
@@ -38,13 +38,13 @@ describe('InputHandler', () => {
       expect(handler.pointerData(7)).toBe(data);
     });
 
-    it('hands back a record whose mutations are visible through the array', () => {
+    it('hands back a record whose mutations are visible through the array', (): void => {
       const handler = new InputHandler(createSprite());
       handler.pointerData(3).isOver = true;
       expect(handler._pointerData[3]?.isOver).toBe(true);
     });
 
-    it('exposes every field a fresh record needs', () => {
+    it('exposes every field a fresh record needs', (): void => {
       const handler = new InputHandler(createSprite());
       expect(handler.pointerData(1)).toStrictEqual({
         id: 1,
@@ -66,18 +66,18 @@ describe('InputHandler', () => {
     });
   });
 
-  describe('start', () => {
-    it('populates the ten pointer slots the input system tracks', () => {
+  describe('start', (): void => {
+    it('populates the ten pointer slots the input system tracks', (): void => {
       const handler = new InputHandler(createSprite());
       handler.start();
       expect(handler._pointerData).toHaveLength(10);
-      expect(handler._pointerData.map((data) => data.id)).toStrictEqual([0, 1, 2, 3, 4, 5, 6, 7, 8, 9]);
+      expect(handler._pointerData.map((data): number => data.id)).toStrictEqual([0, 1, 2, 3, 4, 5, 6, 7, 8, 9]);
       expect(handler.enabled).toBe(true);
     });
   });
 
-  describe('reset', () => {
-    it('clears pointer state back to a fresh record', () => {
+  describe('reset', (): void => {
+    it('clears pointer state back to a fresh record', (): void => {
       const handler = new InputHandler(createSprite());
       handler.start();
       handler.pointerData(2).isDown = true;
@@ -89,8 +89,8 @@ describe('InputHandler', () => {
     });
   });
 
-  describe('pointer accessors', () => {
-    it('read through to the backing record', () => {
+  describe('pointer accessors', (): void => {
+    it('read through to the backing record', (): void => {
       const handler = new InputHandler(createSprite());
       handler.start();
       const data = handler.pointerData(4);
@@ -104,7 +104,7 @@ describe('InputHandler', () => {
       expect(handler.pointerTimeDown(4)).toBe(99);
     });
 
-    it('default to pointer 0', () => {
+    it('default to pointer 0', (): void => {
       const handler = new InputHandler(createSprite());
       handler.pointerData(0).x = 5;
       expect(handler.pointerX()).toBe(5);

package/src/phaser/core/input_handler.ts

@@ -138,7 +138,7 @@ export class InputHandler {
    * @param {boolean} useHandCursor - TBD.
    * @returns {DisplayObject} TBD.
    */
-  public start(priority = 0, useHandCursor = false) {
+  public start(priority = 0, useHandCursor = false): Image {
     //  Turning on
     if (!this.enabled) {
       //  Register, etc

package/src/phaser/core/input_mouse.ts

@@ -2,6 +2,9 @@ import type { InputEvent } from './input_event.js';
 import type { Input } from './input.js';
 import type { Game } from './game.js';
 
+/** The legacy wheel-event adapter Phaser 2 installed for old browsers; nothing sets it any more. */
+export type WheelEventProxy = { bindEvent: (event: InputEvent) => InputEvent };
+
 export class Mouse {
   public game!: Game;
   public input!: Input;
@@ -27,7 +30,7 @@ export class Mouse {
   public _onMouseWheel: EventListener | null;
   public _onMouseUpGlobal!: EventListener;
   public _onMouseOutGlobal!: EventListener;
-  public _wheelEvent!: any;
+  public _wheelEvent!: WheelEventProxy | null;
   /**
    * TBD.
    * @param {Game} game - TBD.
@@ -262,15 +265,13 @@ export class Mouse {
    * @param {WheelEvent} event - TBD.
    */
   public onMouseWheel(event: InputEvent): void {
-    if (this._wheelEvent) {
-      event = this._wheelEvent.bindEvent(event);
-    }
-    this.event = event;
-    this.eventPreventDefault(event);
+    const wheelEvent = this._wheelEvent ? this._wheelEvent.bindEvent(event) : event;
+    this.event = wheelEvent;
+    this.eventPreventDefault(wheelEvent);
     // reverse detail for firefox
-    this.wheelDelta = Math.max(-1, Math.min(1, -(event.deltaY ?? 0)));
+    this.wheelDelta = Math.max(-1, Math.min(1, -(wheelEvent.deltaY ?? 0)));
     if (this.mouseWheelCallback) {
-      this.mouseWheelCallback.call(this.callbackContext, event);
+      this.mouseWheelCallback.call(this.callbackContext, wheelEvent);
     }
   }
 

package/src/phaser/core/input_pointer.test.ts

@@ -9,82 +9,82 @@ import { Pointer } from './input_pointer.js';
 const createGame = (): Game =>
   ({
     time: { time: 0 },
-    scale: { bounds: { contains: () => true }, offset: { x: 0, y: 0 } },
+    scale: { bounds: { contains: (): boolean => true }, offset: { x: 0, y: 0 } },
     input: {
       enabled: true,
       multiInputOverride: 0,
       moveCallbacks: [],
-      interactiveItems: { total: 0, callAll: () => undefined },
+      interactiveItems: { total: 0, callAll: (): undefined => undefined },
       mouse: { locked: false },
       scale: new Point(1, 1),
       position: new Point(),
       circle: new Circle(),
       speed: new Point(),
       activePointer: null,
-      onDown: { dispatch: () => undefined },
-      onUp: { dispatch: () => undefined },
-      onHold: { dispatch: () => undefined },
-      onTap: { dispatch: () => undefined },
+      onDown: { dispatch: (): undefined => undefined },
+      onUp: { dispatch: (): undefined => undefined },
+      onHold: { dispatch: (): undefined => undefined },
+      onTap: { dispatch: (): undefined => undefined },
       x: 0,
       y: 0,
-      resetSpeed: () => undefined,
+      resetSpeed: (): undefined => undefined,
     },
   }) as unknown as Game;
 
 const createPointer = (id = 1): Pointer => new Pointer(createGame(), id, POINTER_CURSOR);
 
 const event = (fields: Partial<InputEvent> = {}): InputEvent =>
-  ({ type: 'pointerdown', target: null, preventDefault: () => undefined, ...fields }) as InputEvent;
+  ({ type: 'pointerdown', target: null, preventDefault: (): undefined => undefined, ...fields }) as InputEvent;
 
-describe('Pointer', () => {
-  describe('updateButtons', () => {
-    it('reads a down event as pressed', () => {
+describe('Pointer', (): void => {
+  describe('updateButtons', (): void => {
+    it('reads a down event as pressed', (): void => {
       const pointer = createPointer();
       pointer.updateButtons(event({ type: 'pointerdown' }));
       expect(pointer.isDown).toBe(true);
       expect(pointer.isUp).toBe(false);
     });
 
-    it('reads an up event as released', () => {
+    it('reads an up event as released', (): void => {
       const pointer = createPointer();
       pointer.updateButtons(event({ type: 'pointerup' }));
       expect(pointer.isDown).toBe(false);
       expect(pointer.isUp).toBe(true);
     });
 
-    it('matches the suffix case insensitively, as the legacy events are capitalised', () => {
+    it('matches the suffix case insensitively, as the legacy events are capitalised', (): void => {
       const pointer = createPointer();
       pointer.updateButtons(event({ type: 'MSPointerDown' }));
       expect(pointer.isDown).toBe(true);
     });
 
-    it('treats a move event as not pressed', () => {
+    it('treats a move event as not pressed', (): void => {
       const pointer = createPointer();
       pointer.updateButtons(event({ type: 'pointermove' }));
       expect(pointer.isUp).toBe(true);
     });
   });
 
-  describe('start', () => {
-    it('records the identifier the event carries', () => {
+  describe('start', (): void => {
+    it('records the identifier the event carries', (): void => {
       const pointer = createPointer();
       pointer.start(event({ identifier: 7 }));
       expect(pointer.identifier).toBe(7);
     });
 
-    it('records a null identifier when the event has none', () => {
+    it('records a null identifier when the event has none', (): void => {
       const pointer = createPointer();
       pointer.start(event({}));
       expect(pointer.identifier).toBeNull();
     });
 
-    it('records the pointerId when the event carries one', () => {
+    it('records the pointerId when the event carries one', (): void => {
       const pointer = createPointer();
       pointer.start(event({ pointerId: 3 }));
       expect(pointer.pointerId).toBe(3);
     });
 
-    it('marks the pointer active and down', () => {
+    it('marks the pointer active and down', (): void => {
       const pointer = createPointer();
       pointer.start(event({ identifier: 1 }));
       expect(pointer.active).toBe(true);
@@ -92,8 +92,8 @@ describe('Pointer', () => {
     });
   });
 
-  describe('move', () => {
-    it('copies the coordinate set off the event', () => {
+  describe('move', (): void => {
+    it('copies the coordinate set off the event', (): void => {
       const pointer = createPointer();
       pointer.start(event({ identifier: 1 }));
       pointer.move(
@@ -115,7 +115,7 @@ describe('Pointer', () => {
       expect(pointer.screenY).toBe(66);
     });
 
-    it('falls back to zero for coordinates the event omits', () => {
+    it('falls back to zero for coordinates the event omits', (): void => {
       const pointer = createPointer();
       pointer.start(event({ identifier: 1 }));
       pointer.move(event({ type: 'pointermove' }));
@@ -124,8 +124,8 @@ describe('Pointer', () => {
     });
   });
 
-  describe('stop', () => {
-    it('clears the identifiers it recorded', () => {
+  describe('stop', (): void => {
+    it('clears the identifiers it recorded', (): void => {
       const pointer = createPointer();
       pointer.start(event({ identifier: 5, pointerId: 5 }));
       pointer.stop(event({ type: 'pointerup' }));
@@ -135,8 +135,8 @@ describe('Pointer', () => {
     });
   });
 
-  describe('reset', () => {
-    it('returns the pointer to its resting state', () => {
+  describe('reset', (): void => {
+    it('returns the pointer to its resting state', (): void => {
       const pointer = createPointer();
       pointer.start(event({ identifier: 5 }));
       pointer.reset();

package/src/phaser/core/input_pointer.ts

@@ -362,7 +362,7 @@ export class Pointer {
    * @param {InputHandler} newTarget - TBD.
    * @param {boolean} silent - TBD.
    */
-  public swapTarget(newTarget: InputHandler, silent = false): void {
+  public swapTarget(newTarget: InputHandler | null, silent = false): void {
     //  Now we know the top-most item (if any) we can process it
     if (newTarget === null) {
       //  The pointer isn't currently over anything, check if we've got a lingering previous target
@@ -456,7 +456,7 @@ export class Pointer {
    * @param {number} duration - TBD.
    * @returns {boolean} TBD.
    */
-  public justPressed(duration: number): boolean {
+  public justPressed(duration = 0): boolean {
     const window = duration || this.game.input.justPressedRate;
     return this.isDown && this.timeDown + window > this.game.time.time;
   }
@@ -466,7 +466,7 @@ export class Pointer {
    * @param {number} duration - TBD.
    * @returns {boolean} TBD.
    */
-  public justReleased(duration: number): boolean {
+  public justReleased(duration = 0): boolean {
     const window = duration || this.game.input.justReleasedRate;
     return this.isUp && this.timeUp + window > this.game.time.time;
   }

package/src/phaser/core/input_touch.ts

@@ -2,15 +2,15 @@ import type { Game } from './game.js';
 import type { InputEvent } from './input_event.js';
 export class Touch {
   public game!: Game;
-  public enabled!: any;
+  public enabled!: boolean;
   public callbackContext!: unknown;
-  public touchStartCallback!: any;
-  public touchMoveCallback!: any;
-  public touchEndCallback!: any;
-  public touchEnterCallback!: any;
-  public touchLeaveCallback!: any;
-  public touchCancelCallback!: any;
-  public preventDefault!: any;
+  public touchStartCallback: EventListener | null;
+  public touchMoveCallback: EventListener | null;
+  public touchEndCallback: EventListener | null;
+  public touchEnterCallback: EventListener | null;
+  public touchLeaveCallback: EventListener | null;
+  public touchCancelCallback: EventListener | null;
+  public preventDefault!: boolean;
   public event!: InputEvent | null;
   public _onTouchStart: EventListener | null;
   public _onTouchMove: EventListener | null;

package/src/phaser/core/loader.test.ts

@@ -4,7 +4,7 @@ import { Loader } from './loader.js';
 
 const createGame = (formats: Record<string, boolean> = {}, noAudio = false): Game =>
   ({
-    logger: { warn: () => undefined, info: () => undefined, debug: () => undefined },
+    logger: { warn: (): undefined => undefined, info: (): undefined => undefined, debug: (): undefined => undefined },
     config: { maxParallelDownloads: 4 },
     cache: {},
     sound: { noAudio },
@@ -14,35 +14,35 @@ const createGame = (formats: Record<string, boolean> = {}, noAudio = false): Gam
 const createLoader = (formats: Record<string, boolean> = {}, noAudio = false): Loader =>
   new Loader(createGame(formats, noAudio));
 
-describe('Loader', () => {
-  describe('getAudioURL', () => {
-    it('returns null when the device has no audio', () => {
+describe('Loader', (): void => {
+  describe('getAudioURL', (): void => {
+    it('returns null when the device has no audio', (): void => {
       expect(createLoader({}, true).getAudioURL(['track.ogg'])).toBeNull();
     });
 
-    it('picks a plain url whose extension the device can play', () => {
+    it('picks a plain url whose extension the device can play', (): void => {
       expect(createLoader({ ogg: true }).getAudioURL(['track.ogg'])).toBe('track.ogg');
     });
 
-    it('skips an extension the device cannot play', () => {
+    it('skips an extension the device cannot play', (): void => {
       expect(createLoader({ ogg: false, mp3: true }).getAudioURL(['track.ogg', 'track.mp3'])).toBe('track.mp3');
     });
 
-    it('returns null when no candidate is playable', () => {
+    it('returns null when no candidate is playable', (): void => {
       expect(createLoader({ ogg: false, mp3: false }).getAudioURL(['track.ogg', 'track.mp3'])).toBeNull();
     });
 
-    it('accepts a bare string as a single candidate', () => {
+    it('accepts a bare string as a single candidate', (): void => {
       expect(createLoader({ mp3: true }).getAudioURL('track.mp3')).toBe('track.mp3');
     });
 
-    it('reads the format from a uri and type pair', () => {
+    it('reads the format from a uri and type pair', (): void => {
       expect(createLoader({ ogg: true }).getAudioURL([{ uri: 'track-no-extension', type: 'ogg' }])).toBe(
         'track-no-extension'
       );
     });
 
-    it('skips a pair whose type the device cannot play', () => {
+    it('skips a pair whose type the device cannot play', (): void => {
       const loader = createLoader({ ogg: false, mp3: true });
       expect(
         loader.getAudioURL([
@@ -52,55 +52,55 @@ describe('Loader', () => {
       ).toBe('b');
     });
 
-    it('takes a blob url without checking the format', () => {
+    it('takes a blob url without checking the format', (): void => {
       expect(createLoader().getAudioURL(['blob:https://example.test/abc'])).toBe('blob:https://example.test/abc');
     });
 
-    it('takes a data uri without checking the format', () => {
+    it('takes a data uri without checking the format', (): void => {
       expect(createLoader().getAudioURL(['data:audio/mp3;base64,AAAA'])).toBe('data:audio/mp3;base64,AAAA');
     });
 
-    it('ignores a query string when reading the extension', () => {
+    it('ignores a query string when reading the extension', (): void => {
       expect(createLoader({ mp3: true }).getAudioURL(['track.mp3?v=2'])).toBe('track.mp3?v=2');
     });
 
-    it('returns null for an empty candidate list', () => {
+    it('returns null for an empty candidate list', (): void => {
       expect(createLoader({ mp3: true }).getAudioURL([])).toBeNull();
     });
   });
 
-  describe('transformUrl', () => {
+  describe('transformUrl', (): void => {
     const file = { path: 'assets/' } as Parameters<Loader['transformUrl']>[1];
 
-    it('returns false for a missing url', () => {
+    it('returns false for a missing url', (): void => {
       expect(createLoader().transformUrl(null, file)).toBe(false);
     });
 
-    it('returns false for an unresolved candidate list', () => {
+    it('returns false for an unresolved candidate list', (): void => {
       expect(createLoader().transformUrl(['a.mp3'], file)).toBe(false);
     });
 
-    it('passes an absolute url through', () => {
+    it('passes an absolute url through', (): void => {
       expect(createLoader().transformUrl('https://example.test/a.png', file)).toBe('https://example.test/a.png');
     });
 
-    it('passes a protocol relative url through', () => {
+    it('passes a protocol relative url through', (): void => {
       expect(createLoader().transformUrl('//example.test/a.png', file)).toBe('//example.test/a.png');
     });
 
-    it('passes a data uri through', () => {
+    it('passes a data uri through', (): void => {
       expect(createLoader().transformUrl('data:image/png;base64,AAAA', file)).toBe('data:image/png;base64,AAAA');
     });
 
-    it('prefixes a relative url with the base url and file path', () => {
+    it('prefixes a relative url with the base url and file path', (): void => {
       const loader = createLoader();
       loader.baseURL = 'https://cdn.test/';
       expect(loader.transformUrl('a.png', file)).toBe('https://cdn.test/assets/a.png');
     });
   });
 
-  describe('addToFileList', () => {
-    it('records the core fields for a queued file', () => {
+  describe('addToFileList', (): void => {
+    it('records the core fields for a queued file', (): void => {
       const loader = createLoader();
       loader.image('logo', 'logo.png');
       const asset = loader.getAsset('image', 'logo');
@@ -114,7 +114,7 @@ describe('Loader', () => {
       });
     });
 
-    it('folds the per-type extras onto the file', () => {
+    it('folds the per-type extras onto the file', (): void => {
       const loader = createLoader();
       loader.audio('theme', ['theme.mp3']);
       expect(loader.getAsset('audio', 'theme')?.file).toMatchObject({
@@ -124,13 +124,13 @@ describe('Loader', () => {
       });
     });
 
-    it('skips a file with no key', () => {
+    it('skips a file with no key', (): void => {
       const loader = createLoader();
       loader.image('', 'logo.png');
       expect(loader.getAsset('image', '')).toBeNull();
     });
 
-    it('derives the url from the key and extension when none is given', () => {
+    it('derives the url from the key and extension when none is given', (): void => {
       const loader = createLoader();
       loader.image('logo');
       expect(loader.getAsset('image', 'logo')?.file.url).toBe('logo.png');