@vpmedia/phaser 1.122.0 → 1.124.0

package/src/phaser/geom/ellipse.test.ts

@@ -1,8 +1,8 @@
 import { describe, expect, it } from 'vitest';
 import { Ellipse } from './ellipse.js';
 
-describe('Ellipse', () => {
-  it('should create an ellipse with default values', () => {
+describe('Ellipse', (): void => {
+  it('should create an ellipse with default values', (): void => {
     const ellipse = new Ellipse();
     expect(ellipse.x).toBe(0);
     expect(ellipse.y).toBe(0);
@@ -10,7 +10,7 @@ describe('Ellipse', () => {
     expect(ellipse.height).toBe(0);
   });
 
-  it('should create an ellipse with custom x, y, width, height', () => {
+  it('should create an ellipse with custom x, y, width, height', (): void => {
     const ellipse = new Ellipse(10, 20, 30, 40);
     expect(ellipse.x).toBe(10);
     expect(ellipse.y).toBe(20);
@@ -18,7 +18,7 @@ describe('Ellipse', () => {
     expect(ellipse.height).toBe(40);
   });
 
-  it('should set the ellipse values to new x, y, width, height', () => {
+  it('should set the ellipse values to new x, y, width, height', (): void => {
     const ellipse = new Ellipse();
     ellipse.setTo(10, 20, 30, 40);
     expect(ellipse.x).toBe(10);
@@ -27,13 +27,13 @@ describe('Ellipse', () => {
     expect(ellipse.height).toBe(40);
   });
 
-  it('should return the ellipse instance', () => {
+  it('should return the ellipse instance', (): void => {
     const ellipse = new Ellipse();
     const result = ellipse.setTo(10, 20, 30, 40);
     expect(result).toBe(ellipse);
   });
 
-  it('should create a rectangle with correct bounds', () => {
+  it('should create a rectangle with correct bounds', (): void => {
     const ellipse = new Ellipse(10, 20, 30, 40);
     const bounds = ellipse.getBounds();
     expect(bounds.x).toBe(10 - 30);
@@ -42,7 +42,7 @@ describe('Ellipse', () => {
     expect(bounds.height).toBe(40);
   });
 
-  it('should copy the values from another ellipse', () => {
+  it('should copy the values from another ellipse', (): void => {
     const source = new Ellipse(10, 20, 30, 40);
     const target = new Ellipse();
     target.copyFrom(source);
@@ -52,7 +52,7 @@ describe('Ellipse', () => {
     expect(target.height).toBe(source.height);
   });
 
-  it('should copy the values to another ellipse', () => {
+  it('should copy the values to another ellipse', (): void => {
     const source = new Ellipse(10, 20, 30, 40);
     const target = new Ellipse();
     source.copyTo(target);
@@ -62,24 +62,24 @@ describe('Ellipse', () => {
     expect(target.height).toBe(source.height);
   });
 
-  it('should return true if point is inside the ellipse', () => {
+  it('should return true if point is inside the ellipse', (): void => {
     const ellipse = new Ellipse(10, 20, 30, 40);
     expect(ellipse.contains(20, 30)).toBe(true);
   });
 
-  it('should return false if point is outside the ellipse', () => {
+  it('should return false if point is outside the ellipse', (): void => {
     const ellipse = new Ellipse(10, 20, 30, 40);
     expect(ellipse.contains(-5, -10)).toBe(false);
   });
 
-  it('should generate a random point within the ellipse', () => {
+  it('should generate a random point within the ellipse', (): void => {
     const ellipse = new Ellipse(10, 20, 30, 40);
     const point = ellipse.random();
     expect(point.x).toBeTypeOf('number');
     expect(point.y).toBeTypeOf('number');
   });
 
-  it('should return a string representation of the ellipse', () => {
+  it('should return a string representation of the ellipse', (): void => {
     const ellipse = new Ellipse(10, 20, 30, 40);
     expect(ellipse.toString()).toBe('[{Ellipse (x=10 y=20 width=30 height=40)}]');
   });

package/src/phaser/geom/line.test.ts

@@ -2,8 +2,8 @@ import { expect, describe, it } from 'vitest';
 import { degToRad } from '../util/math.js';
 import { Line } from './line.js';
 
-describe('Line', () => {
-  it('should create a new line instance with correct coordinates', () => {
+describe('Line', (): void => {
+  it('should create a new line instance with correct coordinates', (): void => {
     const line = new Line(0, 0, 10, 10);
     expect(line.start.x).toBe(0);
     expect(line.start.y).toBe(0);
@@ -11,7 +11,7 @@ describe('Line', () => {
     expect(line.end.y).toBe(10);
   });
 
-  it('should set the start and end points of the line correctly', () => {
+  it('should set the start and end points of the line correctly', (): void => {
     const line = new Line(0, 0, 10, 10);
     line.setTo(5, 5, 15, 15);
     expect(line.start.x).toBe(5);
@@ -20,7 +20,7 @@ describe('Line', () => {
     expect(line.end.y).toBe(15);
   });
 
-  it('should create a new line instance from two sprites correctly', () => {
+  it('should create a new line instance from two sprites correctly', (): void => {
     const line = new Line(0, 0, 10, 10);
     const sprite1 = { x: 0, y: 0 };
     const sprite2 = { x: 10, y: 10 };
@@ -31,7 +31,7 @@ describe('Line', () => {
     expect(result.end.y).toBe(10);
   });
 
-  it('should create a new line instance from an angle and length correctly', () => {
+  it('should create a new line instance from an angle and length correctly', (): void => {
     const line = new Line(0, 10, 10, 10);
     const result = line.fromAngle(0, 0, degToRad(45), 10);
     expect(result.start.x).toBe(0);
@@ -40,7 +40,7 @@ describe('Line', () => {
     expect(result.end.y).toBeCloseTo(7.07);
   });
 
-  it('should rotate the line correctly', () => {
+  it('should rotate the line correctly', (): void => {
     const line = new Line(0, 0, 10, 0);
     const result = line.rotate(90, true);
     expect(result.start.x).toBe(5);
@@ -49,7 +49,7 @@ describe('Line', () => {
     expect(result.end.y).toBe(5);
   });
 
-  it('should rotate the line around a point correctly', () => {
+  it('should rotate the line around a point correctly', (): void => {
     const line = new Line(0, 0, 10, 10);
     const result = line.rotateAround(5, 5, 90, true);
     expect(result.start.x).toBe(10);
@@ -58,54 +58,54 @@ describe('Line', () => {
     expect(result.end.y).toBe(10);
   });
 
-  it('should intersect the line with another line correctly', () => {
+  it('should intersect the line with another line correctly', (): void => {
     const line = new Line(0, 0, 10, 10);
     const line2 = new Line(5, 5, 15, 15);
     const result = line.intersects(line2, true, null);
     expect(result).toBeNull();
   });
 
-  it('should reflect the line across another line correctly', () => {
+  it('should reflect the line across another line correctly', (): void => {
     const line = new Line(0, 0, 10, 10);
     const line2 = new Line(5, 5, 15, 15);
     const result = line.reflect(line2);
     expect(result).toBeCloseTo(-5.497);
   });
 
-  it('should get the midpoint of the line correctly', () => {
+  it('should get the midpoint of the line correctly', (): void => {
     const line = new Line(0, 0, 10, 10);
     const result = line.midPoint(null);
     expect(result.x).toBe(5);
     expect(result.y).toBe(5);
   });
 
-  it('should center the line on a point correctly', () => {
+  it('should center the line on a point correctly', (): void => {
     const line = new Line(0, 0, 10, 10);
     line.centerOn(10, 10);
     expect(line.start.x).toBe(10 - (line.end.x - line.start.x) / 2);
     expect(line.start.y).toBe(10 - (line.end.y - line.start.y) / 2);
   });
 
-  it('should check if a point is on the line correctly', () => {
+  it('should check if a point is on the line correctly', (): void => {
     const line = new Line(0, 0, 10, 10);
     expect(line.pointOnLine(5, 0)).toBe(false);
     expect(line.pointOnLine(-5, 0)).toBe(false);
   });
 
-  it('should check if a point is on the segment of the line correctly', () => {
+  it('should check if a point is on the segment of the line correctly', (): void => {
     const line = new Line(0, 0, 10, 10);
     expect(line.pointOnSegment(5, -10)).toBe(false);
     expect(line.pointOnSegment(15, 15)).toBe(false);
   });
 
-  it('should get the random point on the line correctly', () => {
+  it('should get the random point on the line correctly', (): void => {
     const line = new Line(0, 0, 10, 10);
     const result = line.random(null);
     expect(result.x).toBeGreaterThan(0);
     expect(result.y).toBeGreaterThan(0);
   });
 
-  it('should get the coordinates on the line correctly', () => {
+  it('should get the coordinates on the line correctly', (): void => {
     const line = new Line(0, 0, 10, 10);
     const result = line.coordinatesOnLine(1, []);
     expect(result.length).toBeGreaterThan(0);

package/src/phaser/geom/line.ts

@@ -3,6 +3,9 @@ import { clone, intersectsPoints, reflect } from './util/line.js';
 import { wrap } from '../util/math.js';
 import { GEOM_LINE } from '../core/const.js';
 
+/** Anything a line can read a position from: a display object, a point, or a plain x/y pair. */
+export type LineAnchor = { x: number; y: number; center?: { x: number; y: number } };
+
 export class Line {
   public start: Point;
   public end: Point;
@@ -45,9 +48,9 @@ export class Line {
    * @param {boolean} useCenter - Whether to use the center of the sprites (default: false).
    * @returns {Line} This line instance for chaining.
    */
-  public fromSprite(startSprite: any, endSprite: any, useCenter = false): this {
+  public fromSprite(startSprite: LineAnchor, endSprite: LineAnchor, useCenter = false): this {
     if (useCenter) {
-      return this.setTo(startSprite.center.x, startSprite.center.y, endSprite.center.x, endSprite.center.y);
+      return this.setTo(startSprite.center!.x, startSprite.center!.y, endSprite.center!.x, endSprite.center!.y);
     }
     return this.setTo(startSprite.x, startSprite.y, endSprite.x, endSprite.y);
   }

package/src/phaser/geom/matrix.test.ts

@@ -2,8 +2,8 @@ import { expect, describe, it } from 'vitest';
 import { Matrix } from './matrix.js';
 import { Point } from './point.js';
 
-describe('Constructor', () => {
-  it('should set default values when no arguments are passed', () => {
+describe('Constructor', (): void => {
+  it('should set default values when no arguments are passed', (): void => {
     const matrix = new Matrix();
     expect(matrix.a).toBe(1);
     expect(matrix.b).toBe(0);
@@ -13,7 +13,7 @@ describe('Constructor', () => {
     expect(matrix.ty).toBe(0);
   });
 
-  it('should set values when arguments are passed', () => {
+  it('should set values when arguments are passed', (): void => {
     const matrix = new Matrix(2, 3, 4, 5, 6, 7);
     expect(matrix.a).toBe(2);
     expect(matrix.b).toBe(3);
@@ -24,8 +24,8 @@ describe('Constructor', () => {
   });
 });
 
-describe('fromArray', () => {
-  it('should set values from an array', () => {
+describe('fromArray', (): void => {
+  it('should set values from an array', (): void => {
     const matrix = new Matrix();
     const array = [2, 3, 4, 5, 6, 7];
     matrix.fromArray(array);
@@ -38,8 +38,8 @@ describe('fromArray', () => {
   });
 });
 
-describe('setTo', () => {
-  it('should set values when arguments are passed', () => {
+describe('setTo', (): void => {
+  it('should set values when arguments are passed', (): void => {
     const matrix = new Matrix();
     const a = 2;
     const b = 3;
@@ -56,7 +56,7 @@ describe('setTo', () => {
     expect(matrix.ty).toBe(ty);
   });
 
-  it('should return the matrix instance', () => {
+  it('should return the matrix instance', (): void => {
     const matrix = new Matrix();
     const a = 2;
     const b = 3;
@@ -68,8 +68,8 @@ describe('setTo', () => {
   });
 });
 
-describe('clone', () => {
-  it('should return a copy of the matrix instance', () => {
+describe('clone', (): void => {
+  it('should return a copy of the matrix instance', (): void => {
     const matrix1 = new Matrix(2, 3, 4, 5, 6, 7);
     const matrix2 = matrix1.clone();
     expect(matrix2.a).toBe(matrix1.a);
@@ -81,8 +81,8 @@ describe('clone', () => {
   });
 });
 
-describe('copyTo', () => {
-  it('should copy values to another matrix instance', () => {
+describe('copyTo', (): void => {
+  it('should copy values to another matrix instance', (): void => {
     const matrix1 = new Matrix(2, 3, 4, 5, 6, 7);
     const matrix2 = new Matrix();
     matrix1.copyTo(matrix2);
@@ -95,8 +95,8 @@ describe('copyTo', () => {
   });
 });
 
-describe('copyFrom', () => {
-  it('should copy values from another matrix instance', () => {
+describe('copyFrom', (): void => {
+  it('should copy values from another matrix instance', (): void => {
     const matrix1 = new Matrix(2, 3, 4, 5, 6, 7);
     const matrix2 = new Matrix();
     matrix2.copyFrom(matrix1);
@@ -109,8 +109,8 @@ describe('copyFrom', () => {
   });
 });
 
-describe('apply', () => {
-  it('should apply the matrix to a point', () => {
+describe('apply', (): void => {
+  it('should apply the matrix to a point', (): void => {
     const matrix = new Matrix(2, 3, 4, 5, 6, 7);
     const point = new Point(1, 2);
     const result = new Point();
@@ -125,8 +125,8 @@ describe('apply', () => {
   });
 });
 
-describe('applyInverse', () => {
-  it('should apply the inverse of the matrix to a point', () => {
+describe('applyInverse', (): void => {
+  it('should apply the inverse of the matrix to a point', (): void => {
     const matrix = new Matrix(2, 3, 4, 5, 6, 7);
     const point = new Point(1, 2);
     const result = new Point();
@@ -136,8 +136,8 @@ describe('applyInverse', () => {
   });
 });
 
-describe('translate', () => {
-  it('should add the translation values to the matrix', () => {
+describe('translate', (): void => {
+  it('should add the translation values to the matrix', (): void => {
     const matrix = new Matrix(2, 3, 4, 5, 6, 7);
     const x = 1;
     const y = 2;
@@ -147,8 +147,8 @@ describe('translate', () => {
   });
 });
 
-describe('scale', () => {
-  it('should multiply the scaling values with the matrix', () => {
+describe('scale', (): void => {
+  it('should multiply the scaling values with the matrix', (): void => {
     const matrix = new Matrix(2, 3, 4, 5, 6, 7);
     const x = 1;
     const y = 2;
@@ -162,8 +162,8 @@ describe('scale', () => {
   });
 });
 
-describe('rotate', () => {
-  it('should multiply the rotation values with the matrix', () => {
+describe('rotate', (): void => {
+  it('should multiply the rotation values with the matrix', (): void => {
     const matrix = new Matrix(2, 3, 4, 5, 6, 7);
     const angle = Math.PI / 2;
     matrix.rotate(angle);
@@ -173,8 +173,8 @@ describe('rotate', () => {
   });
 });
 
-describe('append', () => {
-  it('should add the second matrix to the first one', () => {
+describe('append', (): void => {
+  it('should add the second matrix to the first one', (): void => {
     const matrix1 = new Matrix(2, 3, 4, 5, 6, 7);
     const matrix2 = new Matrix(8, 9, 10, 11, 12, 13);
     matrix1.append(matrix2);
@@ -184,8 +184,8 @@ describe('append', () => {
   });
 });
 
-describe('identity', () => {
-  it('should set the values to the identity matrix', () => {
+describe('identity', (): void => {
+  it('should set the values to the identity matrix', (): void => {
     const matrix = new Matrix();
     matrix.identity();
     expect(matrix.a).toBe(1);
@@ -200,8 +200,8 @@ describe('identity', () => {
   });
 });
 
-describe('toArray', () => {
-  it('should return the values as an array', () => {
+describe('toArray', (): void => {
+  it('should return the values as an array', (): void => {
     const matrix = new Matrix(2, 3, 4, 5, 6, 7);
     const result = matrix.toArray();
     expect(result[0]).toBe(matrix.a);
@@ -221,7 +221,7 @@ describe('toArray', () => {
     expect(result2[5]).toBe(matrix.ty);
   });
 
-  it('should return the values as an array with transposed coordinates', () => {
+  it('should return the values as an array with transposed coordinates', (): void => {
     const matrix = new Matrix(2, 3, 4, 5, 6, 7);
     const result = matrix.toArray(true);
     expect(result[0]).toBe(matrix.a);

package/src/phaser/geom/point.test.ts

@@ -1,20 +1,20 @@
 import { expect, describe, it } from 'vitest';
 import { Point } from './point.js';
 
-describe('Point', () => {
-  it('should create a point with default values', () => {
+describe('Point', (): void => {
+  it('should create a point with default values', (): void => {
     const point = new Point();
     expect(point.x).toBe(0);
     expect(point.y).toBe(0);
   });
 
-  it('should create a point with custom x and y values', () => {
+  it('should create a point with custom x and y values', (): void => {
     const point = new Point(10, 20);
     expect(point.x).toBe(10);
     expect(point.y).toBe(20);
   });
 
-  it('should copy from another point', () => {
+  it('should copy from another point', (): void => {
     const point1 = new Point(10, 20);
     const point2 = new Point();
     point2.copyFrom(point1);
@@ -22,28 +22,28 @@ describe('Point', () => {
     expect(point2.y).toBe(20);
   });
 
-  it('should invert a point', () => {
+  it('should invert a point', (): void => {
     const point = new Point(10, 20);
     const invertedPoint = point.invert();
     expect(invertedPoint.x).toBe(20);
     expect(invertedPoint.y).toBe(10);
   });
 
-  it('should set to x and y values', () => {
+  it('should set to x and y values', (): void => {
     const point = new Point();
     point.setTo(10, 20);
     expect(point.x).toBe(10);
     expect(point.y).toBe(20);
   });
 
-  it('should set to y value as x value', () => {
+  it('should set to y value as x value', (): void => {
     const point = new Point();
     point.setTo(10);
     expect(point.x).toBe(10);
     expect(point.y).toBe(10);
   });
 
-  it('should add points', () => {
+  it('should add points', (): void => {
     const point1 = new Point(10, 20);
     const point2 = new Point(30, 40);
     const sum = point1.add(point2.x, point2.y);
@@ -51,7 +51,7 @@ describe('Point', () => {
     expect(sum.y).toBe(60);
   });
 
-  it('should subtract points', () => {
+  it('should subtract points', (): void => {
     const point1 = new Point(10, 20);
     const point2 = new Point(30, 40);
     const difference = point1.subtract(point2.x, point2.y);
@@ -59,49 +59,49 @@ describe('Point', () => {
     expect(difference.y).toBe(-20);
   });
 
-  it('should multiply points', () => {
+  it('should multiply points', (): void => {
     const point = new Point(10, 20);
     const multipliedPoint = point.multiply(2, 3);
     expect(multipliedPoint.x).toBe(20);
     expect(multipliedPoint.y).toBe(60);
   });
 
-  it('should divide points', () => {
+  it('should divide points', (): void => {
     const point1 = new Point(10, 20);
     const quotient = point1.divide(2, 3);
     expect(quotient.x).toBe(5);
     expect(quotient.y).toBeCloseTo(6.67);
   });
 
-  it('should clamp x value', () => {
+  it('should clamp x value', (): void => {
     const point = new Point(-10, 20);
     const clampedPoint = point.clampX(-5, 10);
     expect(clampedPoint.x).toBe(-5);
     expect(clampedPoint.y).toBe(20);
   });
 
-  it('should clamp y value', () => {
+  it('should clamp y value', (): void => {
     const point = new Point(10, -20);
     const clampedPoint = point.clampY(-5, 10);
     expect(clampedPoint.x).toBe(10);
     expect(clampedPoint.y).toBe(-5);
   });
 
-  it('should clamp x and y values', () => {
+  it('should clamp x and y values', (): void => {
     const point = new Point(-10, -20);
     const clampedPoint = point.clamp(-5, 10);
     expect(clampedPoint.x).toBe(-5);
     expect(clampedPoint.y).toBe(-5);
   });
 
-  it('should clone a point', () => {
+  it('should clone a point', (): void => {
     const point1 = new Point(10, 20);
     const clonedPoint = point1.clone();
     expect(clonedPoint.x).toBe(10);
     expect(clonedPoint.y).toBe(20);
   });
 
-  it('should copy to another point', () => {
+  it('should copy to another point', (): void => {
     const point1 = new Point(10, 20);
     const point2 = new Point();
     point1.copyTo(point2);
@@ -109,98 +109,98 @@ describe('Point', () => {
     expect(point2.y).toBe(20);
   });
 
-  it('should calculate distance between two points', () => {
+  it('should calculate distance between two points', (): void => {
     const point1 = new Point(0, 0);
     const point2 = new Point(3, 4);
     const distance = point1.distance(point2);
     expect(distance).toBeCloseTo(5);
   });
 
-  it('should check if two points are equal', () => {
+  it('should check if two points are equal', (): void => {
     const point1 = new Point(10, 20);
     const point2 = new Point(10, 20);
     expect(point1.equals(point2)).toBe(true);
   });
 
-  it('should calculate angle between two points', () => {
+  it('should calculate angle between two points', (): void => {
     const point1 = new Point(0, 0);
     const point2 = new Point(3, 4);
     const angle = point1.angle(point2, true);
     expect(angle).toBeCloseTo(53.13);
   });
 
-  it('should rotate a point around another point', () => {
+  it('should rotate a point around another point', (): void => {
     const point1 = new Point(10, 20);
     const rotatedPoint = point1.rotate(0, 0, Math.PI / 2, true);
     expect(rotatedPoint.x).toBeCloseTo(9.447);
     expect(rotatedPoint.y).toBeCloseTo(20.266);
   });
 
-  it('should get magnitude of a point', () => {
+  it('should get magnitude of a point', (): void => {
     const point = new Point(3, 4);
     expect(point.getMagnitude()).toBeCloseTo(5);
   });
 
-  it('should get magnitude squared of a point', () => {
+  it('should get magnitude squared of a point', (): void => {
     const point = new Point(3, 4);
     expect(point.getMagnitudeSq()).toBeCloseTo(25);
   });
 
-  it('should set magnitude of a point', () => {
+  it('should set magnitude of a point', (): void => {
     const point = new Point(3, 4);
     const newPoint = point.setMagnitude(10);
     expect(newPoint.x).toBe(6);
     expect(newPoint.y).toBe(8);
   });
 
-  it('should normalize a point', () => {
+  it('should normalize a point', (): void => {
     const point = new Point(3, 4);
     const normalizedPoint = point.normalize();
     expect(normalizedPoint.x).toBeCloseTo(0.6);
     expect(normalizedPoint.y).toBeCloseTo(0.8);
   });
 
-  it('should check if a point is zero', () => {
+  it('should check if a point is zero', (): void => {
     const point1 = new Point(0, 0);
     const point2 = new Point(10, 20);
     expect(point1.isZero()).toBe(true);
     expect(point2.isZero()).toBe(false);
   });
 
-  it('should calculate dot product of two points', () => {
+  it('should calculate dot product of two points', (): void => {
     const point1 = new Point(1, 1);
     const point2 = new Point(2, 2);
     expect(point1.dot(point2)).toBe(4);
   });
 
-  it('should calculate cross product of two points', () => {
+  it('should calculate cross product of two points', (): void => {
     const point1 = new Point(1, 1);
     const point2 = new Point(1, 2);
     expect(point1.cross(point2)).toBe(1);
   });
 
-  it('should get perpendicular point', () => {
+  it('should get perpendicular point', (): void => {
     const point = new Point(10, 20);
     const perpPoint = point.perp();
     expect(perpPoint.x).toBe(-20);
     expect(perpPoint.y).toBe(10);
   });
 
-  it('should get right-hand normal point', () => {
+  it('should get right-hand normal point', (): void => {
     const point = new Point(10, 20);
     const normalPoint = point.normalRightHand();
     expect(normalPoint.x).toBe(-20);
     expect(normalPoint.y).toBe(10);
   });
 
-  it('should floor a point', () => {
+  it('should floor a point', (): void => {
     const point = new Point(3.14, 4.23);
     const flooredPoint = point.floor();
     expect(flooredPoint.x).toBe(3);
     expect(flooredPoint.y).toBe(4);
   });
 
-  it('should ceil a point', () => {
+  it('should ceil a point', (): void => {
     const point = new Point(3.14, 4.23);
     const ceiledPoint = point.ceil();
     expect(ceiledPoint.x).toBe(4);