@vpmedia/phaser 1.123.0 → 1.125.0

package/src/phaser/geom/util/circle.ts

@@ -1,6 +1,7 @@
 import { degToRad, distance } from '../../util/math.js';
 import { Circle } from '../circle.js';
 import { Point } from '../point.js';
+import type { Rectangle } from '../rectangle.js';
 
 /**
  * Clones a circle.
@@ -58,11 +59,9 @@ export const intersects = (a: Circle, b: Circle): boolean => distance(a.x, a.y,
  */
 export const circumferencePoint = (a: Circle, angle: number, asDegrees = false, output: Point | null = null): Point => {
   const result = output ?? new Point();
-  if (asDegrees) {
-    angle = degToRad(angle);
-  }
-  result.x = a.x + a.radius * Math.cos(angle);
-  result.y = a.y + a.radius * Math.sin(angle);
+  const radians = asDegrees ? degToRad(angle) : angle;
+  result.x = a.x + a.radius * Math.cos(radians);
+  result.y = a.y + a.radius * Math.sin(radians);
   return result;
 };
 
@@ -76,11 +75,9 @@ export const circumferencePoint = (a: Circle, angle: number, asDegrees = false,
  */
 export const intersectsPoint = (a: Circle, angle: number, asDegrees = false, output: Point | null = null): Point => {
   const result = output ?? new Point();
-  if (asDegrees) {
-    angle = degToRad(angle);
-  }
-  result.x = a.x + a.radius * Math.cos(angle);
-  result.y = a.y + a.radius * Math.sin(angle);
+  const radians = asDegrees ? degToRad(angle) : angle;
+  result.x = a.x + a.radius * Math.cos(radians);
+  result.y = a.y + a.radius * Math.sin(radians);
   return result;
 };
 
@@ -90,7 +87,7 @@ export const intersectsPoint = (a: Circle, angle: number, asDegrees = false, out
  * @param {object} r - The rectangle to check.
  * @returns {boolean} True if the circle intersects with the rectangle, false otherwise.
  */
-export const intersectsRectangle = (c: Circle, r: any): boolean => {
+export const intersectsRectangle = (c: Circle, r: Rectangle): boolean => {
   const cx = Math.abs(c.x - r.x - r.halfWidth);
   const xDist = r.halfWidth + c.radius;
   if (cx > xDist) {

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

@@ -2,8 +2,8 @@ import { describe, expect, it } from 'vitest';
 import { Ellipse } from '../ellipse.js';
 import { contains } from './ellipse.js';
 
-describe('ellipse utils', () => {
-  it('should contain an ellipse the given coordinates', () => {
+describe('ellipse utils', (): void => {
+  it('should contain an ellipse the given coordinates', (): void => {
     const ellipse = new Ellipse(0, 0, 10, 10);
     expect(contains(ellipse, 5, 5)).toBe(true);
     expect(contains(ellipse, 15, 15)).toBe(false);

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

@@ -2,8 +2,8 @@ import { describe, expect, it } from 'vitest';
 import { Line } from '../line.js';
 import { clone } from './line.js';
 
-describe('line utils', () => {
-  it('should clone a line', () => {
+describe('line utils', (): void => {
+  it('should clone a line', (): void => {
     const line1 = new Line(0, 0, 10, 0);
     const line2 = clone(line1);
     expect(line1.start.x).toBe(line2.start.x);

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

@@ -2,8 +2,8 @@ import { describe, expect, it } from 'vitest';
 import { Matrix } from '../matrix.js';
 import { clone, getIdentityMatrix, getTempMatrix } from './matrix.js';
 
-describe('matrix utils', () => {
-  it('should clone a matrix', () => {
+describe('matrix utils', (): void => {
+  it('should clone a matrix', (): void => {
     const matrix1 = new Matrix(2, 0, 0, 2, 0, 0);
     const matrix2 = clone(matrix1);
     expect(matrix1.a).toBe(matrix2.a);
@@ -14,12 +14,12 @@ describe('matrix utils', () => {
     expect(matrix1.ty).toBe(matrix2.ty);
   });
 
-  it('should create an identity matrix', () => {
+  it('should create an identity matrix', (): void => {
     const matrix = getIdentityMatrix();
     expect(matrix.a).toBe(1);
   });
 
-  it('should create a temporary matrix', () => {
+  it('should create a temporary matrix', (): void => {
     const matrix = getTempMatrix();
     expect(matrix.a).toBe(1);
   });

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

@@ -2,8 +2,8 @@ import { describe, expect, it } from 'vitest';
 import { Point } from '../point.js';
 import { clone } from './point.js';
 
-describe('point utils', () => {
-  it('should clone a point', () => {
+describe('point utils', (): void => {
+  it('should clone a point', (): void => {
     const point1 = new Point(1, 2);
     const point2 = clone(point1);
     expect(point1.x).toBe(point2.x);

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

@@ -221,13 +221,11 @@ export const rotate = (
   asDegrees: boolean,
   dist: number | null | undefined
 ): Point => {
-  if (asDegrees) {
-    ang *= Math.PI / 180;
-  }
+  const radians = asDegrees ? ang * (Math.PI / 180) : ang;
   if (dist === undefined || dist === null) {
     a.subtract(x, y);
-    const s = Math.sin(ang);
-    const c = Math.cos(ang);
+    const s = Math.sin(radians);
+    const c = Math.cos(radians);
     const tx = c * a.x - s * a.y;
     const ty = s * a.x + c * a.y;
     a.x = tx + x;
@@ -271,12 +269,12 @@ export const centroid = (points: Point[], output: Point | null = null): Point =>
  * @param {string} yProp - The name of the property containing the y value (default: 'y').
  * @returns {Point} A new point with parsed x and y values.
  */
-export const parse = (obj: any, xProp = 'x', yProp = 'y'): Point => {
+export const parse = (obj: Record<string, unknown>, xProp = 'x', yProp = 'y'): Point => {
   const point = new Point();
-  if (obj[xProp]) {
+  if (obj[xProp] !== undefined) {
     point.x = Math.trunc(Number(obj[xProp]));
   }
-  if (obj[yProp]) {
+  if (obj[yProp] !== undefined) {
     point.y = Math.trunc(Number(obj[yProp]));
   }
   return point;

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

@@ -2,8 +2,8 @@ import { describe, expect, it } from 'vitest';
 import { Polygon } from '../polygon.js';
 import { clone } from './polygon.js';
 
-describe('polygon utils', () => {
-  it('should clone a polygon', () => {
+describe('polygon utils', (): void => {
+  it('should clone a polygon', (): void => {
     const polygon = new Polygon([0, 0, 1, 0, 1, 1]);
     const points = clone(polygon).toNumberArray();
     expect(points[0]).toBe(0);

package/src/phaser/geom/util/rectangle.test.ts

@@ -2,8 +2,8 @@ import { describe, expect, it } from 'vitest';
 import { Rectangle } from '../rectangle.js';
 import { clone } from './rectangle.js';
 
-describe('rectangle utils', () => {
-  it('should clone a rectangle', () => {
+describe('rectangle utils', (): void => {
+  it('should clone a rectangle', (): void => {
     const rectangle1 = new Rectangle(0, 0, 10, 10);
     const rectangle2 = clone(rectangle1);
     expect(rectangle1.x).toBe(rectangle2.x);

package/src/phaser/geom/util/rectangle.ts

@@ -23,7 +23,7 @@ export const inflate = (a: Rectangle, dx: number, dy: number): Rectangle => {
  * @param {object} point - The point containing x and y values to inflate the rectangle by.
  * @returns {Rectangle} The inflated rectangle.
  */
-export const inflatePoint = (a: Rectangle, point: any): Rectangle => inflate(a, point.x, point.y);
+export const inflatePoint = (a: Rectangle, point: Point): Rectangle => inflate(a, point.x, point.y);
 
 /**
  * Gets the size of the rectangle as a point.

package/src/phaser/geom/util/rounded_rectangle.test.ts

@@ -2,8 +2,8 @@ import { describe, expect, it } from 'vitest';
 import { RoundedRectangle } from '../rounded_rectangle.js';
 import { clone } from './rounded_rectangle.js';
 
-describe('rounded rectangle utils', () => {
-  it('should clone a rounded rectangle', () => {
+describe('rounded rectangle utils', (): void => {
+  it('should clone a rounded rectangle', (): void => {
     const rectangle1 = new RoundedRectangle(0, 0, 10, 10, 2);
     const rectangle2 = clone(rectangle1);
     expect(rectangle1.x).toBe(rectangle2.x);

package/src/phaser/util/math.test.ts

@@ -17,66 +17,66 @@ import {
   wrap,
 } from './math.js';
 
-describe('DEG_TO_RAD', () => {
-  it('returns the correct value', () => {
+describe('DEG_TO_RAD', (): void => {
+  it('returns the correct value', (): void => {
     expect(DEG_TO_RAD).toBeCloseTo(Math.PI / 180);
   });
 });
 
-describe('RAD_TO_DEG', () => {
-  it('returns the correct value', () => {
+describe('RAD_TO_DEG', (): void => {
+  it('returns the correct value', (): void => {
     expect(RAD_TO_DEG).toBeCloseTo(180 / Math.PI);
   });
 });
 
-describe('PI_2', () => {
-  it('returns the correct value', () => {
+describe('PI_2', (): void => {
+  it('returns the correct value', (): void => {
     expect(PI_2).toBeCloseTo(Math.PI * 2);
   });
 });
 
-describe('getNextPowerOfTwo', () => {
-  it('returns the correct power of two value for a valid input', () => {
+describe('getNextPowerOfTwo', (): void => {
+  it('returns the correct power of two value for a valid input', (): void => {
     expect(getNextPowerOfTwo(10)).toBe(16);
   });
 
-  it('returns the correct power of two value for an invalid input', () => {
+  it('returns the correct power of two value for an invalid input', (): void => {
     expect(getNextPowerOfTwo(-5)).toBe(1);
   });
 });
 
-describe('isPowerOfTwo', () => {
-  it('returns true for a valid power of two value', () => {
+describe('isPowerOfTwo', (): void => {
+  it('returns true for a valid power of two value', (): void => {
     expect(isPowerOfTwo(8, 16)).toBe(true);
   });
 
-  it('returns false for an invalid power of two value', () => {
+  it('returns false for an invalid power of two value', (): void => {
     expect(isPowerOfTwo(7, 15)).toBe(false);
   });
 });
 
-describe('degToRad', () => {
-  it('returns the correct radian value for a valid degree input', () => {
+describe('degToRad', (): void => {
+  it('returns the correct radian value for a valid degree input', (): void => {
     expect(degToRad(90)).toBeCloseTo(Math.PI / 2);
   });
 
-  it('returns the correct radian value for an invalid degree input', () => {
+  it('returns the correct radian value for an invalid degree input', (): void => {
     expect(degToRad(-45)).toBeCloseTo(-0.7853);
   });
 });
 
-describe('radToDeg', () => {
-  it('returns the correct degree value for a valid radian input', () => {
+describe('radToDeg', (): void => {
+  it('returns the correct degree value for a valid radian input', (): void => {
     expect(radToDeg(Math.PI / 2)).toBe(90);
   });
 
-  it('returns the correct degree value for an invalid radian input', () => {
+  it('returns the correct degree value for an invalid radian input', (): void => {
     expect(radToDeg(-Math.PI / 10)).toBe(-18);
   });
 });
 
-describe('between', () => {
-  it('returns a random value within the specified range', () => {
+describe('between', (): void => {
+  it('returns a random value within the specified range', (): void => {
     const min = 1;
     const max = 100;
     const result = between(min, max);
@@ -85,18 +85,18 @@ describe('between', () => {
   });
 });
 
-describe('snapToCeil', () => {
-  it('returns the correct snapped value for a valid input with a gap of 1', () => {
+describe('snapToCeil', (): void => {
+  it('returns the correct snapped value for a valid input with a gap of 1', (): void => {
     expect(snapToCeil(3.7, 1)).toBe(4);
   });
 
-  it('returns the correct snapped value for a valid input with a gap of 2', () => {
+  it('returns the correct snapped value for a valid input with a gap of 2', (): void => {
     expect(snapToCeil(5.3, 2)).toBe(6);
   });
 });
 
-describe('wrap', () => {
-  it('returns the correct wrapped value for a valid input', () => {
+describe('wrap', (): void => {
+  it('returns the correct wrapped value for a valid input', (): void => {
     const min = 0;
     const max = 100;
     const result = wrap(150, min, max);
@@ -104,7 +104,7 @@ describe('wrap', () => {
     expect(result).toBeLessThanOrEqual(max);
   });
 
-  it('returns the correct wrapped value for an invalid input', () => {
+  it('returns the correct wrapped value for an invalid input', (): void => {
     const min = -1;
     const max = 10;
     const result = wrap(-20, min, max);
@@ -113,15 +113,15 @@ describe('wrap', () => {
   });
 });
 
-describe('linear', () => {
-  it('returns the correct interpolated value for a valid input', () => {
+describe('linear', (): void => {
+  it('returns the correct interpolated value for a valid input', (): void => {
     const p0 = 1;
     const p1 = 2;
     const t = 0.5;
     expect(linear(p0, p1, t)).toStrictEqual(1.5);
   });
 
-  it('returns the correct interpolated value for an invalid input', () => {
+  it('returns the correct interpolated value for an invalid input', (): void => {
     const p0 = 1;
     const p1 = 2;
     const t = 2;
@@ -129,32 +129,32 @@ describe('linear', () => {
   });
 });
 
-describe('difference', () => {
-  it('returns the correct difference value for a valid input', () => {
+describe('difference', (): void => {
+  it('returns the correct difference value for a valid input', (): void => {
     expect(difference(10, 5)).toBe(5);
   });
 
-  it('returns the correct difference value for an invalid input', () => {
+  it('returns the correct difference value for an invalid input', (): void => {
     expect(difference(-10, -15)).toBe(5);
   });
 });
 
-describe('linearInterpolation', () => {
-  it('returns the correct interpolated value for a valid input', () => {
+describe('linearInterpolation', (): void => {
+  it('returns the correct interpolated value for a valid input', (): void => {
     const v = [1, 2, 3];
     const k = 0.5;
     expect(linearInterpolation(v, k)).toBe(2);
   });
 
-  it('returns the correct interpolated value for an invalid input', () => {
+  it('returns the correct interpolated value for an invalid input', (): void => {
     const v = [-10, -20, -30];
     const k = -1;
     expect(linearInterpolation(v, k)).toBe(10);
   });
 });
 
-describe('distance', () => {
-  it('returns the correct distance value for a valid input', () => {
+describe('distance', (): void => {
+  it('returns the correct distance value for a valid input', (): void => {
     const x1 = 0;
     const y1 = 0;
     const x2 = 3;
@@ -162,7 +162,7 @@ describe('distance', () => {
     expect(distance(x1, y1, x2, y2)).toBeCloseTo(5);
   });
 
-  it('returns the correct distance value for an invalid input', () => {
+  it('returns the correct distance value for an invalid input', (): void => {
     const x1 = -10;
     const y1 = -20;
     const x2 = 100;
@@ -171,15 +171,15 @@ describe('distance', () => {
   });
 });
 
-describe('within', () => {
-  it('returns true for a valid input within the specified tolerance', () => {
+describe('within', (): void => {
+  it('returns true for a valid input within the specified tolerance', (): void => {
     const a = 6;
     const b = 5;
     const tolerance = 1;
     expect(within(a, b, tolerance)).toBe(true);
   });
 
-  it('returns false for an invalid input outside the specified tolerance', () => {
+  it('returns false for an invalid input outside the specified tolerance', (): void => {
     const a = -10;
     const b = -15;
     const tolerance = 0.001;

package/src/phaser/util/math.ts

@@ -63,9 +63,8 @@ export const snapToCeil = (input: number, gap = 0, start = 0): number => {
   if (gap === 0) {
     return input;
   }
-  input -= start;
-  input = gap * Math.ceil(input / gap);
-  return start + input;
+  const offset = gap * Math.ceil((input - start) / gap);
+  return start + offset;
 };
 
 /** Wraps a value within a range. */
@@ -115,8 +114,11 @@ export const getColor = (r: number, g: number, b: number): number => (r << 16) |
 
 /** Converts a hex color string to RGB components. */
 export const hexToColor = (value: string, out: ColorTarget): void => {
-  value = value.replace(/^(?:#|0x)?([a-f\d])([a-f\d])([a-f\d])$/i, (_m, r, g, b) => r + r + g + g + b + b);
-  const result = /^(?:#|0x)?([a-f\d]{2})([a-f\d]{2})([a-f\d]{2})$/i.exec(value);
+  const expanded = value.replace(
+    /^(?:#|0x)?([a-f\d])([a-f\d])([a-f\d])$/i,
+    (_match: string, r: string, g: string, b: string): string => r + r + g + g + b + b
+  );
+  const result = /^(?:#|0x)?([a-f\d]{2})([a-f\d]{2})([a-f\d]{2})$/i.exec(expanded);
   if (result) {
     out.r = Number.parseInt(result[1]!, 16);
     out.g = Number.parseInt(result[2]!, 16);