@vpmedia/phaser 1.124.0 → 1.126.0

package/src/phaser/core/animation_parser.ts

@@ -40,22 +40,18 @@ export const spriteSheet = (
   }
   const { width } = img;
   const { height } = img;
-  if (frameWidth <= 0) {
-    frameWidth = Math.floor(-width / Math.min(-1, frameWidth));
-  }
-  if (frameHeight <= 0) {
-    frameHeight = Math.floor(-height / Math.min(-1, frameHeight));
-  }
-  const row = Math.floor((width - margin) / (frameWidth + spacing));
-  const column = Math.floor((height - margin) / (frameHeight + spacing));
+  const cellWidth = frameWidth <= 0 ? Math.floor(-width / Math.min(-1, frameWidth)) : frameWidth;
+  const cellHeight = frameHeight <= 0 ? Math.floor(-height / Math.min(-1, frameHeight)) : frameHeight;
+  const row = Math.floor((width - margin) / (cellWidth + spacing));
+  const column = Math.floor((height - margin) / (cellHeight + spacing));
   let total = row * column;
   if (frameMax !== -1) {
     total = frameMax;
   }
   //  Zero or smaller than frame sizes?
-  if (width === 0 || height === 0 || width < frameWidth || height < frameHeight || total === 0) {
+  if (width === 0 || height === 0 || width < cellWidth || height < cellHeight || total === 0) {
     game.logger.warn(
-      `AnimationParser.spriteSheet: '${typeof key === 'string' ? key : 'image'}'s width/height zero or width/height < given frameWidth/frameHeight`
+      `AnimationParser.spriteSheet: '${typeof key === 'string' ? key : 'image'}'s width/height zero or width/height < given cellWidth/cellHeight`
     );
     return null;
   }
@@ -64,11 +60,11 @@ export const spriteSheet = (
   let x = margin;
   let y = margin;
   for (let i = 0; i < total; i += 1) {
-    data.addFrame(new Frame(i, x, y, frameWidth, frameHeight, ''));
-    x += frameWidth + spacing;
-    if (x + frameWidth > width) {
+    data.addFrame(new Frame(i, x, y, cellWidth, cellHeight, ''));
+    x += cellWidth + spacing;
+    if (x + cellWidth > width) {
       x = margin;
-      y += frameHeight + spacing;
+      y += cellHeight + spacing;
     }
   }
   return data;
@@ -93,7 +89,7 @@ export const jsonDataHash = (game: Game, json: unknown, _key?: string): FrameDat
   let i = 0;
   for (const [key, entry] of Object.entries(frames)) {
     const newFrame = data.addFrame(new Frame(i, entry.frame.x, entry.frame.y, entry.frame.w, entry.frame.h, key));
-    if (entry.trimmed && entry.sourceSize && entry.spriteSourceSize) {
+    if (entry.trimmed === true && entry.sourceSize !== undefined && entry.spriteSourceSize !== undefined) {
       newFrame.setTrim(
         entry.trimmed,
         entry.sourceSize.w,

package/src/phaser/core/array_set.ts

@@ -86,7 +86,7 @@ export class ArraySet<T> {
    */
   public setAll(key: string, value: unknown): void {
     for (const item of this.list) {
-      if (item) {
+      if (item !== undefined) {
         (item as Record<string, unknown>)[key] = value;
       }
     }
@@ -114,7 +114,7 @@ export class ArraySet<T> {
   public removeAll(destroy = false): void {
     for (let i = this.list.length - 1; i >= 0; i -= 1) {
       const entry = this.list[i];
-      if (entry) {
+      if (entry !== undefined) {
         const item = this.remove(entry) as { destroy?: () => void } | null;
         if (destroy) {
           item?.destroy?.();

package/src/phaser/core/cache.ts

@@ -381,7 +381,7 @@ export class Cache {
    */
   public checkURL(url: string): boolean {
     const resolved = this._resolveURL(url);
-    if (resolved && this._urlMap?.[resolved]) {
+    if (resolved !== null && this._urlMap?.[resolved] !== undefined) {
       return true;
     }
     return false;
@@ -481,7 +481,7 @@ export class Cache {
   public getItem(key: string, cache: number, _method: string, property: string | null = null): unknown {
     if (this.checkKey(cache, key)) {
       const entry = this._cacheMap[cache]![key]!;
-      if (!property) {
+      if (property === null) {
         return entry;
       }
       return (entry as Record<string, unknown>)[property];
@@ -705,7 +705,7 @@ export class Cache {
    */
   public getURL(url: string): object | null {
     const resolvedURL = this._resolveURL(url);
-    if (resolvedURL) {
+    if (resolvedURL !== null) {
       return this._urlMap?.[resolvedURL] ?? null;
     }
     this.game.logger.warn('Cache invalid url', { resolvedURL });
@@ -864,7 +864,7 @@ export class Cache {
    */
   public destroy(): void {
     for (const cache of this._cacheMap) {
-      const keys = cache ? Object.keys(cache) : [];
+      const keys = Object.keys(cache);
       for (const key of keys) {
         if (key !== '__default' && key !== '__missing') {
           (cache[key] as { destroy?: () => void }).destroy?.();

package/src/phaser/core/device_util.ts

@@ -96,7 +96,7 @@ export const checkFullScreenSupport = (device: Device): void => {
   const element = document.createElement('div');
   const elementApi = element as unknown as Record<string, unknown>;
   for (const name of fs) {
-    if (elementApi[name]) {
+    if (elementApi[name] !== undefined) {
       device.fullscreen = true;
       device.requestFullscreen = name;
       break;
@@ -105,13 +105,16 @@ export const checkFullScreenSupport = (device: Device): void => {
   if (device.fullscreen) {
     const documentApi = document as unknown as Record<string, unknown>;
     for (const name of cfs) {
-      if (documentApi[name]) {
+      if (documentApi[name] !== undefined) {
         device.cancelFullscreen = name;
         break;
       }
     }
     // ALLOW_KEYBOARD_INPUT is a legacy webkit fullscreen flag, absent from lib.dom
-    if (globalThis.Element && (Element as unknown as { ALLOW_KEYBOARD_INPUT?: number }).ALLOW_KEYBOARD_INPUT) {
+    if (
+      (globalThis.Element as typeof Element | undefined) &&
+      (Element as unknown as { ALLOW_KEYBOARD_INPUT?: number }).ALLOW_KEYBOARD_INPUT !== undefined
+    ) {
       device.fullscreenKeyboard = true;
     }
   }
@@ -190,7 +193,7 @@ export const checkAudio = (device: Device): void => {
   for (const format of formats) {
     const { type, codecs } = format;
     for (const codec of codecs) {
-      if (!device.supportedAudioFormats[type]) {
+      if (device.supportedAudioFormats[type] !== true) {
         const isSupported = isMediaSourceTypeSupported(codec) || canPlayType(audioElement, codec);
         if (isSupported) {
           device.supportedAudioFormats[type] = isSupported;

package/src/phaser/core/dom.ts

@@ -17,7 +17,7 @@ class VisualBoundsDesktopRectangle {
    * @returns {number} The horizontal scroll position in pixels.
    */
   public get x(): number {
-    return globalThis && 'pageXOffset' in globalThis ? window.pageXOffset : document.documentElement.scrollLeft;
+    return 'pageXOffset' in globalThis ? window.pageXOffset : document.documentElement.scrollLeft;
   }
 
   /**
@@ -25,7 +25,7 @@ class VisualBoundsDesktopRectangle {
    * @returns {number} The vertical scroll position in pixels.
    */
   public get y(): number {
-    return globalThis && 'pageYOffset' in globalThis ? window.pageYOffset : document.documentElement.scrollTop;
+    return 'pageYOffset' in globalThis ? window.pageYOffset : document.documentElement.scrollTop;
   }
 
   /**
@@ -81,7 +81,7 @@ class VisualBoundsRectangle {
    * @returns {number} The horizontal scroll position in pixels.
    */
   public get x(): number {
-    return globalThis && 'pageXOffset' in globalThis ? window.pageXOffset : document.documentElement.scrollLeft;
+    return 'pageXOffset' in globalThis ? window.pageXOffset : document.documentElement.scrollLeft;
   }
 
   /**
@@ -89,7 +89,7 @@ class VisualBoundsRectangle {
    * @returns {number} The vertical scroll position in pixels.
    */
   public get y(): number {
-    return globalThis && 'pageYOffset' in globalThis ? window.pageYOffset : document.documentElement.scrollTop;
+    return 'pageYOffset' in globalThis ? window.pageYOffset : document.documentElement.scrollTop;
   }
 
   /**
@@ -199,13 +199,11 @@ export class DOM {
     this.layoutBounds = this.treatAsDesktop ? new LayoutBoundsDesktopRectangle() : new LayoutBoundsRectangle();
     this.documentBounds = new DocumentBoundsRectangle();
     this.scrollXProvider =
-      globalThis && 'pageXOffset' in globalThis
+      'pageXOffset' in globalThis
         ? (): number => window.pageXOffset
         : (): number => document.documentElement.scrollLeft;
     this.scrollYProvider =
-      globalThis && 'pageYOffset' in globalThis
-        ? (): number => window.pageYOffset
-        : (): number => document.documentElement.scrollTop;
+      'pageYOffset' in globalThis ? (): number => window.pageYOffset : (): number => document.documentElement.scrollTop;
   }
 
   /**
@@ -233,11 +231,13 @@ export class DOM {
    * @returns {boolean} True if bounds were successfully retrieved, false otherwise.
    */
   public getBounds(element: HTMLCanvasElement, cushion = 0): CalibratedBounds | false {
-    element = element && !element.nodeType ? (element as unknown as HTMLCanvasElement[])[0]! : element;
-    if (!element || element.nodeType !== 1) {
+    // a jQuery-style wrapper was accepted here historically, so unwrap the first entry of one
+    const wrapped = element as HTMLCanvasElement | undefined;
+    const target = wrapped && !wrapped.nodeType ? (element as unknown as HTMLCanvasElement[])[0] : wrapped;
+    if (target?.nodeType !== 1) {
       return false;
     }
-    return this.calibrate(element.getBoundingClientRect(), cushion);
+    return this.calibrate(target.getBoundingClientRect(), cushion);
   }
 
   /**
@@ -266,16 +266,21 @@ export class DOM {
    * @returns {string} The screen orientation ('portrait-primary', 'landscape-primary', etc.).
    */
   public getScreenOrientation(primaryFallback: string | null = null): OrientationType {
-    const { screen } = globalThis;
-    // @ts-expect-error the prefixed orientation properties predate the standard one and are absent from lib.dom
-    const orientation = screen.orientation || screen.mozOrientation || screen.msOrientation;
-    if (orientation && typeof orientation.type === 'string') {
-      // Screen Orientation API specification
-      return orientation.type;
-    } else if (typeof orientation === 'string') {
+    // the prefixed orientation properties predate the standard one and are absent from lib.dom
+    const screen = globalThis.screen as Screen & {
+      mozOrientation?: string;
+      msOrientation?: string;
+    };
+    const orientation: ScreenOrientation | string | undefined =
+      screen.orientation ?? screen.mozOrientation ?? screen.msOrientation;
+    if (typeof orientation === 'string') {
       // moz/ms-orientation are strings
       return orientation;
     }
+    if (typeof orientation?.type === 'string') {
+      // Screen Orientation API specification
+      return orientation.type;
+    }
     const PORTRAIT = 'portrait-primary';
     const LANDSCAPE = 'landscape-primary';
     if (primaryFallback === 'screen') {
@@ -288,7 +293,7 @@ export class DOM {
     if (primaryFallback === 'window.orientation' && typeof legacyOrientation === 'number') {
       // This may change by device based on "natural" orientation.
       return legacyOrientation === 0 || legacyOrientation === 180 ? PORTRAIT : LANDSCAPE;
-    } else if (globalThis.matchMedia) {
+    } else if (typeof globalThis.matchMedia === 'function') {
       if (globalThis.matchMedia('(orientation: portrait)').matches) {
         return PORTRAIT;
       } else if (globalThis.matchMedia('(orientation: landscape)').matches) {

package/src/phaser/core/frame_data.ts

@@ -20,10 +20,7 @@ export class FrameData {
   }
 
   public getFrame(index = 0): Frame {
-    if (index >= this._frames.length) {
-      index = 0;
-    }
-    return this._frames[index]!;
+    return this._frames[index >= this._frames.length ? 0 : index]!;
   }
 
   public getFrameByName(name: string): Frame | null {
@@ -59,7 +56,7 @@ export class FrameData {
     output: number[] | null = null
   ): number[] {
     const result = output ?? [];
-    if (frames && frames.length > 0) {
+    if (((frames as (string | number)[] | undefined)?.length ?? 0) > 0) {
       for (const f of frames) {
         if (useNumericIndex && this._frames[f as number]) {
           result.push(this._frames[f as number]!.index);

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

@@ -0,0 +1,131 @@
+import { afterAll, afterEach, beforeAll, describe, expect, it, vi } from 'vitest';
+import { RENDER_CANVAS } from './const.js';
+import { Game } from './game.js';
+
+// happy-dom has no canvas implementation, so booting needs the smallest 2D context the canvas
+// renderer touches. Booting is the one path that wires every subsystem together, which makes it the
+// regression net for guards that only fire while the game is half-built.
+const createContext2D = (): CanvasRenderingContext2D =>
+  ({
+    font: '',
+    fillStyle: '',
+    strokeStyle: '',
+    globalAlpha: 1,
+    globalCompositeOperation: 'source-over',
+    imageSmoothingEnabled: true,
+    clearRect: vi.fn(),
+    fillRect: vi.fn(),
+    drawImage: vi.fn(),
+    setTransform: vi.fn(),
+    save: vi.fn(),
+    restore: vi.fn(),
+    translate: vi.fn(),
+    getImageData: (): ImageData => ({ data: new Uint8ClampedArray(4) }) as ImageData,
+    putImageData: vi.fn(),
+    measureText: (value: string) => ({ width: value.length * 8 }),
+  }) as unknown as CanvasRenderingContext2D;
+
+const createGame = (): Game =>
+  new Game({
+    width: 320,
+    height: 240,
+    renderType: RENDER_CANVAS,
+    isSkipTicker: true,
+  });
+
+describe('Game', () => {
+  const originalGetContext = HTMLCanvasElement.prototype.getContext;
+
+  beforeAll(() => {
+    HTMLCanvasElement.prototype.getContext = function getContext(
+      this: HTMLCanvasElement,
+      id: string
+    ): CanvasRenderingContext2D | null {
+      return id === '2d' ? createContext2D() : null;
+    } as typeof HTMLCanvasElement.prototype.getContext;
+  });
+
+  afterEach(() => {
+    document.body.innerHTML = '';
+  });
+
+  afterAll(() => {
+    HTMLCanvasElement.prototype.getContext = originalGetContext;
+  });
+
+  describe('boot', () => {
+    it('brings the game up', () => {
+      expect(createGame().isBooted).toBe(true);
+    });
+
+    it('wires every subsystem', () => {
+      const game = createGame();
+      expect(game.scale).toBeDefined();
+      expect(game.stage).toBeDefined();
+      expect(game.world).toBeDefined();
+      expect(game.add).toBeDefined();
+      expect(game.cache).toBeDefined();
+      expect(game.load).toBeDefined();
+      expect(game.time).toBeDefined();
+      expect(game.tweens).toBeDefined();
+      expect(game.input).toBeDefined();
+      expect(game.sound).toBeDefined();
+      expect(game.renderer).toBeDefined();
+    });
+
+    it('takes the size from the config', () => {
+      const game = createGame();
+      expect(game.width).toBe(320);
+      expect(game.height).toBe(240);
+      expect(game.scale.width).toBe(320);
+      expect(game.scale.height).toBe(240);
+    });
+
+    it('gives the scale manager an input scale once input is up', () => {
+      expect(createGame().input.scale.x).toBeGreaterThan(0);
+    });
+
+    it('attaches the canvas to the document', () => {
+      const game = createGame();
+      expect(game.canvas.parentElement).not.toBeNull();
+    });
+
+    it('skips the ticker when the config asks it to', () => {
+      expect(createGame().raf).toBeUndefined();
+    });
+
+    it('defaults the size when the config gives none', () => {
+      const game = new Game({ renderType: RENDER_CANVAS, isSkipTicker: true });
+      expect(game.width).toBe(800);
+      expect(game.height).toBe(600);
+    });
+  });
+
+  describe('update', () => {
+    it('advances the clock and the world without throwing', () => {
+      const game = createGame();
+      expect(() => {
+        game.update(16);
+        game.update(32);
+      }).not.toThrow();
+    });
+  });
+
+  describe('config', () => {
+    it('takes a canvas supplied by the config instead of creating one', () => {
+      const canvas = document.createElement('canvas');
+      const game = new Game({ width: 320, height: 240, renderType: RENDER_CANVAS, isSkipTicker: true, canvas });
+      expect(game.canvas).toBe(canvas);
+    });
+  });
+
+  describe('destroy', () => {
+    it('detaches the canvas and drops it', () => {
+      const game = createGame();
+      const { canvas } = game;
+      game.destroy();
+      expect(canvas.parentElement).toBeNull();
+      expect(game.canvas).toBeNull();
+    });
+  });
+});

package/src/phaser/core/game.ts

@@ -165,10 +165,10 @@ export class Game {
     this.input.boot();
     this.sound.boot();
     this.state.boot();
-    if (window.focus) {
+    if (typeof window.focus === 'function') {
       window.focus();
     }
-    if (!this.config.isSkipTicker) {
+    if (this.config.isSkipTicker !== true) {
       this.raf = new RequestAnimationFrame(this);
       this.raf.start();
     }
@@ -180,7 +180,7 @@ export class Game {
    */
   public createRendererCanvas(): void {
     this.logger.info('createRendererCanvas');
-    if (this.canvas) {
+    if (this.canvas as HTMLCanvasElement | undefined) {
       removeFromDOM(this.canvas);
     }
     this.canvas = this.config.canvas ?? create(this, this.width, this.height, this.config.canvasID, true);
@@ -212,10 +212,10 @@ export class Game {
         isWebGlReady = true;
       } catch (error) {
         isWebGlReady = false;
-        if (globalThis.PhaserRegistry?.GL_PROGRAM_INFO_LOG) {
+        if (globalThis.PhaserRegistry?.GL_PROGRAM_INFO_LOG != null) {
           this.logger.warn('WebGL program info', { log: globalThis.PhaserRegistry.GL_PROGRAM_INFO_LOG });
         }
-        if (globalThis.PhaserRegistry?.GL_SHADER_INFO_LOG) {
+        if (globalThis.PhaserRegistry?.GL_SHADER_INFO_LOG != null) {
           this.logger.warn('WebGL shader info', { log: globalThis.PhaserRegistry.GL_SHADER_INFO_LOG });
         }
         const typedError = error instanceof Error ? error : new Error(String(error));
@@ -229,7 +229,7 @@ export class Game {
       if (this.contextRestoredBinded) {
         this.canvas.removeEventListener('webglcontextlost', this.contextRestoredBinded, false);
       }
-      if (this.renderer) {
+      if (this.renderer as CanvasRenderer | WebGLRenderer | undefined) {
         this.renderer.destroy();
       }
       this.createRendererCanvas();
@@ -278,7 +278,12 @@ export class Game {
     this.parseConfigElement(config, 'renderType', RENDER_AUTO);
     this.parseConfigElement(config, 'isForceDisabledAudio', false);
     this.parseConfigElement(config, 'maxParallelDownloads', 16);
-    if (config.parent) {
+    this.parseConfigElement(config, 'canvas');
+    this.parseConfigElement(config, 'isSkipTicker');
+    this.parseConfigElement(config, 'scaleMode');
+    this.parseConfigElement(config, 'fullScreenScaleMode');
+    this.parseConfigElement(config, 'fullScreenTarget');
+    if (config.parent !== undefined) {
       this.parent = config.parent;
     }
     this.state = new SceneManager(this, config.state ?? null);
@@ -291,7 +296,7 @@ export class Game {
   public contextLost(event: Event): void {
     this.logger.info('contextLost', { type: event.type });
     event.preventDefault();
-    if (this.renderer) {
+    if (this.renderer as CanvasRenderer | WebGLRenderer | undefined) {
       this.renderer.contextLost = true;
     }
   }
@@ -302,7 +307,7 @@ export class Game {
    */
   public contextRestored(event: Event): void {
     this.logger.info('contextRestored', { type: event.type });
-    if (this.renderer) {
+    if (this.renderer as CanvasRenderer | WebGLRenderer | undefined) {
       this.renderer.initContext(this);
       // This.cache.clearGLTextures();
       this.renderer.contextLost = false;
@@ -340,10 +345,10 @@ export class Game {
     this.logger.info('destroy');
     this.isPaused = true;
 
-    if (!this.cache) {
+    if (!(this.cache as Cache | undefined)) {
       return;
     }
-    if (this.raf) {
+    if (this.raf as RequestAnimationFrame | undefined) {
       this.raf.stop();
     }
 
@@ -354,7 +359,7 @@ export class Game {
     this.stage.destroy();
     this.input.destroy();
 
-    if (this.canvas) {
+    if (this.canvas as HTMLCanvasElement | undefined) {
       if (this.contextLostBinded) {
         this.canvas.removeEventListener('webglcontextlost', this.contextLostBinded, false);
       }

package/src/phaser/core/input.ts

@@ -443,8 +443,9 @@ export class Input {
     }
     this.getLocalPosition(displayObject, pointer, this._localPoint);
     localPoint.copyFrom(this._localPoint);
-    if (displayObject.hitArea && displayObject.hitArea.contains) {
-      return displayObject.hitArea.contains(this._localPoint.x, this._localPoint.y);
+    const { hitArea } = displayObject;
+    if (hitArea && (hitArea.contains as ((x: number, y: number) => boolean) | undefined)) {
+      return hitArea.contains(this._localPoint.x, this._localPoint.y);
     } else if (displayObject instanceof Image) {
       const { width } = displayObject.texture.frame;
       const { height } = displayObject.texture.frame;
@@ -457,7 +458,7 @@ export class Input {
       }
     } else if (displayObject instanceof Graphics) {
       for (const data of displayObject.graphicsData) {
-        if (data.fill && data.shape && data.shape.contains(this._localPoint.x, this._localPoint.y)) {
+        if (data.fill && (data.shape?.contains(this._localPoint.x, this._localPoint.y) ?? false)) {
           // Only deal with fills..
           return true;
         }

package/src/phaser/core/input_handler.ts

@@ -6,6 +6,7 @@ import type { Image } from '../display/image.js';
 import type { Pointer } from './input_pointer.js';
 import type { Rectangle } from '../geom/rectangle.js';
 import type { Game } from './game.js';
+import type { EventManager } from './event_manager.js';
 
 interface PointerData {
   id: number;
@@ -223,7 +224,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 +403,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 +431,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 +512,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 +561,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?.events as EventManager | undefined)) {
         this.sprite.events.onInputOver$dispatch(this.sprite, pointer);
       }
       if (this.sprite.parent && this.sprite.parent.type === GROUP) {
@@ -587,9 +588,9 @@ export class InputHandler {
       this.game.canvas.style.cursor = 'default';
       this._setHandCursor = false;
     }
-    if (!silent && this.sprite && this.sprite.events) {
+    if (!silent && (this.sprite?.events as EventManager | undefined)) {
       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 +616,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?.events as EventManager | undefined) {
         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 +651,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 +674,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?.events as EventManager | undefined) {
         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 +844,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

@@ -106,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);
     }
   }
@@ -132,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);
     }
   }

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;