@vpmedia/phaser 1.123.0 → 1.125.0

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
@@ -223,7 +223,7 @@ export class InputHandler {
    * TBD.
    */
   public destroy(): void {
-    if (this.sprite) {
+    if (this.sprite !== null) {
       if (this._setHandCursor) {
         this.game.canvas.style.cursor = 'default';
         this._setHandCursor = false;
@@ -402,7 +402,7 @@ export class InputHandler {
     if (
       !pointer.isDown ||
       !this.enabled ||
-      !this.sprite ||
+      this.sprite === null ||
       !this.sprite.parent ||
       !this.sprite.visible ||
       !this.sprite.parent.visible ||
@@ -430,7 +430,7 @@ export class InputHandler {
   public checkPointerOver(pointer: Pointer, fastTest = false): boolean {
     if (
       !this.enabled ||
-      !this.sprite ||
+      this.sprite === null ||
       !this.sprite.parent ||
       !this.sprite.visible ||
       !this.sprite.parent.visible ||
@@ -511,7 +511,7 @@ export class InputHandler {
       // Abort. We've been destroyed.
       return false;
     }
-    if (!this.enabled || !this.sprite.visible || !this.sprite.parent?.visible) {
+    if (!this.enabled || !this.sprite.visible || this.sprite.parent?.visible !== true) {
       this._pointerOutHandler(pointer);
       return false;
     }
@@ -560,7 +560,7 @@ export class InputHandler {
         this.game.canvas.style.cursor = 'pointer';
         this._setHandCursor = true;
       }
-      if (!silent && sendEvent && this.sprite && this.sprite.events) {
+      if (!silent && sendEvent && this.sprite !== null) {
         this.sprite.events.onInputOver$dispatch(this.sprite, pointer);
       }
       if (this.sprite.parent && this.sprite.parent.type === GROUP) {
@@ -587,9 +587,9 @@ export class InputHandler {
       this.game.canvas.style.cursor = 'default';
       this._setHandCursor = false;
     }
-    if (!silent && this.sprite && this.sprite.events) {
+    if (!silent && this.sprite !== null) {
       this.sprite.events.onInputOut$dispatch(this.sprite, pointer);
-      if (this.sprite && this.sprite.parent && this.sprite.parent.type === GROUP) {
+      if (this.sprite?.parent?.type === GROUP) {
         (this.sprite.parent as Group).onChildInputOut.dispatch(this.sprite, pointer);
       }
     }
@@ -615,10 +615,10 @@ export class InputHandler {
       this.downPoint.setTo(pointer.x, pointer.y);
       // It's possible the onInputDown event creates a new Sprite that is on-top of this one, so we ought to force a Pointer update
       pointer.dirty = true;
-      if (this.sprite && this.sprite.events) {
+      if (this.sprite !== null) {
         this.sprite.events.onInputDown$dispatch(this.sprite, pointer);
         // The event above might have destroyed this sprite.
-        if (this.sprite && this.sprite.parent && this.sprite.parent.type === GROUP) {
+        if (this.sprite?.parent?.type === GROUP) {
           (this.sprite.parent as Group).onChildInputDown.dispatch(this.sprite, pointer);
         }
         //  The events might have destroyed this sprite.
@@ -650,7 +650,7 @@ export class InputHandler {
    */
   public dragTimeElapsed(pointer: Pointer): void {
     this._dragTimePass = true;
-    if (this._pendingDrag && this.sprite && this._dragDistancePass) {
+    if (this._pendingDrag && this.sprite !== null && this._dragDistancePass) {
       this.startDrag(pointer);
     }
   }
@@ -673,14 +673,14 @@ export class InputHandler {
       data.downDuration = data.timeUp - data.timeDown;
       // Only release the InputUp signal if the pointer is still over this sprite
       let isOver = this.checkPointerOver(pointer);
-      if (this.sprite && this.sprite.events) {
+      if (this.sprite !== null) {
         if (
           !this.dragStopBlocksInputUp ||
           (this.dragStopBlocksInputUp && !(this.draggable && this.isDragged && this._draggedPointerID === pointer.id))
         ) {
           this.sprite.events.onInputUp$dispatch(this.sprite, pointer, isOver);
         }
-        if (this.sprite && this.sprite.parent && this.sprite.parent.type === GROUP) {
+        if (this.sprite?.parent?.type === GROUP) {
           (this.sprite.parent as Group).onChildInputUp.dispatch(this.sprite, pointer, isOver);
         }
         // The onInputUp event may have changed the sprite so that checkPointerOver is no longer true, so update it.
@@ -843,7 +843,7 @@ export class InputHandler {
    * TBD.
    */
   public disableDrag(): void {
-    if (this._pointerData) {
+    if (this._pointerData.length > 0) {
       for (let i = 0; i < 10; i += 1) {
         this.pointerData(i).isDragged = false;
       }

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.
@@ -103,7 +106,7 @@ export class Mouse {
     canvas.addEventListener('mouseover', this._onMouseOver, true);
     canvas.addEventListener('mouseout', this._onMouseOut, true);
     const { wheelEvent } = this.game.device;
-    if (wheelEvent) {
+    if (wheelEvent !== null) {
       canvas.addEventListener(wheelEvent, this._onMouseWheel, true);
     }
   }
@@ -129,13 +132,13 @@ export class Mouse {
       canvas.removeEventListener('mouseout', this._onMouseOut, true);
     }
     const { wheelEvent } = this.game.device;
-    if (wheelEvent && this._onMouseWheel) {
+    if (wheelEvent !== null && this._onMouseWheel) {
       canvas.removeEventListener(wheelEvent, this._onMouseWheel, true);
     }
-    if (this._onMouseUpGlobal) {
+    if (this._onMouseUpGlobal !== null) {
       globalThis.removeEventListener('mouseup', this._onMouseUpGlobal, true);
     }
-    if (this._onMouseOutGlobal) {
+    if (this._onMouseOutGlobal !== null) {
       globalThis.removeEventListener('mouseout', this._onMouseOutGlobal, true);
     }
   }
@@ -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

@@ -149,7 +149,7 @@ export class Pointer {
    */
   public start(event: InputEvent): this {
     const { input } = this.game;
-    if (event.pointerId) {
+    if (event.pointerId !== undefined) {
       this.pointerId = event.pointerId;
     }
     this.identifier = event.identifier ?? null;
@@ -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');