@vpmedia/phaser 1.123.0 → 1.125.0

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);

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

@@ -6,13 +6,13 @@ const square = (): Polygon => new Polygon([new Point(0, 0), new Point(10, 0), ne
 
 const triangle = (): Polygon => new Polygon([new Point(0, 0), new Point(10, 0), new Point(0, 10)]);
 
-describe('Polygon', () => {
-  describe('contains', () => {
-    it('accepts a point well inside a square', () => {
+describe('Polygon', (): void => {
+  describe('contains', (): void => {
+    it('accepts a point well inside a square', (): void => {
       expect(square().contains(5, 5)).toBe(true);
     });
 
-    it('rejects points outside a square on every side', () => {
+    it('rejects points outside a square on every side', (): void => {
       const polygon = square();
       expect(polygon.contains(-1, 5)).toBe(false);
       expect(polygon.contains(11, 5)).toBe(false);
@@ -20,13 +20,13 @@ describe('Polygon', () => {
       expect(polygon.contains(5, 11)).toBe(false);
     });
 
-    it('accepts a point inside a triangle and rejects one in the cut corner', () => {
+    it('accepts a point inside a triangle and rejects one in the cut corner', (): void => {
       const polygon = triangle();
       expect(polygon.contains(2, 2)).toBe(true);
       expect(polygon.contains(8, 8)).toBe(false);
     });
 
-    it('agrees with itself once flattened', () => {
+    it('agrees with itself once flattened', (): void => {
       const probes: [number, number][] = [
         [5, 5],
         [-1, 5],
@@ -42,7 +42,7 @@ describe('Polygon', () => {
       }
     });
 
-    it('agrees with itself once flattened for a triangle', () => {
+    it('agrees with itself once flattened for a triangle', (): void => {
       const probes: [number, number][] = [
         [2, 2],
         [8, 8],
@@ -57,35 +57,35 @@ describe('Polygon', () => {
       }
     });
 
-    it('reports false for a polygon with no points', () => {
+    it('reports false for a polygon with no points', (): void => {
       expect(new Polygon().contains(0, 0)).toBe(false);
     });
   });
 
-  describe('toNumberArray', () => {
-    it('flattens points to x/y pairs', () => {
+  describe('toNumberArray', (): void => {
+    it('flattens points to x/y pairs', (): void => {
       expect(square().toNumberArray()).toStrictEqual([0, 0, 10, 0, 10, 10, 0, 10]);
     });
 
-    it('passes an already flattened polygon through unchanged', () => {
+    it('passes an already flattened polygon through unchanged', (): void => {
       expect(square().flatten().toNumberArray()).toStrictEqual([0, 0, 10, 0, 10, 10, 0, 10]);
     });
   });
 
-  describe('flatten', () => {
-    it('marks the polygon flattened and swaps the point representation', () => {
+  describe('flatten', (): void => {
+    it('marks the polygon flattened and swaps the point representation', (): void => {
       const polygon = square().flatten();
       expect(polygon.flattened).toBe(true);
-      expect(polygon._points.every((value) => typeof value === 'number')).toBe(true);
+      expect(polygon._points.every((value): boolean => typeof value === 'number')).toBe(true);
     });
   });
 
-  describe('setTo', () => {
-    it('reads a flat list of loose numbers as x/y pairs', () => {
+  describe('setTo', (): void => {
+    it('reads a flat list of loose numbers as x/y pairs', (): void => {
       expect(new Polygon([0, 0, 10, 0, 10, 10]).toNumberArray()).toStrictEqual([0, 0, 10, 0, 10, 10]);
     });
 
-    it('reads a list of x/y tuples', () => {
+    it('reads a list of x/y tuples', (): void => {
       expect(
         new Polygon([
           [0, 0],
@@ -95,23 +95,23 @@ describe('Polygon', () => {
       ).toStrictEqual([0, 0, 10, 0, 10, 10]);
     });
 
-    it('reads a list of plain x/y objects', () => {
+    it('reads a list of plain x/y objects', (): void => {
       expect(new Polygon([{ x: 0, y: 0 }, { x: 10, y: 0 }, new Point(10, 10)]).toNumberArray()).toStrictEqual([
         0, 0, 10, 0, 10, 10,
       ]);
     });
 
-    it('stores every vertex as a point whatever form it came in as', () => {
-      expect(new Polygon([0, 0, 10, 0]).points.every((value) => value instanceof Point)).toBe(true);
+    it('stores every vertex as a point whatever form it came in as', (): void => {
+      expect(new Polygon([0, 0, 10, 0]).points.every((value): boolean => value instanceof Point)).toBe(true);
     });
 
-    it('replaces the previous points', () => {
+    it('replaces the previous points', (): void => {
       const polygon = square();
       polygon.points = [new Point(1, 1), new Point(2, 2)];
       expect(polygon.toNumberArray()).toStrictEqual([1, 1, 2, 2]);
     });
 
-    it('empties the polygon when the points are cleared', () => {
+    it('empties the polygon when the points are cleared', (): void => {
       const polygon = square();
       polygon.points = null;
       expect(polygon.points).toStrictEqual([]);
@@ -119,18 +119,18 @@ describe('Polygon', () => {
     });
   });
 
-  describe('calculateArea', () => {
-    it('measures a square', () => {
+  describe('calculateArea', (): void => {
+    it('measures a square', (): void => {
       expect(Math.abs(square().area)).toBe(100);
     });
 
-    it('measures a triangle as half its bounding square', () => {
+    it('measures a triangle as half its bounding square', (): void => {
       expect(Math.abs(triangle().area)).toBe(50);
     });
   });
 
-  describe('clone', () => {
-    it('copies the vertices into a detached polygon', () => {
+  describe('clone', (): void => {
+    it('copies the vertices into a detached polygon', (): void => {
       const original = square();
       const copy = original.clone();
       expect(copy.toNumberArray()).toStrictEqual(original.toNumberArray());

package/src/phaser/geom/polygon.ts

@@ -27,7 +27,7 @@ export class Polygon {
     this.flattened = false;
     /** @type {number} */
     this.type = GEOM_POLYGON;
-    if (points) {
+    if (points !== null) {
       this.setTo(points);
     }
   }
@@ -111,7 +111,7 @@ export class Polygon {
     this.area = 0;
     const vertices: Point[] = [];
     this._points = vertices;
-    if (points) {
+    if (points.length > 0) {
       //  If points isn't an array, use arguments as the array
       if (!Array.isArray(points)) {
         console.error('[Polygon] setTo() error, input parameter is not an array', points);