@vpmedia/phaser 1.112.0 → 1.113.0

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

@@ -1,5 +1,6 @@
 import { Point } from '../point.js';
 import { Rectangle } from '../rectangle.js';
+import { getRegistry } from '../../core/registry.js';
 
 /**
  * Inflates the rectangle by the specified amounts on each axis.
@@ -22,9 +23,7 @@ export const inflate = (a: Rectangle, dx: number, dy: number) => {
  * @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) => {
-  return inflate(a, point.x, point.y);
-};
+export const inflatePoint = (a: Rectangle, point: any) => inflate(a, point.x, point.y);
 
 /**
  * Gets the size of the rectangle as a point.
@@ -33,7 +32,7 @@ export const inflatePoint = (a: Rectangle, point: any) => {
  * @returns {Point} The size of the rectangle as a point (width, height).
  */
 export const size = (a: Rectangle, output: Point | null = null) => {
-  const result = output || new Point();
+  const result = output ?? new Point();
   result.setTo(a.width, a.height);
   return result;
 };
@@ -45,7 +44,7 @@ export const size = (a: Rectangle, output: Point | null = null) => {
  * @returns {Rectangle} The cloned rectangle.
  */
 export const clone = (input: Rectangle, output: Rectangle | null = null) => {
-  const result = output || new Rectangle();
+  const result = output ?? new Rectangle();
   result.setTo(input.x, input.y, input.width, input.height);
   return result;
 };
@@ -74,9 +73,8 @@ export const contains = (a: Rectangle, x: number, y: number) => {
  * @param {number} y - The y coordinate of the point.
  * @returns {boolean} True if the point is contained within the rectangle, false otherwise.
  */
-export const containsRaw = (rx: number, ry: number, rw: number, rh: number, x: number, y: number) => {
-  return x >= rx && x < rx + rw && y >= ry && y < ry + rh;
-};
+export const containsRaw = (rx: number, ry: number, rw: number, rh: number, x: number, y: number) =>
+  x >= rx && x < rx + rw && y >= ry && y < ry + rh;
 
 /**
  * Checks if a point is contained within the rectangle.
@@ -84,9 +82,7 @@ export const containsRaw = (rx: number, ry: number, rw: number, rh: number, x: n
  * @param {Point} point - The point to check.
  * @returns {boolean} True if the point is contained within the rectangle, false otherwise.
  */
-export const containsPoint = (a: Rectangle, point: Point) => {
-  return contains(a, point.x, point.y);
-};
+export const containsPoint = (a: Rectangle, point: Point) => contains(a, point.x, point.y);
 
 /**
  * Checks if rectangle a contains rectangle b.
@@ -107,9 +103,8 @@ export const containsRect = (a: Rectangle, b: Rectangle) => {
  * @param {Rectangle} b - The second rectangle to compare.
  * @returns {boolean} True if the rectangles are equal, false otherwise.
  */
-export const equals = (a: Rectangle, b: Rectangle) => {
-  return a.x === b.x && a.y === b.y && a.width === b.width && a.height === b.height;
-};
+export const equals = (a: Rectangle, b: Rectangle) =>
+  a.x === b.x && a.y === b.y && a.width === b.width && a.height === b.height;
 
 /**
  * Checks if two rectangles have the same dimensions.
@@ -117,9 +112,7 @@ export const equals = (a: Rectangle, b: Rectangle) => {
  * @param {Rectangle} b - The second rectangle to compare.
  * @returns {boolean} True if the rectangles have the same dimensions, false otherwise.
  */
-export const sameDimensions = (a: Rectangle, b: Rectangle) => {
-  return a.width === b.width && a.height === b.height;
-};
+export const sameDimensions = (a: Rectangle, b: Rectangle) => a.width === b.width && a.height === b.height;
 
 /**
  * Checks if two rectangles intersect.
@@ -142,7 +135,7 @@ export const intersects = (a: Rectangle, b: Rectangle) => {
  * @returns {Rectangle} The intersection of the rectangles, or an empty rectangle if they don't intersect.
  */
 export const intersection = (a: Rectangle, b: Rectangle, output: Rectangle | null = null) => {
-  const result = output || new Rectangle();
+  const result = output ?? new Rectangle();
   if (intersects(a, b)) {
     result.x = Math.max(a.x, b.x);
     result.y = Math.max(a.y, b.y);
@@ -162,21 +155,13 @@ export const intersection = (a: Rectangle, b: Rectangle, output: Rectangle | nul
  * @param {number} tolerance - Optional tolerance value for intersection.
  * @returns {boolean} True if the rectangle intersects with the area, false otherwise.
  */
-export const intersectsRaw = (
-  a: Rectangle,
-  left: number,
-  right: number,
-  top: number,
-  bottom: number,
-  tolerance: number = 0
-) => {
-  return !(
+export const intersectsRaw = (a: Rectangle, left: number, right: number, top: number, bottom: number, tolerance = 0) =>
+  !(
     left > a.right + tolerance ||
     right < a.left - tolerance ||
     top > a.bottom + tolerance ||
     bottom < a.top - tolerance
   );
-};
 
 /**
  * Gets the union of two rectangles.
@@ -186,7 +171,7 @@ export const intersectsRaw = (
  * @returns {Rectangle} The union of the rectangles.
  */
 export const union = (a: Rectangle, b: Rectangle, output: Rectangle | null = null) => {
-  const result = output || new Rectangle();
+  const result = output ?? new Rectangle();
   return result.setTo(
     Math.min(a.x, b.x),
     Math.min(a.y, b.y),
@@ -202,7 +187,7 @@ export const union = (a: Rectangle, b: Rectangle, output: Rectangle | null = nul
  * @returns {Rectangle} The AABB of the points.
  */
 export const aabb = (points: Point[], output: Rectangle | null = null) => {
-  const result = output || new Rectangle();
+  const result = output ?? new Rectangle();
   let xMax = Number.NEGATIVE_INFINITY;
   let xMin = Number.POSITIVE_INFINITY;
   let yMax = Number.NEGATIVE_INFINITY;
@@ -230,11 +215,7 @@ export const aabb = (points: Point[], output: Rectangle | null = null) => {
  * @returns {Rectangle} An empty rectangle.
  */
 export const getEmptyRectangle = () => {
-  if (!window.PhaserRegistry) {
-    window.PhaserRegistry = {};
-  }
-  if (!window.PhaserRegistry.EMPTY_RECTANGLE) {
-    window.PhaserRegistry.EMPTY_RECTANGLE = new Rectangle();
-  }
-  return window.PhaserRegistry.EMPTY_RECTANGLE;
+  getRegistry();
+  globalThis.PhaserRegistry.EMPTY_RECTANGLE ??= new Rectangle();
+  return globalThis.PhaserRegistry.EMPTY_RECTANGLE;
 };

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

@@ -1,13 +1,15 @@
-import { expect } from 'vitest';
+import { describe, expect, it } from 'vitest';
 import { RoundedRectangle } from '../rounded_rectangle.js';
 import { clone } from './rounded_rectangle.js';
 
-it('should clone a rounded rectangle', () => {
-  const rectangle1 = new RoundedRectangle(0, 0, 10, 10, 2);
-  const rectangle2 = clone(rectangle1);
-  expect(rectangle1.x).toBe(rectangle2.x);
-  expect(rectangle1.y).toBe(rectangle2.y);
-  expect(rectangle1.width).toBe(rectangle2.width);
-  expect(rectangle1.height).toBe(rectangle2.height);
-  expect(rectangle1.radius).toBe(rectangle2.radius);
+describe('rounded rectangle utils', () => {
+  it('should clone a rounded rectangle', () => {
+    const rectangle1 = new RoundedRectangle(0, 0, 10, 10, 2);
+    const rectangle2 = clone(rectangle1);
+    expect(rectangle1.x).toBe(rectangle2.x);
+    expect(rectangle1.y).toBe(rectangle2.y);
+    expect(rectangle1.width).toBe(rectangle2.width);
+    expect(rectangle1.height).toBe(rectangle2.height);
+    expect(rectangle1.radius).toBe(rectangle2.radius);
+  });
 });

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

@@ -7,7 +7,7 @@ import { RoundedRectangle } from '../rounded_rectangle.js';
  * @returns {RoundedRectangle} The cloned rounded rectangle.
  */
 export const clone = (input: RoundedRectangle, output: RoundedRectangle | null = null) => {
-  const result = output || new RoundedRectangle();
+  const result = output ?? new RoundedRectangle();
   result.x = input.x;
   result.y = input.y;
   result.width = input.width;

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

@@ -1,4 +1,4 @@
-import { expect } from 'vitest';
+import { expect, describe, it } from 'vitest';
 import {
   between,
   DEG_TO_RAD,
@@ -80,8 +80,8 @@ describe('between', () => {
     const min = 1;
     const max = 100;
     const result = between(min, max);
-    expect(result >= min).toBe(true);
-    expect(result <= max).toBe(true);
+    expect(result).toBeGreaterThanOrEqual(min);
+    expect(result).toBeLessThanOrEqual(max);
   });
 });
 
@@ -100,16 +100,16 @@ describe('wrap', () => {
     const min = 0;
     const max = 100;
     const result = wrap(150, min, max);
-    expect(result >= min).toBe(true);
-    expect(result <= max).toBe(true);
+    expect(result).toBeGreaterThanOrEqual(min);
+    expect(result).toBeLessThanOrEqual(max);
   });
 
   it('returns the correct wrapped value for an invalid input', () => {
     const min = -1;
     const max = 10;
     const result = wrap(-20, min, max);
-    expect(result >= min).toBe(true);
-    expect(result <= max).toBe(true);
+    expect(result).toBeGreaterThanOrEqual(min);
+    expect(result).toBeLessThanOrEqual(max);
   });
 });
 
@@ -118,14 +118,14 @@ describe('linear', () => {
     const p0 = 1;
     const p1 = 2;
     const t = 0.5;
-    expect(linear(p0, p1, t)).toEqual(1.5);
+    expect(linear(p0, p1, t)).toStrictEqual(1.5);
   });
 
   it('returns the correct interpolated value for an invalid input', () => {
     const p0 = 1;
     const p1 = 2;
     const t = 2;
-    expect(linear(p0, p1, t)).toEqual(3);
+    expect(linear(p0, p1, t)).toBe(3);
   });
 });
 
@@ -143,13 +143,13 @@ describe('linearInterpolation', () => {
   it('returns the correct interpolated value for a valid input', () => {
     const v = [1, 2, 3];
     const k = 0.5;
-    expect(linearInterpolation(v, k)).toEqual(2);
+    expect(linearInterpolation(v, k)).toBe(2);
   });
 
   it('returns the correct interpolated value for an invalid input', () => {
     const v = [-10, -20, -30];
     const k = -1;
-    expect(linearInterpolation(v, k)).toEqual(10);
+    expect(linearInterpolation(v, k)).toBe(10);
   });
 });
 

package/src/phaser/util/math.ts

@@ -24,14 +24,14 @@ export interface ColorComponents {
 }
 
 /** Converts a hexadecimal color value to RGB components. */
-export const hex2rgb = (hex: number): [number, number, number] => {
-  return [((hex >> 16) & 0xff) / 255, ((hex >> 8) & 0xff) / 255, (hex & 0xff) / 255];
-};
+export const hex2rgb = (hex: number): [number, number, number] => [
+  ((hex >> 16) & 0xff) / 255,
+  ((hex >> 8) & 0xff) / 255,
+  (hex & 0xff) / 255,
+];
 
 /** Converts RGB components to a hexadecimal color value. */
-export const rgb2hex = (rgb: number[]): number => {
-  return ((rgb[0] * 255) << 16) + ((rgb[1] * 255) << 8) + rgb[2] * 255;
-};
+export const rgb2hex = (rgb: number[]): number => ((rgb[0]! * 255) << 16) + ((rgb[1]! * 255) << 8) + rgb[2]! * 255;
 
 /** Gets the next power of two greater than or equal to a value. */
 export const getNextPowerOfTwo = (value: number): number => {
@@ -46,27 +46,20 @@ export const getNextPowerOfTwo = (value: number): number => {
 };
 
 /** Checks if both width and height are powers of two. */
-export const isPowerOfTwo = (width: number, height: number): boolean => {
-  return width > 0 && (width & (width - 1)) === 0 && height > 0 && (height & (height - 1)) === 0;
-};
+export const isPowerOfTwo = (width: number, height: number): boolean =>
+  width > 0 && (width & (width - 1)) === 0 && height > 0 && (height & (height - 1)) === 0;
 
 /** Converts degrees to radians. */
-export const degToRad = (degrees: number): number => {
-  return degrees * DEG_TO_RAD;
-};
+export const degToRad = (degrees: number): number => degrees * DEG_TO_RAD;
 
 /** Converts radians to degrees. */
-export const radToDeg = (radians: number): number => {
-  return radians * RAD_TO_DEG;
-};
+export const radToDeg = (radians: number): number => radians * RAD_TO_DEG;
 
 /** Gets a random integer between min and max (inclusive). */
-export const between = (min: number, max: number): number => {
-  return Math.floor(Math.random() * (max - min + 1) + min);
-};
+export const between = (min: number, max: number): number => Math.floor(Math.random() * (max - min + 1) + min);
 
 /** Snaps a value to the nearest multiple of gap, starting from start. */
-export const snapToCeil = (input: number, gap: number = 0, start: number = 0): number => {
+export const snapToCeil = (input: number, gap = 0, start = 0): number => {
   if (gap === 0) {
     return input;
   }
@@ -89,14 +82,10 @@ export const wrap = (value: number, min: number, max: number): number => {
 };
 
 /** Performs linear interpolation between two values. */
-export const linear = (p0: number, p1: number, t: number): number => {
-  return (p1 - p0) * t + p0;
-};
+export const linear = (p0: number, p1: number, t: number): number => (p1 - p0) * t + p0;
 
 /** Calculates the absolute difference between two numbers. */
-export const difference = (a: number, b: number): number => {
-  return Math.abs(a - b);
-};
+export const difference = (a: number, b: number): number => Math.abs(a - b);
 
 /** Performs linear interpolation on an array of values. */
 export const linearInterpolation = (v: number[], k: number): number => {
@@ -104,12 +93,12 @@ export const linearInterpolation = (v: number[], k: number): number => {
   const f = m * k;
   const i = Math.floor(f);
   if (k < 0) {
-    return linear(v[0], v[1], f);
+    return linear(v[0]!, v[1]!, f);
   }
   if (k > 1) {
-    return linear(v[m], v[m - 1], m - f);
+    return linear(v[m]!, v[m - 1]!, m - f);
   }
-  return linear(v[i], v[i + 1 > m ? m : i + 1], f - i);
+  return linear(v[i]!, v[i + 1 > m ? m : i + 1]!, f - i);
 };
 
 /** Calculates the distance between two points. */
@@ -120,28 +109,22 @@ export const distance = (x1: number, y1: number, x2: number, y2: number): number
 };
 
 /** Checks if two numbers are within a tolerance of each other. */
-export const within = (a: number, b: number, tolerance: number): boolean => {
-  return Math.abs(a - b) <= tolerance;
-};
+export const within = (a: number, b: number, tolerance: number): boolean => Math.abs(a - b) <= tolerance;
 
 /** Creates a 32-bit color value from alpha, red, green, and blue components. */
-export const getColor32 = (a: number, r: number, g: number, b: number): number => {
-  return (a << 24) | (r << 16) | (g << 8) | b;
-};
+export const getColor32 = (a: number, r: number, g: number, b: number): number => (a << 24) | (r << 16) | (g << 8) | b;
 
 /** Creates a 24-bit color value from red, green, and blue components. */
-export const getColor = (r: number, g: number, b: number): number => {
-  return (r << 16) | (g << 8) | b;
-};
+export const getColor = (r: number, g: number, b: number): number => (r << 16) | (g << 8) | b;
 
 /** 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);
   if (result) {
-    out.r = Number.parseInt(result[1], 16);
-    out.g = Number.parseInt(result[2], 16);
-    out.b = Number.parseInt(result[3], 16);
+    out.r = Number.parseInt(result[1]!, 16);
+    out.g = Number.parseInt(result[2]!, 16);
+    out.b = Number.parseInt(result[3]!, 16);
   }
 };
 
@@ -149,16 +132,16 @@ export const hexToColor = (value: string, out: ColorTarget): void => {
 export const webToColor = (value: string, out: ColorTarget): void => {
   const result = /^rgba?\(\s*(\d+)\s*,\s*(\d+)\s*,\s*(\d+)\s*(?:,\s*(\d+(?:\.\d+)?))?\s*\)$/.exec(value);
   if (result) {
-    out.r = Number.parseInt(result[1], 10);
-    out.g = Number.parseInt(result[2], 10);
-    out.b = Number.parseInt(result[3], 10);
-    out.a = result[4] !== undefined ? Number.parseFloat(result[4]) : 1;
+    out.r = Math.trunc(Number(result[1]));
+    out.g = Math.trunc(Number(result[2]));
+    out.b = Math.trunc(Number(result[3]));
+    out.a = result[4] !== undefined ? Number(result[4]) : 1;
   }
 };
 
 /** Extracts RGB components from a 32-bit color value. */
 export const getRGB = (color: number): ColorComponents => {
-  if (color > 16777215) {
+  if (color > 16_777_215) {
     return {
       alpha: color >>> 24,
       red: (color >> 16) & 0xff,
@@ -185,7 +168,7 @@ export const getRGB = (color: number): ColorComponents => {
 /** Converts a color value (string or number) to an object with various color formats. */
 export const valueToColor = (value: string | number, out: ColorTarget): ColorTarget => {
   if (typeof value === 'string') {
-    if (value.indexOf('rgb') === 0) {
+    if (value.startsWith('rgb')) {
       webToColor(value, out);
     } else {
       out.a = 1;