@vpmedia/phaser 1.112.0 → 1.114.0

package/src/phaser/core/event_manager.ts

@@ -2,24 +2,24 @@ import type { DisplayObject } from '../display/display_object.js';
 import { Signal } from './signal.js';
 
 export class EventManager {
-  parent: DisplayObject | null;
-  _onAddedToGroup: Signal | null;
-  _onRemovedFromGroup: Signal | null;
-  _onDestroy: Signal | null;
-  _onOutOfBounds: Signal | null;
-  _onEnterBounds: Signal | null;
-  _onInputOver: Signal | null;
-  _onInputOut: Signal | null;
-  _onInputDown: Signal | null;
-  _onInputUp: Signal | null;
-  _onDragStart: Signal | null;
-  _onDragUpdate: Signal | null;
-  _onDragStop: Signal | null;
-  _onAnimationStart: Signal | null;
-  _onAnimationComplete: Signal | null;
-  _onAnimationLoop: Signal | null;
-
-  constructor(sprite: DisplayObject) {
+  public parent: DisplayObject | null;
+  public _onAddedToGroup: Signal | null;
+  public _onRemovedFromGroup: Signal | null;
+  public _onDestroy: Signal | null;
+  public _onOutOfBounds: Signal | null;
+  public _onEnterBounds: Signal | null;
+  public _onInputOver: Signal | null;
+  public _onInputOut: Signal | null;
+  public _onInputDown: Signal | null;
+  public _onInputUp: Signal | null;
+  public _onDragStart: Signal | null;
+  public _onDragUpdate: Signal | null;
+  public _onDragStop: Signal | null;
+  public _onAnimationStart: Signal | null;
+  public _onAnimationComplete: Signal | null;
+  public _onAnimationLoop: Signal | null;
+
+  public constructor(sprite: DisplayObject) {
     this.parent = sprite;
     this._onAddedToGroup = null;
     this._onRemovedFromGroup = null;
@@ -38,7 +38,7 @@ export class EventManager {
     this._onAnimationLoop = null;
   }
 
-  destroy(): void {
+  public destroy(): void {
     this.parent = null;
     if (this._onDestroy) {
       this._onDestroy.dispose();
@@ -87,181 +87,151 @@ export class EventManager {
     }
   }
 
-  get onAddedToGroup(): Signal {
-    if (!this._onAddedToGroup) {
-      this._onAddedToGroup = new Signal();
-    }
+  public get onAddedToGroup(): Signal {
+    this._onAddedToGroup ??= new Signal();
     return this._onAddedToGroup;
   }
-  onAddedToGroup$dispatch(...args: unknown[]): void {
+  public onAddedToGroup$dispatch(...args: unknown[]): void {
     if (this._onAddedToGroup) {
       this._onAddedToGroup.dispatch(...args);
     }
   }
 
-  get onRemovedFromGroup(): Signal {
-    if (!this._onRemovedFromGroup) {
-      this._onRemovedFromGroup = new Signal();
-    }
+  public get onRemovedFromGroup(): Signal {
+    this._onRemovedFromGroup ??= new Signal();
     return this._onRemovedFromGroup;
   }
-  onRemovedFromGroup$dispatch(...args: unknown[]): void {
+  public onRemovedFromGroup$dispatch(...args: unknown[]): void {
     if (this._onRemovedFromGroup) {
       this._onRemovedFromGroup.dispatch(...args);
     }
   }
 
-  get onDestroy(): Signal {
-    if (!this._onDestroy) {
-      this._onDestroy = new Signal();
-    }
+  public get onDestroy(): Signal {
+    this._onDestroy ??= new Signal();
     return this._onDestroy;
   }
-  onDestroy$dispatch(...args: unknown[]): void {
+  public onDestroy$dispatch(...args: unknown[]): void {
     if (this._onDestroy) {
       this._onDestroy.dispatch(...args);
     }
   }
 
-  get onOutOfBounds(): Signal {
-    if (!this._onOutOfBounds) {
-      this._onOutOfBounds = new Signal();
-    }
+  public get onOutOfBounds(): Signal {
+    this._onOutOfBounds ??= new Signal();
     return this._onOutOfBounds;
   }
-  onOutOfBounds$dispatch(...args: unknown[]): void {
+  public onOutOfBounds$dispatch(...args: unknown[]): void {
     if (this._onOutOfBounds) {
       this._onOutOfBounds.dispatch(...args);
     }
   }
 
-  get onEnterBounds(): Signal {
-    if (!this._onEnterBounds) {
-      this._onEnterBounds = new Signal();
-    }
+  public get onEnterBounds(): Signal {
+    this._onEnterBounds ??= new Signal();
     return this._onEnterBounds;
   }
-  onEnterBounds$dispatch(...args: unknown[]): void {
+  public onEnterBounds$dispatch(...args: unknown[]): void {
     if (this._onEnterBounds) {
       this._onEnterBounds.dispatch(...args);
     }
   }
 
-  get onInputOver(): Signal {
-    if (!this._onInputOver) {
-      this._onInputOver = new Signal();
-    }
+  public get onInputOver(): Signal {
+    this._onInputOver ??= new Signal();
     return this._onInputOver;
   }
-  onInputOver$dispatch(...args: unknown[]): void {
+  public onInputOver$dispatch(...args: unknown[]): void {
     if (this._onInputOver) {
       this._onInputOver.dispatch(...args);
     }
   }
 
-  get onInputOut(): Signal {
-    if (!this._onInputOut) {
-      this._onInputOut = new Signal();
-    }
+  public get onInputOut(): Signal {
+    this._onInputOut ??= new Signal();
     return this._onInputOut;
   }
-  onInputOut$dispatch(...args: unknown[]): void {
+  public onInputOut$dispatch(...args: unknown[]): void {
     if (this._onInputOut) {
       this._onInputOut.dispatch(...args);
     }
   }
 
-  get onInputDown(): Signal {
-    if (!this._onInputDown) {
-      this._onInputDown = new Signal();
-    }
+  public get onInputDown(): Signal {
+    this._onInputDown ??= new Signal();
     return this._onInputDown;
   }
-  onInputDown$dispatch(...args: unknown[]): void {
+  public onInputDown$dispatch(...args: unknown[]): void {
     if (this._onInputDown) {
       this._onInputDown.dispatch(...args);
     }
   }
 
-  get onInputUp(): Signal {
-    if (!this._onInputUp) {
-      this._onInputUp = new Signal();
-    }
+  public get onInputUp(): Signal {
+    this._onInputUp ??= new Signal();
     return this._onInputUp;
   }
-  onInputUp$dispatch(...args: unknown[]): void {
+  public onInputUp$dispatch(...args: unknown[]): void {
     if (this._onInputUp) {
       this._onInputUp.dispatch(...args);
     }
   }
 
-  get onDragStart(): Signal {
-    if (!this._onDragStart) {
-      this._onDragStart = new Signal();
-    }
+  public get onDragStart(): Signal {
+    this._onDragStart ??= new Signal();
     return this._onDragStart;
   }
-  onDragStart$dispatch(...args: unknown[]): void {
+  public onDragStart$dispatch(...args: unknown[]): void {
     if (this._onDragStart) {
       this._onDragStart.dispatch(...args);
     }
   }
 
-  get onDragUpdate(): Signal {
-    if (!this._onDragUpdate) {
-      this._onDragUpdate = new Signal();
-    }
+  public get onDragUpdate(): Signal {
+    this._onDragUpdate ??= new Signal();
     return this._onDragUpdate;
   }
-  onDragUpdate$dispatch(...args: unknown[]): void {
+  public onDragUpdate$dispatch(...args: unknown[]): void {
     if (this._onDragUpdate) {
       this._onDragUpdate.dispatch(...args);
     }
   }
 
-  get onDragStop(): Signal {
-    if (!this._onDragStop) {
-      this._onDragStop = new Signal();
-    }
+  public get onDragStop(): Signal {
+    this._onDragStop ??= new Signal();
     return this._onDragStop;
   }
-  onDragStop$dispatch(...args: unknown[]): void {
+  public onDragStop$dispatch(...args: unknown[]): void {
     if (this._onDragStop) {
       this._onDragStop.dispatch(...args);
     }
   }
 
-  get onAnimationStart(): Signal {
-    if (!this._onAnimationStart) {
-      this._onAnimationStart = new Signal();
-    }
+  public get onAnimationStart(): Signal {
+    this._onAnimationStart ??= new Signal();
     return this._onAnimationStart;
   }
-  onAnimationStart$dispatch(...args: unknown[]): void {
+  public onAnimationStart$dispatch(...args: unknown[]): void {
     if (this._onAnimationStart) {
       this._onAnimationStart.dispatch(...args);
     }
   }
 
-  get onAnimationComplete(): Signal {
-    if (!this._onAnimationComplete) {
-      this._onAnimationComplete = new Signal();
-    }
+  public get onAnimationComplete(): Signal {
+    this._onAnimationComplete ??= new Signal();
     return this._onAnimationComplete;
   }
-  onAnimationComplete$dispatch(...args: unknown[]): void {
+  public onAnimationComplete$dispatch(...args: unknown[]): void {
     if (this._onAnimationComplete) {
       this._onAnimationComplete.dispatch(...args);
     }
   }
 
-  get onAnimationLoop(): Signal {
-    if (!this._onAnimationLoop) {
-      this._onAnimationLoop = new Signal();
-    }
+  public get onAnimationLoop(): Signal {
+    this._onAnimationLoop ??= new Signal();
     return this._onAnimationLoop;
   }
-  onAnimationLoop$dispatch(...args: unknown[]): void {
+  public onAnimationLoop$dispatch(...args: unknown[]): void {
     if (this._onAnimationLoop) {
       this._onAnimationLoop.dispatch(...args);
     }

package/src/phaser/core/factory.ts

@@ -7,12 +7,12 @@ import { Text } from '../display/text.js';
 import type { Game } from './game.js';
 
 export class GameObjectFactory {
-  game!: Game;
+  public game!: Game;
   /**
    * Creates a new GameObjectFactory instance.
-   * @param {import('./game.js').Game} game - The game instance this factory belongs to.
+   * @param {Game} game - The game instance this factory belongs to.
    */
-  constructor(game: Game) {
+  public constructor(game: Game) {
     this.game = game;
   }
 
@@ -25,7 +25,7 @@ export class GameObjectFactory {
    * @param {Group} group - The parent group for the image.
    * @returns {Image} The created Image object.
    */
-  image(x: number, y: number, key: string, frame: any, group: Group | null = null) {
+  public image(x: number, y: number, key: string, frame: any, group: Group | null = null) {
     const target = group ?? this.game.world;
     return target.add(new Image(this.game, x, y, key, frame));
   }
@@ -37,7 +37,7 @@ export class GameObjectFactory {
    * @param {boolean} addToStage - Whether to add the group to the stage.
    * @returns {Group} The created Group object.
    */
-  group(parent: Group | null = null, name: string | null = null, addToStage: boolean = false) {
+  public group(parent: Group | null = null, name: string | null = null, addToStage = false) {
     return new Group(this.game, parent, name, addToStage);
   }
 
@@ -50,8 +50,8 @@ export class GameObjectFactory {
    * @param {Group | null} group - The parent group for the text.
    * @returns {Text} The created Text object.
    */
-  text(x: number, y: number, text: any, style: any, group: Group | null = null) {
-    const parent = group || this.game.world;
+  public text(x: number, y: number, text: any, style: any, group: Group | null = null) {
+    const parent = group ?? this.game.world;
     return parent.add(new Text(this.game, x, y, text, style));
   }
 
@@ -69,7 +69,7 @@ export class GameObjectFactory {
    * @param {Group | null} group - The parent group for the button.
    * @returns {Button} The created Button object.
    */
-  button(
+  public button(
     x: number,
     y: number,
     key: string,
@@ -81,7 +81,7 @@ export class GameObjectFactory {
     upFrame: string | null = null,
     group: Group | null = null
   ) {
-    const parent = group || this.game.world;
+    const parent = group ?? this.game.world;
     return parent.add(
       new Button(this.game, x, y, key, callback, callbackContext, overFrame, outFrame, downFrame, upFrame)
     );
@@ -94,8 +94,8 @@ export class GameObjectFactory {
    * @param {Group | null} group - The parent group for the graphics object.
    * @returns {Graphics} The created Graphics object.
    */
-  graphics(x: number = 0, y: number = 0, group: Group | null = null) {
-    const parent = group || this.game.world;
+  public graphics(x = 0, y = 0, group: Group | null = null) {
+    const parent = group ?? this.game.world;
     return parent.add(new Graphics(this.game, x, y));
   }
 
@@ -110,16 +110,16 @@ export class GameObjectFactory {
    * @param {string} align - The alignment of the text.
    * @returns {BitmapText} The created BitmapText object.
    */
-  bitmapText(
+  public bitmapText(
     x: number,
     y: number,
     font: string,
     text: string,
     size: number,
     group: Group | null = null,
-    align: string = 'left'
+    align = 'left'
   ) {
-    const parent = group || this.game.world;
+    const parent = group ?? this.game.world;
     return parent.add(new BitmapText(this.game, x, y, font, text, size, align));
   }
 }

package/src/phaser/core/frame.ts

@@ -3,38 +3,38 @@ import { distance } from '../util/math.js';
 import { cloneFrame } from './frame_util.js';
 
 export class Frame {
-  index!: number;
-  x!: number;
-  y!: number;
-  width!: number;
-  height!: number;
-  name!: string;
-  centerX!: number;
-  centerY!: number;
-  distance!: number;
-  rotated!: boolean;
-  rotationDirection!: 'cw' | 'ccw';
-  trimmed!: boolean;
-  sourceSizeW!: number;
-  sourceSizeH!: number;
-  spriteSourceSizeX!: number;
-  spriteSourceSizeY!: number;
-  spriteSourceSizeW!: number;
-  spriteSourceSizeH!: number;
-  right!: number;
-  bottom!: number;
+  public index!: number;
+  public x!: number;
+  public y!: number;
+  public width!: number;
+  public height!: number;
+  public name!: string;
+  public centerX!: number;
+  public centerY!: number;
+  public distance!: number;
+  public rotated!: boolean;
+  public rotationDirection!: 'cw' | 'ccw';
+  public trimmed!: boolean;
+  public sourceSizeW!: number;
+  public sourceSizeH!: number;
+  public spriteSourceSizeX!: number;
+  public spriteSourceSizeY!: number;
+  public spriteSourceSizeW!: number;
+  public spriteSourceSizeH!: number;
+  public right!: number;
+  public bottom!: number;
 
-  constructor(index: number, x: number, y: number, width: number, height: number, name?: string) {
+  public constructor(index: number, x: number, y: number, width: number, height: number, name?: string) {
     this.initialize(index, x, y, width, height, name);
   }
 
-  initialize(index: number, x: number, y: number, width: number, height: number, name?: string): void {
+  public initialize(index: number, x: number, y: number, width: number, height: number, name?: string): void {
     this.index = index;
     this.x = x;
     this.y = y;
     this.width = width;
     this.height = height;
-    this.name = name as string;
+    this.name = name!;
     this.centerX = Math.floor(width / 2);
     this.centerY = Math.floor(height / 2);
     this.distance = distance(0, 0, width, height);
@@ -51,7 +51,7 @@ export class Frame {
     this.bottom = this.y + this.height;
   }
 
-  resize(width: number, height: number): void {
+  public resize(width: number, height: number): void {
     this.width = width;
     this.height = height;
     this.centerX = Math.floor(width / 2);
@@ -63,7 +63,7 @@ export class Frame {
     this.bottom = this.y + height;
   }
 
-  setTrim(
+  public setTrim(
     trimmed: boolean,
     actualWidth: number,
     actualHeight: number,
@@ -85,12 +85,12 @@ export class Frame {
     }
   }
 
-  clone(): Frame {
+  public clone(): Frame {
     return cloneFrame(this);
   }
 
-  getRect(output: Rectangle | null = null): Rectangle {
-    const result = output || new Rectangle();
+  public getRect(output: Rectangle | null = null): Rectangle {
+    const result = output ?? new Rectangle();
     result.setTo(this.x, this.y, this.width, this.height);
     return result;
   }

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

@@ -0,0 +1,100 @@
+import { describe, expect, it } from 'vitest';
+import { Frame } from './frame.js';
+import { FrameData } from './frame_data.js';
+
+const seed = (names: string[]): FrameData => {
+  const data = new FrameData();
+  for (const [i, name] of names.entries()) {
+    data.addFrame(new Frame(i, i * 10, 0, 10, 10, name));
+  }
+  return data;
+};
+
+describe('FrameData', () => {
+  describe('addFrame', () => {
+    it('assigns a sequential index and registers the name', () => {
+      const data = seed(['a', 'b']);
+      expect(data._frames.map((frame) => frame.index)).toStrictEqual([0, 1]);
+      expect(data._frameNames).toStrictEqual({ a: 0, b: 1 });
+    });
+
+    it('does not register an empty name', () => {
+      const data = new FrameData();
+      data.addFrame(new Frame(0, 0, 0, 10, 10, ''));
+      expect(data._frameNames).toStrictEqual({});
+    });
+  });
+
+  describe('getFrame', () => {
+    it('returns the frame at the index', () => {
+      const data = seed(['a', 'b', 'c']);
+      expect(data.getFrame(1).name).toBe('b');
+    });
+
+    it('falls back to the first frame when the index is out of range', () => {
+      const data = seed(['a', 'b']);
+      expect(data.getFrame(9).name).toBe('a');
+    });
+  });
+
+  describe('getFrameByName', () => {
+    it('finds a registered frame', () => {
+      const data = seed(['a', 'b']);
+      expect(data.getFrameByName('b')?.index).toBe(1);
+    });
+
+    it('returns null for an unknown name', () => {
+      const data = seed(['a']);
+      expect(data.getFrameByName('missing')).toBeNull();
+    });
+
+    it('returns null when the name maps to a frame that is gone', () => {
+      const data = seed(['a']);
+      data._frames.length = 0;
+      expect(data.getFrameByName('a')).toBeNull();
+    });
+  });
+
+  describe('checkFrameName', () => {
+    it('distinguishes known from unknown names', () => {
+      const data = seed(['a']);
+      expect(data.checkFrameName('a')).toBe(true);
+      expect(data.checkFrameName('b')).toBe(false);
+    });
+  });
+
+  describe('getFrameRange', () => {
+    it('collects the inclusive range', () => {
+      const data = seed(['a', 'b', 'c', 'd']);
+      expect(data.getFrameRange(1, 2).map((frame) => frame.name)).toStrictEqual(['b', 'c']);
+    });
+
+    it('appends into a supplied output array', () => {
+      const data = seed(['a', 'b']);
+      const output = [data.getFrame(0)];
+      expect(data.getFrameRange(1, 1, output)).toHaveLength(2);
+    });
+  });
+
+  describe('getFrameIndexes', () => {
+    it('maps numeric indexes through', () => {
+      const data = seed(['a', 'b', 'c']);
+      expect(data.getFrameIndexes([0, 2])).toStrictEqual([0, 2]);
+    });
+
+    it('maps names when numeric indexing is off', () => {
+      const data = seed(['a', 'b', 'c']);
+      expect(data.getFrameIndexes(['c', 'a'], false)).toStrictEqual([2, 0]);
+    });
+
+    it('skips names that do not resolve', () => {
+      const data = seed(['a']);
+      expect(data.getFrameIndexes(['a', 'missing'], false)).toStrictEqual([0]);
+    });
+
+    it('returns every index when given no frames', () => {
+      const data = seed(['a', 'b', 'c']);
+      expect(data.getFrameIndexes([])).toStrictEqual([0, 1, 2]);
+    });
+  });
+});

package/src/phaser/core/frame_data.ts

@@ -2,15 +2,15 @@ import type { Frame } from './frame.js';
 import { cloneFrameData } from './frame_util.js';
 
 export class FrameData {
-  _frames: Frame[];
-  _frameNames: Record<string, number>;
+  public _frames: Frame[];
+  public _frameNames: Record<string, number>;
 
-  constructor() {
+  public constructor() {
     this._frames = [];
     this._frameNames = {};
   }
 
-  addFrame(frame: Frame): Frame {
+  public addFrame(frame: Frame): Frame {
     frame.index = this._frames.length;
     this._frames.push(frame);
     if (frame.name !== '') {
@@ -19,50 +19,50 @@ export class FrameData {
     return frame;
   }
 
-  getFrame(index: number = 0): Frame {
+  public getFrame(index = 0): Frame {
     if (index >= this._frames.length) {
       index = 0;
     }
-    return this._frames[index];
+    return this._frames[index]!;
   }
 
-  getFrameByName(name: string): Frame | null {
-    if (typeof this._frameNames[name] === 'number') {
-      return this._frames[this._frameNames[name]];
+  public getFrameByName(name: string): Frame | null {
+    const index = this._frameNames[name];
+    if (typeof index === 'number') {
+      return this._frames[index] ?? null;
     }
     return null;
   }
 
-  checkFrameName(name: string): boolean {
+  public checkFrameName(name: string): boolean {
     if (this._frameNames[name] == null) {
       return false;
     }
     return true;
   }
 
-  clone(): FrameData {
+  public clone(): FrameData {
     return cloneFrameData(this);
   }
 
-  getFrameRange(start: number, end: number, output: Frame[] | null = null): Frame[] {
-    const result = output || [];
+  public getFrameRange(start: number, end: number, output: Frame[] | null = null): Frame[] {
+    const result = output ?? [];
     for (let i = start; i <= end; i += 1) {
-      result.push(this._frames[i]);
+      result.push(this._frames[i]!);
     }
     return result;
   }
 
-  getFrameIndexes(
+  public getFrameIndexes(
     frames: (number | string)[],
-    useNumericIndex: boolean = true,
+    useNumericIndex = true,
     output: number[] | null = null
   ): number[] {
-    const result = output || [];
+    const result = output ?? [];
     if (frames && frames.length > 0) {
-      for (let i = 0; i < frames.length; i += 1) {
-        const f = frames[i];
+      for (const f of frames) {
         if (useNumericIndex && this._frames[f as number]) {
-          result.push(this._frames[f as number].index);
+          result.push(this._frames[f as number]!.index);
         } else {
           const found = this.getFrameByName(f as string);
           if (found) {
@@ -71,19 +71,19 @@ export class FrameData {
         }
       }
     } else {
-      for (let i = 0; i < this._frames.length; i += 1) {
-        result.push(this._frames[i].index);
+      for (const frame of this._frames) {
+        result.push(frame.index);
       }
     }
     return result;
   }
 
-  destroy(): void {
+  public destroy(): void {
     this._frames = null as unknown as Frame[];
     this._frameNames = null as unknown as Record<string, number>;
   }
 
-  get total(): number {
+  public get total(): number {
     return this._frames.length;
   }
 }