@vpmedia/phaser 1.108.0 → 1.110.0

package/src/phaser/core/scale_manager.ts

@@ -1,65 +1,66 @@
 import { Point } from '../geom/point.js';
 import { Rectangle } from '../geom/rectangle.js';
 import { RENDER_CANVAS, SCALE_EXACT_FIT, SCALE_OFF, SCALE_RESIZE, SCALE_SHOW_ALL, SCALE_USER } from './const.js';
+import type { Game } from './game.js';
 import { DOM } from './dom.js';
 import { Signal } from './signal.js';
 
 export class ScaleManager {
-  game!: any;
-  dom!: any;
-  width!: any;
-  height!: any;
-  minWidth!: any;
-  maxWidth!: any;
-  minHeight!: any;
-  maxHeight!: any;
-  offset!: any;
-  forceLandscape!: any;
-  forcePortrait!: any;
-  incorrectOrientation!: any;
-  _pageAlignHorizontally!: any;
-  _pageAlignVertically!: any;
-  onOrientationChange!: any;
-  enterIncorrectOrientation!: any;
-  leaveIncorrectOrientation!: any;
-  hasPhaserSetFullScreen!: any;
+  game!: Game;
+  dom!: DOM;
+  width!: number;
+  height!: number;
+  minWidth!: number | null;
+  maxWidth!: number | null;
+  minHeight!: number | null;
+  maxHeight!: number | null;
+  offset!: Point;
+  forceLandscape!: boolean;
+  forcePortrait!: boolean;
+  incorrectOrientation!: boolean;
+  _pageAlignHorizontally!: boolean;
+  _pageAlignVertically!: boolean;
+  onOrientationChange!: Signal;
+  enterIncorrectOrientation!: Signal;
+  leaveIncorrectOrientation!: Signal;
+  hasPhaserSetFullScreen!: boolean;
   fullScreenTarget!: any;
   _createdFullScreenTarget!: any;
-  onFullScreenInit!: any;
-  onFullScreenChange!: any;
-  onFullScreenError!: any;
+  onFullScreenInit!: Signal;
+  onFullScreenChange!: Signal;
+  onFullScreenError!: Signal;
   screenOrientation!: any;
-  scaleFactor!: any;
-  scaleFactorInversed!: any;
+  scaleFactor!: Point;
+  scaleFactorInversed!: Point;
   margin!: any;
-  bounds!: any;
-  aspectRatio!: any;
-  sourceAspectRatio!: any;
-  event!: any;
+  bounds!: Rectangle;
+  aspectRatio!: number;
+  sourceAspectRatio!: number;
+  event!: Event | null | undefined;
   windowConstraints!: any;
   compatibility!: any;
-  _scaleMode!: any;
-  _fullScreenScaleMode!: any;
-  parentIsWindow!: any;
+  _scaleMode!: number;
+  _fullScreenScaleMode!: number;
+  parentIsWindow!: boolean;
   parentNode!: any;
-  parentScaleFactor!: any;
-  trackParentInterval!: any;
-  onSizeChange!: any;
+  parentScaleFactor!: Point;
+  trackParentInterval!: number;
+  onSizeChange!: Signal;
   onResize!: any;
   onResizeContext!: any;
   _pendingScaleMode!: any;
   _fullScreenRestore!: any;
-  _gameSize!: any;
-  _userScaleFactor!: any;
-  _userScaleTrim!: any;
-  _lastUpdate!: any;
-  _updateThrottle!: any;
-  _updateThrottleReset!: any;
-  _parentBounds!: any;
-  _tempBounds!: any;
-  _lastReportedCanvasSize!: any;
-  _lastReportedGameSize!: any;
-  _booted!: any;
+  _gameSize!: Rectangle;
+  _userScaleFactor!: Point;
+  _userScaleTrim!: Point;
+  _lastUpdate!: number;
+  _updateThrottle!: number;
+  _updateThrottleReset!: number;
+  _parentBounds!: Rectangle;
+  _tempBounds!: Rectangle;
+  _lastReportedCanvasSize!: Rectangle;
+  _lastReportedGameSize!: Rectangle;
+  _booted!: boolean;
   _orientationChange!: (event: Event) => void;
   _windowResize!: (event: UIEvent) => void;
   _fullScreenChange!: (event: Event) => void;
@@ -70,7 +71,7 @@ export class ScaleManager {
    * @param {number} width - TBD.
    * @param {number} height - TBD.
    */
-  constructor(game: import('./game.js').Game, width: number, height: number) {
+  constructor(game: Game, width: number, height: number) {
     this.game = game;
     this.dom = new DOM(game.device);
     this.width = 0;
@@ -108,7 +109,6 @@ export class ScaleManager {
     this.bounds = new Rectangle();
     this.aspectRatio = 0;
     this.sourceAspectRatio = 0;
-    /** @type {Event | null | undefined} */
     this.event = null;
     this.windowConstraints = {
       right: 'layout',
@@ -334,7 +334,7 @@ export class ScaleManager {
       // Per StateManager#onResizeCallback, it only occurs when in RESIZE mode.
       if (this.currentScaleMode === SCALE_RESIZE) {
         this.game.state.resize(width, height);
-        this.game.load.resize(width, height);
+        this.game.load.resize();
       }
     }
   }
@@ -806,7 +806,9 @@ export class ScaleManager {
       // (The target has to be added for the Fullscreen API to work.)
       const canvas = this.game.canvas;
       const parent = canvas.parentNode;
-      parent.insertBefore(fsTarget, canvas);
+      if (parent) {
+        parent.insertBefore(fsTarget, canvas);
+      }
       fsTarget.appendChild(canvas);
     }
     if (this.game.device.fullscreenKeyboard) {
@@ -936,7 +938,7 @@ export class ScaleManager {
     if (this.parentIsWindow || (this.isFullScreen && this.hasPhaserSetFullScreen && !this._createdFullScreenTarget)) {
       return null;
     }
-    const parentNode = this.game.canvas && this.game.canvas.parentNode;
+    const parentNode = this.game.canvas ? (this.game.canvas.parentNode as HTMLElement | null) : null;
     return parentNode || null;
   }
 

package/src/phaser/core/scene_manager.ts

@@ -1,3 +1,4 @@
+import type { Game } from './game.js';
 import { Scene } from './scene.js';
 
 export class SceneManager {
@@ -8,7 +9,7 @@ export class SceneManager {
   _clearCache!: any;
   _created!: any;
   _args!: any;
-  current!: any;
+  current!: string;
   onInitCallback!: any;
   onPreloadCallback!: any;
   onCreateCallback!: any;
@@ -22,7 +23,7 @@ export class SceneManager {
    * @param {import('./game.js').Game} game - The game instance this manager belongs to.
    * @param {string} pendingState - The state to load when the game boots.
    */
-  constructor(game: import('./game.js').Game, pendingState: string) {
+  constructor(game: Game, pendingState: string) {
     this.game = game;
     this.states = {};
     this._pendingState = null;
@@ -250,9 +251,10 @@ export class SceneManager {
 
   /**
    * Get the current scene state.
-   * @returns {Scene} The current scene state.
+   * @template T
+   * @returns {T} The current scene state.
    */
-  getCurrentState() {
+  getCurrentState<T = Partial<Scene>>(): T {
     return this.states[this.current];
   }
 

package/src/phaser/core/signal.ts

@@ -1,12 +1,12 @@
 import { SignalBinding } from './signal_binding.js';
 
 export class Signal {
-  _bindings: any;
-  _prevParams: any;
+  _bindings: SignalBinding[] | null;
+  _prevParams: unknown[] | null;
   memorize: boolean;
   _shouldPropagate: boolean;
   active: boolean;
-  _boundDispatch: any;
+  _boundDispatch: ((...args: unknown[]) => void) | null;
 
   /**
    * Creates a new Signal instance.
@@ -54,7 +54,7 @@ export class Signal {
   ) {
     const prevIndex = this._indexOfListener(listener, listenerContext);
     let binding;
-    if (prevIndex !== -1) {
+    if (prevIndex !== -1 && this._bindings) {
       binding = this._bindings[prevIndex];
       if (binding.isOnce() !== isOnce) {
         throw new Error(
@@ -156,7 +156,7 @@ export class Signal {
   remove(listener: Function, context: any | null = null) {
     this.validateListener(listener, 'remove');
     const i = this._indexOfListener(listener, context);
-    if (i !== -1) {
+    if (i !== -1 && this._bindings) {
       // no reason to a SignalBinding exist if it isn't attached to a signal
       this._bindings[i]._destroy();
       this._bindings.splice(i, 1);
@@ -268,7 +268,9 @@ export class Signal {
   get boundDispatch() {
     const _this = this;
     if (!this._boundDispatch) {
-      this._boundDispatch = (...rest: unknown[]) => _this.dispatch(...rest);
+      this._boundDispatch = (...rest: unknown[]) => {
+        _this.dispatch(...rest);
+      };
     }
     return this._boundDispatch;
   }

package/src/phaser/core/time.ts

@@ -1,89 +1,65 @@
+import type { Game } from './game.js';
 import { Timer } from './timer.js';
 
 export class Time {
-  game!: any;
-  time!: any;
-  prevTime!: any;
-  now!: any;
-  elapsed!: any;
-  elapsedMS!: any;
-  desiredFpsMult!: any;
-  _desiredFps!: any;
-  suggestedFps!: any;
-  advancedTiming!: any;
-  frames!: any;
-  fps!: any;
-  fpsMin!: any;
-  fpsMax!: any;
-  msMin!: any;
-  msMax!: any;
-  pauseDuration!: any;
-  timeToCall!: any;
-  timeExpected!: any;
-  events!: any;
-  _frameCount!: any;
-  _elapsedAccumulator!: any;
-  _started!: any;
-  _timeLastSecond!: any;
-  _pauseStarted!: any;
-  _justResumed!: any;
-  _timers!: any;
+  game!: Game;
+  time!: number;
+  prevTime!: number;
+  now!: number;
+  elapsed!: number;
+  elapsedMS!: number;
+  desiredFpsMult!: number;
+  _desiredFps!: number;
+  suggestedFps!: number;
+  advancedTiming!: boolean;
+  frames!: number;
+  fps!: number;
+  fpsMin!: number;
+  fpsMax!: number;
+  msMin!: number;
+  msMax!: number;
+  pauseDuration!: number;
+  timeToCall!: number;
+  timeExpected!: number;
+  events!: Timer;
+  _frameCount!: number;
+  _elapsedAccumulator!: number;
+  _started!: number;
+  _timeLastSecond!: number;
+  _pauseStarted!: number;
+  _justResumed!: boolean;
+  _timers!: Timer[];
   /**
    * Creates a new Time instance.
    * @param {import('./game.js').Game} game - Reference to the Phaser Game instance.
    */
-  constructor(game: import('./game.js').Game) {
+  constructor(game: Game) {
     this.game = game;
-    /** @type {number} */
     this.time = 0;
-    /** @type {number} */
     this.prevTime = 0;
-    /** @type {number} */
     this.now = 0;
-    /** @type {number} */
     this.elapsed = 0;
-    /** @type {number} */
     this.elapsedMS = 0;
-    /** @type {number} */
     this.desiredFpsMult = 1 / 60;
-    /** @type {number} */
     this._desiredFps = 60;
-    /** @type {number} */
     this.suggestedFps = this.desiredFps;
-    /** @type {boolean} */
     this.advancedTiming = false;
-    /** @type {number} */
     this.frames = 0;
-    /** @type {number} */
     this.fps = 0;
-    /** @type {number} */
     this.fpsMin = 1000;
-    /** @type {number} */
     this.fpsMax = 0;
-    /** @type {number} */
     this.msMin = 1000;
-    /** @type {number} */
     this.msMax = 0;
-    /** @type {number} */
     this.pauseDuration = 0;
-    /** @type {number} */
     this.timeToCall = 0;
-    /** @type {number} */
     this.timeExpected = 0;
-    /** @type {Timer} */
     this.events = new Timer(this.game, false);
-    /** @type {number} */
     this._frameCount = 0;
-    /** @type {number} */
     this._elapsedAccumulator = 0;
     this._started = 0;
-    /** @type {number} */
     this._timeLastSecond = 0;
-    /** @type {number} */
     this._pauseStarted = 0;
-    /** @type {boolean} */
     this._justResumed = false;
-    /** @type {Timer[]} */
     this._timers = [];
   }
 

package/src/phaser/core/timer.ts

@@ -1,71 +1,53 @@
+import type { Game } from './game.js';
 import { Signal } from './signal.js';
 import { TimerEvent } from './timer_event.js';
 
 export class Timer {
-  game!: any;
-  running!: any;
-  autoDestroy!: any;
-  expired!: any;
-  elapsed!: any;
-  events!: any;
-  onComplete!: any;
-  nextTick!: any;
-  timeCap!: any;
-  paused!: any;
-  _codePaused!: any;
-  _started!: any;
-  _pauseStarted!: any;
-  _pauseTotal!: any;
-  _now!: any;
-  _len!: any;
-  _marked!: any;
-  _i!: any;
-  _diff!: any;
-  _newTick!: any;
+  game!: Game;
+  running!: boolean;
+  autoDestroy!: boolean;
+  expired!: boolean;
+  elapsed!: number;
+  events!: TimerEvent[];
+  onComplete!: Signal;
+  nextTick!: number;
+  timeCap!: number;
+  paused!: boolean;
+  _codePaused!: boolean;
+  _started!: number;
+  _pauseStarted!: number;
+  _pauseTotal!: number;
+  _now!: number;
+  _len!: number;
+  _marked!: number;
+  _i!: number;
+  _diff!: number;
+  _newTick!: number;
   /**
    * Creates a new Timer instance.
    * @param {import('./game.js').Game} game - The game instance.
    * @param {boolean} autoDestroy - Whether to automatically destroy the timer when it completes.
    */
-  constructor(game: import('./game.js').Game, autoDestroy: boolean = false) {
+  constructor(game: Game, autoDestroy: boolean = false) {
     this.game = game;
-    /** @type {boolean} */
     this.running = false;
-    /** @type {boolean} */
     this.autoDestroy = autoDestroy;
-    /** @type {boolean} */
     this.expired = false;
-    /** @type {number} */
     this.elapsed = 0;
-    /** @type {TimerEvent[]} */
     this.events = [];
-    /** @type {Signal} */
     this.onComplete = new Signal();
-    /** @type {number} */
     this.nextTick = 0;
-    /** @type {number} */
     this.timeCap = 1000;
-    /** @type {boolean} */
     this.paused = false;
-    /** @type {boolean} */
     this._codePaused = false;
-    /** @type {number} */
     this._started = 0;
-    /** @type {number} */
     this._pauseStarted = 0;
-    /** @type {number} */
     this._pauseTotal = 0;
-    /** @type {number} */
     this._now = Date.now();
-    /** @type {number} */
     this._len = 0;
-    /** @type {number} */
     this._marked = 0;
-    /** @type {number} */
     this._i = 0;
-    /** @type {number} */
     this._diff = 0;
-    /** @type {number} */
     this._newTick = 0;
   }
 

package/src/phaser/core/tween_manager.ts

@@ -213,8 +213,8 @@ export class TweenManager {
    * @param {object} object - The object to check.
    * @returns {boolean} True if the object is being tweened, false otherwise.
    */
-  isTweening(object: any) {
-    return this._tweens.some((tween: Tween) => tween.target === object);
+  isTweening(object: unknown): boolean {
+    return (this._tweens as Tween[]).some((tween: Tween) => tween.target === object);
   }
 
   /**

package/src/phaser/display/bitmap_text.ts

@@ -4,21 +4,21 @@ import { DisplayObject } from './display_object.js';
 import { Image } from './image.js';
 
 export class BitmapText extends DisplayObject {
-  declare type: any;
-  pendingDestroy!: any;
-  declare renderOrderID: any;
-  textWidth!: any;
-  textHeight!: any;
-  _prevAnchor!: any;
-  _glyphs!: any;
-  _maxWidth!: any;
-  _text!: any;
+  declare type: number;
+  pendingDestroy!: boolean;
+  declare renderOrderID: number;
+  textWidth!: number;
+  textHeight!: number;
+  _prevAnchor!: Point;
+  _glyphs!: Image[];
+  _maxWidth!: number;
+  _text!: string;
   _data!: any;
-  _font!: any;
-  _fontSize!: any;
-  _align!: any;
-  _tint!: any;
-  dirty!: any;
+  _font!: string;
+  _fontSize!: number;
+  _align!: string;
+  _tint!: number;
+  dirty!: boolean;
   /**
    * Creates a new BitmapText instance.
    * @param {import('../core/game.js').Game} game - The game instance this bitmap text belongs to.
@@ -39,31 +39,20 @@ export class BitmapText extends DisplayObject {
     align: string = 'left'
   ) {
     super(game);
-    /** @type {number} */
     this.type = BITMAP_TEXT;
     this.position.setTo(x, y);
-    /** @type {number} */
     this.textWidth = 0;
-    /** @type {number} */
     this.textHeight = 0;
-    /** @type {Point} */
     this._prevAnchor = new Point();
     this._glyphs = [];
-    /** @type {number} */
     this._maxWidth = 0;
-    /** @type {string} */
     this._text = text.toString() || '';
     this._data = game.cache.getBitmapFont(font);
-    /** @type {string} */
     this._font = font;
-    /** @type {number} */
     this._fontSize = size;
-    /** @type {string} */
     this._align = align;
-    /** @type {number} */
     this._tint = 0xffffff;
     this.updateText();
-    /** @type {boolean} */
     this.dirty = false;
   }
 
@@ -71,9 +60,9 @@ export class BitmapText extends DisplayObject {
    * Destroys this bitmap text and cleans up resources.
    */
   override destroy() {
-    this._prevAnchor = null;
-    this._glyphs = null;
-    this._text = null;
+    this._prevAnchor = null!;
+    this._glyphs = null!;
+    this._text = null!;
     this._data = null;
     super.destroy();
   }
@@ -289,7 +278,6 @@ export class BitmapText extends DisplayObject {
         kept.push(this._glyphs[i]);
       }
     }
-    /** @type {Image[]} */
     this._glyphs = [];
     this._glyphs = kept;
     this.updateText();
@@ -430,7 +418,7 @@ export class BitmapText extends DisplayObject {
    * Gets the text content of this bitmap text.
    * @returns {string} The current text content.
    */
-  get text() {
+  get text(): string {
     return this._text;
   }
 

package/src/phaser/display/display_object.ts

@@ -36,23 +36,23 @@ export class DisplayObject {
   _mask: import('./graphics.js').Graphics | null = null;
   _filters: object[] | null = null;
   _filterBlock: object | null = null;
-  children!: any[];
+  children!: DisplayObject[];
   /** @type {boolean} */
   ignoreChildInput = false;
   name: string | null = null;
-  data: Record<string, any> | null = null;
+  data: any = null;
   game!: import('../core/game.js').Game;
   type!: number;
   _cachedSprite!: any;
-  rotationCache!: any;
-  worldRotation!: any;
+  rotationCache!: number;
+  worldRotation!: number;
   transformCallback!: any;
   transformCallbackContext!: any;
-  _width!: any;
-  _height!: any;
-  z!: any;
+  _width!: number;
+  _height!: number;
+  z!: number;
   events!: any;
-  renderOrderID!: any;
+  renderOrderID!: number;
   /**
    * Creates a new DisplayObject instance.
    * @param {import('../core/game.js').Game} game - The game instance this display object belongs to.
@@ -263,7 +263,7 @@ export class DisplayObject {
   removeChildAt(index: number) {
     const child = this.getChildAt(index);
     if (child) {
-      child.parent = undefined;
+      child.parent = null;
       this.children.splice(index, 1);
     }
     return child;
@@ -288,7 +288,7 @@ export class DisplayObject {
       const removed = this.children.splice(beginIndex, range);
       for (let i = 0; i < removed.length; i += 1) {
         const child = removed[i];
-        child.parent = undefined;
+        child.parent = null;
       }
       return removed;
     }
@@ -509,8 +509,9 @@ export class DisplayObject {
   /**
    * Renders this display object using WebGL.
    * @param {object} renderSession - The WebGL rendering session.
+   * @param {import('../geom/matrix.js').Matrix | null} _matrix - The transform matrix to render with.
    */
-  renderWebGL(renderSession: any) {
+  renderWebGL(renderSession: any, _matrix: Matrix | null = null) {
     if (!this.visible || this.alpha <= 0) {
       return;
     }

package/src/phaser/display/group.ts

@@ -100,12 +100,13 @@ export class Group extends DisplayObject {
 
   /**
    * Adds a child to this group.
-   * @param {DisplayObject} child - The child to add.
+   * @template T
+   * @param {T} child - The child to add.
    * @param {boolean} silent - Whether to dispatch events.
    * @param {number} index - The index to add the child at.
-   * @returns {DisplayObject} The added child.
+   * @returns {T} The added child.
    */
-  add(child: any, silent: boolean = false, index: number = -1) {
+  add<T extends DisplayObject>(child: T, silent: boolean = false, index: number = -1): T {
     if (child.parent === this) {
       return child;
     }
@@ -116,8 +117,9 @@ export class Group extends DisplayObject {
       this.addChildAt(child, index);
       this.updateZ();
     }
-    if (this.inputEnableChildren && (!child.input || child.inputEnabled)) {
-      child.inputEnabled = true;
+    const inputChild = child as T & { input?: unknown; inputEnabled?: boolean };
+    if (this.inputEnableChildren && (!inputChild.input || inputChild.inputEnabled)) {
+      inputChild.inputEnabled = true;
     }
     if (!silent && child.events) {
       child.events.onAddedToGroup$dispatch(child, this);