@vpmedia/phaser 1.123.0 → 1.125.0

package/src/phaser/core/loader.ts

@@ -83,6 +83,15 @@ export type LoaderFile = {
   ySpacing?: number;
 };
 
+/** The sprite the loader crops as a progress bar, with the rectangle it crops to. */
+export type PreloadSprite = {
+  sprite: Image;
+  direction: number;
+  width: number;
+  height: number;
+  rect: Rectangle;
+};
+
 export class Loader {
   public game!: Game;
   public cache!: Cache;
@@ -91,7 +100,7 @@ export class Loader {
   public isUseRetry!: boolean;
   public maxRetry!: number;
   public hasLoaded!: boolean;
-  public preloadSprite!: any;
+  public preloadSprite!: PreloadSprite | null;
   public crossOrigin!: boolean | string;
   public baseURL!: string;
   public path!: string;
@@ -162,10 +171,8 @@ export class Loader {
       direction,
       width: sprite.width,
       height: sprite.height,
-      rect: null,
+      rect: direction === 0 ? new Rectangle(0, 0, 1, sprite.height) : new Rectangle(0, 0, sprite.width, 1),
     };
-    this.preloadSprite.rect =
-      direction === 0 ? new Rectangle(0, 0, 1, sprite.height) : new Rectangle(0, 0, sprite.width, 1);
     sprite.crop(this.preloadSprite.rect);
     sprite.visible = true;
   }
@@ -217,7 +224,7 @@ export class Loader {
    * @param {string} key - The key of the file to get.
    * @returns {{index: number, file: object} | null} The file and its index, or null if not found.
    */
-  public getAsset(type: string, key: string) {
+  public getAsset(type: string, key: string): { index: number; file: LoaderFile } | null {
     const fileIndex = this.getAssetIndex(type, key);
     if (fileIndex > -1) {
       return { index: fileIndex, file: this._fileList[fileIndex]! };
@@ -275,19 +282,19 @@ export class Loader {
       this.game.logger.warn(`Loader: Invalid or no key given of type ${type}`);
       return this;
     }
-    if (url === undefined || url === null) {
-      if (extension) {
-        url = key + extension;
-      } else {
+    let resolvedUrl = url;
+    if (resolvedUrl === undefined || resolvedUrl === null) {
+      if (extension === null) {
         this.game.logger.warn(`Loader: No URL given for file type: ${type} key: ${key}`);
         return this;
       }
+      resolvedUrl = key + extension;
     }
     const file: LoaderFile = {
       type,
       key,
       path: this.path,
-      url,
+      url: resolvedUrl,
       syncPoint: this._withSyncPointDepth > 0,
       data: null,
       loading: false,
@@ -344,11 +351,9 @@ export class Loader {
       error: false,
       callbackContext,
     };
-    if (data) {
-      if (typeof data === 'string') {
-        data = JSON.parse(data);
-      }
-      pack.data = (data ?? {}) as LoaderFileData;
+    if (data !== null) {
+      const parsed: unknown = typeof data === 'string' ? JSON.parse(data) : data;
+      pack.data = (parsed ?? {}) as LoaderFileData;
       pack.loaded = true;
     }
     for (let i = 0; i < this._fileList.length + 1; i += 1) {
@@ -466,10 +471,8 @@ export class Loader {
     if (this.game.sound.noAudio || this.game.device.noAudioFormat) {
       return this;
     }
-    if (typeof urls === 'string') {
-      urls = [urls];
-    }
-    return this.addToFileList('audio', key, urls, { buffer: null, autoDecode });
+    const sources = typeof urls === 'string' ? [urls] : urls;
+    return this.addToFileList('audio', key, sources, { buffer: null, autoDecode });
   }
 
   /**
@@ -488,11 +491,9 @@ export class Loader {
     this.audio(key, urls, autoDecode);
     if (jsonURL) {
       this.json(`${key}-audioatlas`, jsonURL);
-    } else if (jsonData) {
-      if (typeof jsonData === 'string') {
-        jsonData = JSON.parse(jsonData);
-      }
-      this.cache.addJSON(`${key}-audioatlas`, '', jsonData);
+    } else if (jsonData !== null) {
+      const parsed: unknown = typeof jsonData === 'string' ? JSON.parse(jsonData) : jsonData;
+      this.cache.addJSON(`${key}-audioatlas`, '', parsed);
     }
     return this;
   }
@@ -516,29 +517,27 @@ export class Loader {
     xSpacing = 0,
     ySpacing = 0
   ): this {
-    textureURL ??= `${key}.png`;
-    if (atlasURL === null && atlasData === null) {
-      atlasURL = `${key}.xml`;
-    }
+    const texture = textureURL ?? `${key}.png`;
+    const atlas = atlasURL === null && atlasData === null ? `${key}.xml` : atlasURL;
     //  A URL to a json/xml atlas has been given
-    if (atlasURL) {
-      this.addToFileList('bitmapfont', key, textureURL, { atlasURL, xSpacing, ySpacing });
+    if (atlas !== null) {
+      this.addToFileList('bitmapfont', key, texture, { atlasURL: atlas, xSpacing, ySpacing });
     } else if (typeof atlasData === 'string') {
       //  A stringified xml/json atlas has been given
-      let json = null;
-      let xml = null;
+      let json: unknown = null;
+      let xml: XMLDocument | null = null;
       try {
-        json = JSON.parse(atlasData);
+        json = JSON.parse(atlasData) as unknown;
       } catch {
         xml = this.parseXml(atlasData);
       }
-      if (!xml && !json) {
+      if (xml === null && json === null) {
         throw new Error(ENGINE_ERROR_INVALID_BITMAP_FONT_ATLAS);
       }
-      this.addToFileList('bitmapfont', key, textureURL, {
+      this.addToFileList('bitmapfont', key, texture, {
         atlasURL: null,
         atlasData: json ?? xml,
-        atlasType: json ? 'json' : 'xml',
+        atlasType: json === null ? 'xml' : 'json',
         xSpacing,
         ySpacing,
       });
@@ -562,15 +561,13 @@ export class Loader {
     atlasData: unknown = null,
     format: number = TEXTURE_ATLAS_JSON_HASH
   ): this {
-    textureURL ??= `${key}.png`;
-    if (!atlasURL && !atlasData) {
-      atlasURL = `${key}.json`;
-    }
+    const texture = textureURL ?? `${key}.png`;
+    const atlas = atlasURL === null && atlasData === null ? `${key}.json` : atlasURL;
     //  A URL to a json/xml file has been given
-    if (atlasURL) {
-      this.addToFileList('textureatlas', key, textureURL, { atlasURL, format });
+    if (atlas !== null) {
+      this.addToFileList('textureatlas', key, texture, { atlasURL: atlas, format });
     } else {
-      this.addToFileList('textureatlas', key, textureURL, { atlasURL: null, atlasData, format });
+      this.addToFileList('textureatlas', key, texture, { atlasURL: null, atlasData, format });
     }
     return this;
   }
@@ -694,7 +691,7 @@ export class Loader {
         }
       } else if (!file.loading && this._flightQueue.length < inflightLimit) {
         // -> not loaded/failed, not loading
-        if (file.type === 'packfile' && !file.data) {
+        if (file.type === 'packfile' && file.data === null) {
           // Fetches the pack data: the pack is processed above as it reaches queue-start.
           // (Packs do not trigger onLoadStart or onFileStart.)
           this._flightQueue.push(file);
@@ -885,7 +882,7 @@ export class Loader {
       }
       case 'audio': {
         const resolved = this.getAudioURL(file.url);
-        if (resolved) {
+        if (resolved !== null) {
           file.url = resolved;
           this.xhrLoad(file, this.transformUrl(resolved, file), 'arraybuffer', this.fileComplete);
         } else if (this.game.sound.noAudio) {
@@ -940,9 +937,9 @@ export class Loader {
       { once: true }
     );
     image.addEventListener('error', (): void => {
-      if (this.isUseRetry && (!file.numRetry || file.numRetry < this.maxRetry)) {
+      if (this.isUseRetry && (file.numRetry === undefined || file.numRetry < this.maxRetry)) {
         setTimeout((): void => {
-          file.numRetry = file.numRetry ? file.numRetry + 1 : 1;
+          file.numRetry = file.numRetry === undefined ? 1 : file.numRetry + 1;
           this.loadImageTag(file);
         }, 1000);
       } else if (!settled) {
@@ -986,16 +983,16 @@ export class Loader {
       xhr.setRequestHeader('X-Requested-With', requestedWith);
     }
     const acceptHeader = this.headers[file.type];
-    if (acceptHeader) {
+    if (acceptHeader !== undefined && acceptHeader !== false) {
       xhr.setRequestHeader('Accept', acceptHeader);
     }
     const handleError = onerror ?? this.fileError;
     const retry = (): boolean => {
-      if (!this.isUseRetry || (file.numRetry && file.numRetry >= this.maxRetry)) {
+      if (!this.isUseRetry || (file.numRetry !== undefined && file.numRetry >= this.maxRetry)) {
         return false;
       }
       setTimeout((): void => {
-        file.numRetry = file.numRetry ? file.numRetry + 1 : 1;
+        file.numRetry = file.numRetry === undefined ? 1 : file.numRetry + 1;
         this.xhrLoad(file, url, type, onload, handleError);
       }, 1000);
       return true;
@@ -1094,10 +1091,8 @@ export class Loader {
    */
   public fileError(file: LoaderFile, xhr: XMLHttpRequest | null = null, reason: unknown = 0): void {
     // const url = file.requestUrl || this.transformUrl(file.url, file);
-    if (!reason && xhr) {
-      reason = xhr.status;
-    }
-    const message = `Error loading asset (${String(reason)})`;
+    const cause = reason === 0 && xhr !== null ? xhr.status : reason;
+    const message = `Error loading asset (${String(cause)})`;
     this.asyncComplete(file, message);
   }
 
@@ -1115,7 +1110,7 @@ export class Loader {
     switch (file.type) {
       case 'packfile': {
         // Pack data must never be false-ish after it is fetched without error
-        file.data = JSON.parse(response.responseText) ?? {};
+        file.data = (JSON.parse(response.responseText) ?? {}) as LoaderFileData;
         break;
       }
       case 'image': {
@@ -1149,7 +1144,7 @@ export class Loader {
         break;
       }
       case 'bitmapfont': {
-        if (!file.atlasURL) {
+        if (file.atlasURL === null || file.atlasURL === undefined) {
           this.cache.addBitmapFont(
             file.key,
             url,
@@ -1167,14 +1162,14 @@ export class Loader {
             this.transformUrl(file.atlasURL, file),
             'text',
             (bitmapFontFile: LoaderFile, bitmapFontXhr: XMLHttpRequest): void => {
-              let json;
+              let json: unknown;
               try {
                 // Try to parse as JSON, if it fails, then it's hopefully XML
-                json = JSON.parse(bitmapFontXhr.responseText);
+                json = JSON.parse(bitmapFontXhr.responseText) as unknown;
               } catch {
                 // pass
               }
-              if (json) {
+              if (json !== undefined) {
                 bitmapFontFile.atlasType = 'json';
                 this.jsonLoadComplete(bitmapFontFile, bitmapFontXhr);
               } else {
@@ -1190,7 +1185,7 @@ export class Loader {
         const audio = response.response as ArrayBuffer;
         file.data = audio;
         this.cache.addSound(file.key, url, audio);
-        if (file.autoDecode) {
+        if (file.autoDecode === true) {
           void this.game.sound.decode(file.key);
         }
         break;
@@ -1217,7 +1212,7 @@ export class Loader {
    * @param {XMLHttpRequest} xhr - The XMLHttpRequest object containing the file data.
    */
   public jsonLoadComplete(file: LoaderFile, xhr: XMLHttpRequest): void {
-    const data = JSON.parse(xhr.responseText);
+    const data = JSON.parse(xhr.responseText) as unknown;
     const url = typeof file.url === 'string' ? file.url : '';
     if (file.type === 'bitmapfont') {
       this.cache.addBitmapFont(
@@ -1254,7 +1249,8 @@ export class Loader {
     const data = xhr.responseText;
     const xml = this.parseXml(data);
     if (!xml) {
-      const responseType = xhr.responseType || (xhr as any).contentType; // contentType for MS-XDomainRequest
+      // contentType is the MS-XDomainRequest name for the same thing
+      const responseType = xhr.responseType || (xhr as unknown as { contentType?: string }).contentType;
       this.game.logger.warn(`${file.key}: invalid XML (${responseType})`);
       this.asyncComplete(file, 'invalid XML');
       return;
@@ -1283,22 +1279,14 @@ export class Loader {
    * @param {object} data - The XML string data to parse.
    * @returns {Document} The parsed DOM Document, or null if parsing failed.
    */
-  public parseXml(data: string) {
-    let xml = null;
+  public parseXml(data: string): XMLDocument | null {
+    let xml: XMLDocument | null = null;
     try {
-      if (globalThis.DOMParser) {
-        const domparser = new DOMParser();
-        xml = domparser.parseFromString(data, 'text/xml');
-      } else {
-        xml = new globalThis.ActiveXObject('Microsoft.XMLDOM');
-        // Why is this 'false'?
-        xml.async = 'false';
-        xml.loadXML(data);
-      }
+      xml = new DOMParser().parseFromString(data, 'text/xml');
     } catch {
       xml = null;
     }
-    if (!xml || !xml.documentElement || xml.querySelectorAll('parsererror').length > 0) {
+    if (!xml?.documentElement || xml.querySelectorAll('parsererror').length > 0) {
       return null;
     }
     return xml;
@@ -1314,7 +1302,7 @@ export class Loader {
       } else {
         this.preloadSprite.rect.height = Math.floor((this.preloadSprite.height / 100) * this.progress);
       }
-      if (this.preloadSprite.sprite) {
+      if (this.preloadSprite.sprite !== null) {
         this.preloadSprite.sprite.updateCrop();
       } else {
         // We seem to have lost our sprite - maybe it was destroyed?

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

@@ -33,64 +33,64 @@ const FONT_JSON = {
   },
 };
 
-describe('bitmap font parsing', () => {
-  describe('xmlBitmapFont', () => {
-    it('reads the font metrics', () => {
+describe('bitmap font parsing', (): void => {
+  describe('xmlBitmapFont', (): void => {
+    it('reads the font metrics', (): void => {
       const data = xmlBitmapFont(parseXml(FONT_XML), baseTexture, 0, 0);
       expect(data.font).toBe('Arial');
       expect(data.size).toBe(32);
       expect(data.lineHeight).toBe(40);
     });
 
-    it('reads every glyph, keyed by character code', () => {
+    it('reads every glyph, keyed by character code', (): void => {
       const data = xmlBitmapFont(parseXml(FONT_XML), baseTexture, 0, 0);
       expect(Object.keys(data.chars)).toStrictEqual(['65', '66']);
       expect(data.chars[65]).toMatchObject({ x: 0, y: 0, width: 20, height: 30, xOffset: 1, yOffset: 2 });
     });
 
-    it('adds the spacing arguments to advance and line height', () => {
+    it('adds the spacing arguments to advance and line height', (): void => {
       const data = xmlBitmapFont(parseXml(FONT_XML), baseTexture, 5, 7);
       expect(data.chars[65]?.xAdvance).toBe(26);
       expect(data.lineHeight).toBe(47);
     });
 
-    it('records kerning against the second character of the pair', () => {
+    it('records kerning against the second character of the pair', (): void => {
       const data = xmlBitmapFont(parseXml(FONT_XML), baseTexture, 0, 0);
       expect(data.chars[66]?.kerning[65]).toBe(-3);
     });
 
-    it('attaches a texture to every glyph', () => {
+    it('attaches a texture to every glyph', (): void => {
       const data = xmlBitmapFont(parseXml(FONT_XML), baseTexture, 0, 0);
       expect(data.chars[65]?.texture).toBeDefined();
       expect(data.chars[66]?.texture).toBeDefined();
     });
 
-    it('survives a font with no kerning table', () => {
+    it('survives a font with no kerning table', (): void => {
       const markup = FONT_XML.replace(/<kernings>[\s\S]*<\/kernings>/, '');
       expect(() => xmlBitmapFont(parseXml(markup), baseTexture, 0, 0)).not.toThrow();
     });
 
-    it('ignores kerning that names a character the font does not have', () => {
+    it('ignores kerning that names a character the font does not have', (): void => {
       const markup = FONT_XML.replace('second="66"', 'second="999"');
       const data = xmlBitmapFont(parseXml(markup), baseTexture, 0, 0);
       expect(data.chars[66]?.kerning).toStrictEqual({});
     });
 
-    it('falls back to an empty face when the info element is missing', () => {
+    it('falls back to an empty face when the info element is missing', (): void => {
       const markup = FONT_XML.replace(/<info[^>]*\/>/, '');
       expect(xmlBitmapFont(parseXml(markup), baseTexture, 0, 0).font).toBe('');
     });
   });
 
-  describe('jsonBitmapFont', () => {
-    it('reads the same metrics as the xml form', () => {
+  describe('jsonBitmapFont', (): void => {
+    it('reads the same metrics as the xml form', (): void => {
       const data = jsonBitmapFont(FONT_JSON, baseTexture, 0, 0);
       expect(data.font).toBe('Arial');
       expect(data.size).toBe(32);
       expect(data.lineHeight).toBe(40);
     });
 
-    it('produces the same glyphs as the xml form', () => {
+    it('produces the same glyphs as the xml form', (): void => {
       const fromJson = jsonBitmapFont(FONT_JSON, baseTexture, 0, 0);
       const fromXml = xmlBitmapFont(parseXml(FONT_XML), baseTexture, 0, 0);
       for (const code of [65, 66]) {
@@ -102,13 +102,13 @@ describe('bitmap font parsing', () => {
       }
     });
 
-    it('records the same kerning as the xml form', () => {
+    it('records the same kerning as the xml form', (): void => {
       expect(jsonBitmapFont(FONT_JSON, baseTexture, 0, 0).chars[66]?.kerning[65]).toBe(-3);
     });
   });
 
-  describe('bitmapFont', () => {
-    it('parses the xml form', () => {
+  describe('bitmapFont', (): void => {
+    it('parses the xml form', (): void => {
       expect(bitmapFont(parseXml(FONT_XML), baseTexture, 0, 0).font).toBe('Arial');
     });
   });

package/src/phaser/core/loader_parser.ts

@@ -16,6 +16,16 @@ export type BitmapFontChar = {
 };
 
 /** A parsed bitmap font: its metrics and the glyphs it can draw. */
+/** A bitmap font descriptor in the JSON form the packers emit, with attributes prefixed by `_`. */
+export type JsonBitmapFontDescriptor = {
+  font: {
+    info: Record<string, string>;
+    common: Record<string, string>;
+    chars: { char: Record<string, string>[] };
+    kernings?: { kerning?: Record<string, string>[] };
+  };
+};
+
 export type BitmapFontData = {
   font: string;
   size: number;
@@ -104,18 +114,18 @@ export const bitmapFont = (
  * @returns {object} The parsed bitmap font data.
  */
 export const jsonBitmapFont = (
-  json: any,
+  json: JsonBitmapFontDescriptor,
   baseTexture: BaseTexture,
   xSpacing: number,
   ySpacing: number
 ): BitmapFontData => {
   const data: BitmapFontData = {
-    font: json.font.info._face,
-    size: Math.trunc(Number(json.font.info._size)),
-    lineHeight: Math.trunc(Number(json.font.common._lineHeight)) + ySpacing,
+    font: json.font.info['_face'] ?? '',
+    size: Math.trunc(Number(json.font.info['_size'])),
+    lineHeight: Math.trunc(Number(json.font.common['_lineHeight'])) + ySpacing,
     chars: {},
   };
-  for (const letter of json.font.chars.char as Record<string, string>[]) {
+  for (const letter of json.font.chars.char) {
     const charCode = Math.trunc(Number(letter['_id']));
     data.chars[charCode] = {
       x: Math.trunc(Number(letter['_x'])),
@@ -129,7 +139,7 @@ export const jsonBitmapFont = (
     };
   }
   if (json.font.kernings && json.font.kernings.kerning) {
-    for (const kerning of json.font.kernings.kerning as Record<string, string>[]) {
+    for (const kerning of json.font.kernings.kerning) {
       const char = data.chars[Math.trunc(Number(kerning['_second']))];
       if (char) {
         char.kerning[Math.trunc(Number(kerning['_first']))] = Math.trunc(Number(kerning['_amount']));

package/src/phaser/core/raf.ts

@@ -1,6 +1,6 @@
 import type { Game } from './game.js';
 export class RequestAnimationFrame {
-  public game: any;
+  public game: Game;
   public rafId: number;
 
   /**

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

@@ -1,28 +1,28 @@
 import { beforeEach, describe, expect, it } from 'vitest';
 import { getRegistry } from './registry.js';
 
-describe('getRegistry', () => {
-  beforeEach(() => {
+describe('getRegistry', (): void => {
+  beforeEach((): void => {
     // @ts-expect-error the registry is created on demand, so tests may clear it
     delete globalThis.PhaserRegistry;
   });
 
-  it('creates the registry on first access', () => {
+  it('creates the registry on first access', (): void => {
     expect(globalThis.PhaserRegistry).toBeUndefined();
     expect(getRegistry()).toBeDefined();
     expect(globalThis.PhaserRegistry).toBeDefined();
   });
 
-  it('returns the same object on repeat access', () => {
+  it('returns the same object on repeat access', (): void => {
     expect(getRegistry()).toBe(getRegistry());
   });
 
-  it('preserves members written by subsystems', () => {
+  it('preserves members written by subsystems', (): void => {
     getRegistry().GL_CONTEXT_ID = 7;
     expect(getRegistry().GL_CONTEXT_ID).toBe(7);
   });
 
-  it('does not clobber a registry that already exists', () => {
+  it('does not clobber a registry that already exists', (): void => {
     const existing = getRegistry();
     existing.stencilBufferLimit = 3;
     expect(getRegistry()).toBe(existing);

package/src/phaser/core/scale_manager.ts

@@ -5,6 +5,7 @@ import type { Game, GameConfig } from './game.js';
 import { DOM } from './dom.js';
 import { Signal } from './signal.js';
 import type { AppliedCallback, Callback } from './callback.js';
+import type { Input } from './input.js';
 
 /** The gap the canvas leaves around itself inside its parent. */
 export type ScaleMargin = { left: number; top: number; right: number; bottom: number; x: number; y: number };
@@ -159,7 +160,7 @@ export class ScaleManager {
     this._lastReportedCanvasSize = new Rectangle();
     this._lastReportedGameSize = new Rectangle();
     this._booted = false;
-    if (game.config) {
+    if (game.config as GameConfig | undefined) {
       this.parseConfig(game.config);
     }
     this.setupScale(width, height);
@@ -249,7 +250,7 @@ export class ScaleManager {
       if (typeof this.game.parent === 'string') {
         // hopefully an element ID
         target = document.querySelector<HTMLElement>(`#${CSS.escape(this.game.parent)}`);
-      } else if (this.game.parent && this.game.parent.nodeType === 1) {
+      } else if (typeof this.game.parent === 'object' && this.game.parent.nodeType === 1) {
         // quick test for a HTMLelement
         target = this.game.parent;
       }
@@ -447,12 +448,12 @@ export class ScaleManager {
     this.scaleFactorInversed.y = this.height / this.game.height;
     this.aspectRatio = this.width / this.height;
     // This can be invoked in boot pre-canvas
-    if (this.game.canvas) {
+    if (this.game.canvas as HTMLCanvasElement | undefined) {
       this.dom.getOffset(this.game.canvas, this.offset);
     }
     this.bounds.setTo(this.offset.x, this.offset.y, this.width, this.height);
     // Can be invoked in boot pre-input
-    if (this.game.input && this.game.input.scale) {
+    if (this.game.input as Input | undefined) {
       this.game.input.scale.setTo(this.scaleFactor.x, this.scaleFactor.y);
     }
   }
@@ -579,7 +580,7 @@ export class ScaleManager {
    * @returns {Rectangle} TBD.
    */
   public getParentBounds(target: Rectangle): Rectangle {
-    const bounds = target || new Rectangle();
+    const bounds = target ?? new Rectangle();
     const parentNode = this.boundingParent;
     const { visualBounds } = this.dom;
     const { layoutBounds } = this.dom;
@@ -757,10 +758,10 @@ export class ScaleManager {
       // Max/min not honored fullscreen
       return;
     }
-    if (this.maxWidth) {
+    if (this.maxWidth !== null) {
       this.width = Math.min(this.width, this.maxWidth);
     }
-    if (this.maxHeight) {
+    if (this.maxHeight !== null) {
       this.height = Math.min(this.height, this.maxHeight);
     }
   }
@@ -796,7 +797,7 @@ export class ScaleManager {
     }
     if (this.compatibility.clickTrampoline === 'when-not-mouse') {
       const { input } = this.game;
-      if (input.activePointer && input.activePointer !== input.mousePointer && allowTrampoline) {
+      if (input.activePointer !== null && input.activePointer !== input.mousePointer && allowTrampoline) {
         input.activePointer.addClickTrampoline('startFullScreen', this.startFullScreen, this, [antialias, false]);
         return false;
       }
@@ -953,7 +954,7 @@ export class ScaleManager {
     if (this.parentIsWindow || (this.isFullScreen && this.hasPhaserSetFullScreen && !this._createdFullScreenTarget)) {
       return null;
     }
-    const parentNode = this.game.canvas ? (this.game.canvas.parentNode as HTMLElement | null) : null;
+    const parentNode = (this.game.canvas.parentNode as HTMLElement | null) ?? null;
     return parentNode ?? null;
   }
 
@@ -968,7 +969,7 @@ export class ScaleManager {
   /**
    * TBD.
    */
-  public set scaleMode(value) {
+  public set scaleMode(value: number) {
     if (value !== this._scaleMode) {
       if (!this.isFullScreen) {
         this.updateDimensions(this._gameSize.width, this._gameSize.height, true);
@@ -990,7 +991,7 @@ export class ScaleManager {
   /**
    * TBD.
    */
-  public set fullScreenScaleMode(value) {
+  public set fullScreenScaleMode(value: number) {
     if (value !== this._fullScreenScaleMode) {
       // If in fullscreen then need a wee bit more work
       if (this.isFullScreen) {