@vpmedia/phaser 1.95.0 → 1.96.0

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

@@ -2,11 +2,11 @@ import { Point } from '../point.js';
 import { Rectangle } from '../rectangle.js';
 
 /**
- * TBD.
- * @param {Rectangle} a - TBD.
- * @param {number} dx - TBD.
- * @param {number} dy - TBD.
- * @returns {Rectangle} TBD.
+ * Inflates the rectangle by the specified amounts on each axis.
+ * @param {Rectangle} a - The rectangle to inflate.
+ * @param {number} dx - The amount to inflate the rectangle horizontally.
+ * @param {number} dy - The amount to inflate the rectangle vertically.
+ * @returns {Rectangle} The inflated rectangle.
  */
 export const inflate = (a, dx, dy) => {
   a.x -= dx;
@@ -17,20 +17,20 @@ export const inflate = (a, dx, dy) => {
 };
 
 /**
- * TBD.
- * @param {Rectangle} a - TBD.
- * @param {object} point - TBD.
- * @returns {Rectangle} TBD.
+ * Inflates the rectangle by the specified point values on each axis.
+ * @param {Rectangle} a - The rectangle to inflate.
+ * @param {object} point - The point containing x and y values to inflate the rectangle by.
+ * @returns {Rectangle} The inflated rectangle.
  */
 export const inflatePoint = (a, point) => {
   return inflate(a, point.x, point.y);
 };
 
 /**
- * TBD.
- * @param {Rectangle} a - TBD.
- * @param {Point} output - TBD.
- * @returns {Point} TBD.
+ * Gets the size of the rectangle as a point.
+ * @param {Rectangle} a - The rectangle to get the size of.
+ * @param {Point} output - Optional point to store the result in.
+ * @returns {Point} The size of the rectangle as a point (width, height).
  */
 export const size = (a, output = null) => {
   const result = output || new Point();
@@ -39,10 +39,10 @@ export const size = (a, output = null) => {
 };
 
 /**
- * TBD.
- * @param {Rectangle} input - TBD.
- * @param {Rectangle} output - TBD.
- * @returns {Rectangle} TBD.
+ * Clones a rectangle.
+ * @param {Rectangle} input - The rectangle to clone.
+ * @param {Rectangle} output - Optional rectangle to store the result in.
+ * @returns {Rectangle} The cloned rectangle.
  */
 export const clone = (input, output = null) => {
   const result = output || new Rectangle();
@@ -51,11 +51,11 @@ export const clone = (input, output = null) => {
 };
 
 /**
- * TBD.
- * @param {Rectangle} a - TBD.
- * @param {number} x - TBD.
- * @param {number} y - TBD.
- * @returns {boolean} TBD.
+ * Checks if a point is contained within the rectangle.
+ * @param {Rectangle} a - The rectangle to check.
+ * @param {number} x - The x coordinate of the point.
+ * @param {number} y - The y coordinate of the point.
+ * @returns {boolean} True if the point is contained within the rectangle, false otherwise.
  */
 export const contains = (a, x, y) => {
   if (a.width <= 0 || a.height <= 0) {
@@ -65,34 +65,34 @@ export const contains = (a, x, y) => {
 };
 
 /**
- * TBD.
- * @param {number} rx - TBD.
- * @param {number} ry - TBD.
- * @param {number} rw - TBD.
- * @param {number} rh - TBD.
- * @param {number} x - TBD.
- * @param {number} y - TBD.
- * @returns {boolean} TBD.
+ * Checks if a point is contained within the rectangle (raw version).
+ * @param {number} rx - The x coordinate of the rectangle.
+ * @param {number} ry - The y coordinate of the rectangle.
+ * @param {number} rw - The width of the rectangle.
+ * @param {number} rh - The height of the rectangle.
+ * @param {number} x - The x coordinate of the point.
+ * @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, ry, rw, rh, x, y) => {
   return x >= rx && x < rx + rw && y >= ry && y < ry + rh;
 };
 
 /**
- * TBD.
- * @param {Rectangle} a - TBD.
- * @param {Point} point - TBD.
- * @returns {boolean} TBD.
+ * Checks if a point is contained within the rectangle.
+ * @param {Rectangle} a - The rectangle to check.
+ * @param {Point} point - The point to check.
+ * @returns {boolean} True if the point is contained within the rectangle, false otherwise.
  */
 export const containsPoint = (a, point) => {
   return contains(a, point.x, point.y);
 };
 
 /**
- * TBD.
- * @param {Rectangle} a - TBD.
- * @param {Rectangle} b - TBD.
- * @returns {boolean} TBD.
+ * Checks if rectangle a contains rectangle b.
+ * @param {Rectangle} a - The first rectangle to check.
+ * @param {Rectangle} b - The second rectangle to check.
+ * @returns {boolean} True if rectangle a contains rectangle b, false otherwise.
  */
 export const containsRect = (a, b) => {
   if (a.volume > b.volume) {
@@ -102,30 +102,30 @@ export const containsRect = (a, b) => {
 };
 
 /**
- * TBD.
- * @param {Rectangle} a - TBD.
- * @param {Rectangle} b - TBD.
- * @returns {boolean} TBD.
+ * Checks if two rectangles are equal.
+ * @param {Rectangle} a - The first rectangle to compare.
+ * @param {Rectangle} b - The second rectangle to compare.
+ * @returns {boolean} True if the rectangles are equal, false otherwise.
  */
 export const equals = (a, b) => {
   return a.x === b.x && a.y === b.y && a.width === b.width && a.height === b.height;
 };
 
 /**
- * TBD.
- * @param {Rectangle} a - TBD.
- * @param {Rectangle} b - TBD.
- * @returns {boolean} TBD.
+ * Checks if two rectangles have the same dimensions.
+ * @param {Rectangle} a - The first rectangle to compare.
+ * @param {Rectangle} b - The second rectangle to compare.
+ * @returns {boolean} True if the rectangles have the same dimensions, false otherwise.
  */
 export const sameDimensions = (a, b) => {
   return a.width === b.width && a.height === b.height;
 };
 
 /**
- * TBD.
- * @param {Rectangle} a - TBD.
- * @param {Rectangle} b - TBD.
- * @returns {boolean} TBD.
+ * Checks if two rectangles intersect.
+ * @param {Rectangle} a - The first rectangle to check.
+ * @param {Rectangle} b - The second rectangle to check.
+ * @returns {boolean} True if the rectangles intersect, false otherwise.
  */
 export const intersects = (a, b) => {
   if (a.width <= 0 || a.height <= 0 || b.width <= 0 || b.height <= 0) {
@@ -135,11 +135,11 @@ export const intersects = (a, b) => {
 };
 
 /**
- * TBD.
- * @param {Rectangle} a - TBD.
- * @param {Rectangle} b - TBD.
- * @param {Rectangle} output - TBD.
- * @returns {Rectangle} TBD.
+ * Gets the intersection of two rectangles.
+ * @param {Rectangle} a - The first rectangle.
+ * @param {Rectangle} b - The second rectangle.
+ * @param {Rectangle} output - Optional rectangle to store the result in.
+ * @returns {Rectangle} The intersection of the rectangles, or an empty rectangle if they don't intersect.
  */
 export const intersection = (a, b, output = null) => {
   const result = output || new Rectangle();
@@ -153,14 +153,14 @@ export const intersection = (a, b, output = null) => {
 };
 
 /**
- * TBD.
- * @param {Rectangle} a - TBD.
- * @param {number} left - TBD.
- * @param {number} right - TBD.
- * @param {number} top - TBD.
- * @param {number} bottom - TBD.
- * @param {number} tolerance - TBD.
- * @returns {boolean} TBD.
+ * Checks if a rectangle intersects with a set of raw coordinates.
+ * @param {Rectangle} a - The rectangle to check.
+ * @param {number} left - The left coordinate of the area to check.
+ * @param {number} right - The right coordinate of the area to check.
+ * @param {number} top - The top coordinate of the area to check.
+ * @param {number} bottom - The bottom coordinate of the area to check.
+ * @param {number} tolerance - Optional tolerance value for intersection.
+ * @returns {boolean} True if the rectangle intersects with the area, false otherwise.
  */
 export const intersectsRaw = (a, left, right, top, bottom, tolerance = 0) => {
   return !(
@@ -172,11 +172,11 @@ export const intersectsRaw = (a, left, right, top, bottom, tolerance = 0) => {
 };
 
 /**
- * TBD.
- * @param {Rectangle} a - TBD.
- * @param {Rectangle} b - TBD.
- * @param {Rectangle} output - TBD.
- * @returns {Rectangle} TBD.
+ * Gets the union of two rectangles.
+ * @param {Rectangle} a - The first rectangle.
+ * @param {Rectangle} b - The second rectangle.
+ * @param {Rectangle} output - Optional rectangle to store the result in.
+ * @returns {Rectangle} The union of the rectangles.
  */
 export const union = (a, b, output = null) => {
   const result = output || new Rectangle();
@@ -189,10 +189,10 @@ export const union = (a, b, output = null) => {
 };
 
 /**
- * TBD.
- * @param {Point[]} points - TBD.
- * @param {Rectangle} output - TBD.
- * @returns {Rectangle} TBD.
+ * Gets the axis-aligned bounding box (AABB) of a set of points.
+ * @param {Point[]} points - The array of points to calculate the AABB for.
+ * @param {Rectangle} output - Optional rectangle to store the result in.
+ * @returns {Rectangle} The AABB of the points.
  */
 export const aabb = (points, output = null) => {
   const result = output || new Rectangle();
@@ -219,8 +219,8 @@ export const aabb = (points, output = null) => {
 };
 
 /**
- * TBD.
- * @returns {Rectangle} TBD.
+ * Gets an empty rectangle instance.
+ * @returns {Rectangle} An empty rectangle.
  */
 export const getEmptyRectangle = () => {
   if (!window.PhaserRegistry) {

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

@@ -1,10 +1,10 @@
 import { RoundedRectangle } from '../rounded_rectangle.js';
 
 /**
- * TBD.
- * @param {RoundedRectangle} input - TBD.
- * @param {RoundedRectangle} output - TBD.
- * @returns {RoundedRectangle} TBD.
+ * Clones a rounded rectangle.
+ * @param {RoundedRectangle} input - The rounded rectangle to clone.
+ * @param {RoundedRectangle} output - Optional rounded rectangle to store the result in.
+ * @returns {RoundedRectangle} The cloned rounded rectangle.
  */
 export const clone = (input, output = null) => {
   const result = output || new RoundedRectangle();

package/src/phaser/util/math.js

@@ -3,27 +3,27 @@ export const RAD_TO_DEG = 180 / Math.PI;
 export const PI_2 = Math.PI * 2;
 
 /**
- * TBD.
- * @param {number} hex - TBD.
- * @returns {number[]} TBD.
+ * Converts a hexadecimal color value to RGB components.
+ * @param {number} hex - The hexadecimal color value.
+ * @returns {number[]} An array containing the RGB components [r, g, b].
  */
 export const hex2rgb = (hex) => {
   return [((hex >> 16) & 0xff) / 255, ((hex >> 8) & 0xff) / 255, (hex & 0xff) / 255];
 };
 
 /**
- * TBD.
- * @param {number} rgb - TBD.
- * @returns {number} TBD.
+ * Converts RGB components to a hexadecimal color value.
+ * @param {number} rgb - The RGB components array [r, g, b].
+ * @returns {number} The hexadecimal color value.
  */
 export const rgb2hex = (rgb) => {
   return ((rgb[0] * 255) << 16) + ((rgb[1] * 255) << 8) + rgb[2] * 255;
 };
 
 /**
- * TBD.
- * @param {number} value - TBD.
- * @returns {number} TBD.
+ * Gets the next power of two greater than or equal to a value.
+ * @param {number} value - The input value.
+ * @returns {number} The next power of two.
  */
 export const getNextPowerOfTwo = (value) => {
   // see: https://en.wikipedia.org/wiki/Power_of_two#Fast_algorithm_to_check_if_a_positive_number_is_a_power_of_two
@@ -38,49 +38,49 @@ export const getNextPowerOfTwo = (value) => {
 };
 
 /**
- * TBD.
- * @param {number} width - TBD.
- * @param {number} height - TBD.
- * @returns {boolean} TBD.
+ * Checks if both width and height are powers of two.
+ * @param {number} width - The width to check.
+ * @param {number} height - The height to check.
+ * @returns {boolean} True if both width and height are powers of two, false otherwise.
  */
 export const isPowerOfTwo = (width, height) => {
   return width > 0 && (width & (width - 1)) === 0 && height > 0 && (height & (height - 1)) === 0;
 };
 
 /**
- * TBD.
- * @param {number} degrees - TBD.
- * @returns {number} TBD.
+ * Converts degrees to radians.
+ * @param {number} degrees - The angle in degrees.
+ * @returns {number} The angle in radians.
  */
 export const degToRad = (degrees) => {
   return degrees * DEG_TO_RAD;
 };
 
 /**
- * TBD.
- * @param {number} radians - TBD.
- * @returns {number} TBD.
+ * Converts radians to degrees.
+ * @param {number} radians - The angle in radians.
+ * @returns {number} The angle in degrees.
  */
 export const radToDeg = (radians) => {
   return radians * RAD_TO_DEG;
 };
 
 /**
- * TBD.
- * @param {number} min - TBD.
- * @param {number} max - TBD.
- * @returns {number} TBD.
+ * Gets a random integer between min and max (inclusive).
+ * @param {number} min - The minimum value.
+ * @param {number} max - The maximum value.
+ * @returns {number} A random integer between min and max.
  */
 export const between = (min, max) => {
   return Math.floor(Math.random() * (max - min + 1) + min);
 };
 
 /**
- * TBD.
- * @param {number} input - TBD.
- * @param {number} gap - TBD.
- * @param {number} start - TBD.
- * @returns {number} TBD.
+ * Snaps a value to the nearest multiple of gap, starting from start.
+ * @param {number} input - The value to snap.
+ * @param {number} gap - The gap size to snap to.
+ * @param {number} start - The starting offset for snapping.
+ * @returns {number} The snapped value.
  */
 export const snapToCeil = (input, gap = 0, start = 0) => {
   if (gap === 0) {
@@ -92,11 +92,11 @@ export const snapToCeil = (input, gap = 0, start = 0) => {
 };
 
 /**
- * TBD.
- * @param {number} value - TBD.
- * @param {number} min - TBD.
- * @param {number} max - TBD.
- * @returns {number} TBD.
+ * Wraps a value within a range.
+ * @param {number} value - The value to wrap.
+ * @param {number} min - The minimum value of the range.
+ * @param {number} max - The maximum value of the range.
+ * @returns {number} The wrapped value.
  */
 export const wrap = (value, min, max) => {
   const range = max - min;
@@ -111,31 +111,31 @@ export const wrap = (value, min, max) => {
 };
 
 /**
- * TBD.
- * @param {number} p0 - TBD.
- * @param {number} p1 - TBD.
- * @param {number} t - TBD.
- * @returns {number} TBD.
+ * Performs linear interpolation between two values.
+ * @param {number} p0 - The first point.
+ * @param {number} p1 - The second point.
+ * @param {number} t - The interpolation factor (0 to 1).
+ * @returns {number} The interpolated value.
  */
 export const linear = (p0, p1, t) => {
   return (p1 - p0) * t + p0;
 };
 
 /**
- * TBD.
- * @param {number} a - TBD.
- * @param {number} b - TBD.
- * @returns {number} TBD.
+ * Calculates the absolute difference between two numbers.
+ * @param {number} a - The first number.
+ * @param {number} b - The second number.
+ * @returns {number} The absolute difference between a and b.
  */
 export const difference = (a, b) => {
   return Math.abs(a - b);
 };
 
 /**
- * TBD.
- * @param {number[]} v - TBD.
- * @param {number} k - TBD.
- * @returns {number} TBD.
+ * Performs linear interpolation on an array of values.
+ * @param {number[]} v - The array of values.
+ * @param {number} k - The interpolation factor (0 to 1).
+ * @returns {number} The interpolated value.
  */
 export const linearInterpolation = (v, k) => {
   const m = v.length - 1;
@@ -151,12 +151,12 @@ export const linearInterpolation = (v, k) => {
 };
 
 /**
- * TBD.
- * @param {number} x1 - TBD.
- * @param {number} y1 - TBD.
- * @param {number} x2 - TBD.
- * @param {number} y2 - TBD.
- * @returns {number} TBD.
+ * Calculates the distance between two points.
+ * @param {number} x1 - The x-coordinate of the first point.
+ * @param {number} y1 - The y-coordinate of the first point.
+ * @param {number} x2 - The x-coordinate of the second point.
+ * @param {number} y2 - The y-coordinate of the second point.
+ * @returns {number} The distance between the two points.
  */
 export const distance = (x1, y1, x2, y2) => {
   const dx = x1 - x2;
@@ -165,43 +165,43 @@ export const distance = (x1, y1, x2, y2) => {
 };
 
 /**
- * TBD.
- * @param {number} a - TBD.
- * @param {number} b - TBD.
- * @param {number} tolerance - TBD.
- * @returns {boolean} TBD.
+ * Checks if two numbers are within a tolerance of each other.
+ * @param {number} a - The first number.
+ * @param {number} b - The second number.
+ * @param {number} tolerance - The tolerance value.
+ * @returns {boolean} True if the numbers are within tolerance, false otherwise.
  */
 export const within = (a, b, tolerance) => {
   return Math.abs(a - b) <= tolerance;
 };
 
 /**
- * TBD.
- * @param {number} a - TBD.
- * @param {number} r - TBD.
- * @param {number} g - TBD.
- * @param {number} b - TBD.
- * @returns {number} TBD.
+ * Creates a 32-bit color value from alpha, red, green, and blue components.
+ * @param {number} a - The alpha component (0-255).
+ * @param {number} r - The red component (0-255).
+ * @param {number} g - The green component (0-255).
+ * @param {number} b - The blue component (0-255).
+ * @returns {number} The 32-bit color value.
  */
 export const getColor32 = (a, r, g, b) => {
   return (a << 24) | (r << 16) | (g << 8) | b;
 };
 
 /**
- * TBD.
- * @param {number} r - TBD.
- * @param {number} g - TBD.
- * @param {number} b - TBD.
- * @returns {number} TBD.
+ * Creates a 24-bit color value from red, green, and blue components.
+ * @param {number} r - The red component (0-255).
+ * @param {number} g - The green component (0-255).
+ * @param {number} b - The blue component (0-255).
+ * @returns {number} The 24-bit color value.
  */
 export const getColor = (r, g, b) => {
   return (r << 16) | (g << 8) | b;
 };
 
 /**
- * TBD.
- * @param {string} value - TBD.
- * @param {{r?: number, g?: number, b?: number}} out - TBD.
+ * Converts a hex color string to RGB components.
+ * @param {string} value - The hex color string (e.g. "#FF0000").
+ * @param {{r?: number, g?: number, b?: number}} out - The object to store the result in.
  */
 export const hexToColor = (value, out) => {
   // Expand shorthand form (e.g. "03F") to full form (e.g. "0033FF")
@@ -215,9 +215,9 @@ export const hexToColor = (value, out) => {
 };
 
 /**
- * TBD.
- * @param {string} value - TBD.
- * @param {{r?: number, g?: number, b?: number, a?: number}} out - TBD.
+ * Converts a web color string (e.g. "rgb(255, 0, 0)") to RGB components with alpha.
+ * @param {string} value - The web color string (e.g. "rgba(255, 0, 0, 0.5)").
+ * @param {{r?: number, g?: number, b?: number, a?: number}} out - The object to store the result in.
  */
 export const webToColor = (value, out) => {
   const result = /^rgba?\(\s*(\d+)\s*,\s*(\d+)\s*,\s*(\d+)\s*(?:,\s*(\d+(?:\.\d+)?))?\s*\)$/.exec(value);
@@ -230,9 +230,9 @@ export const webToColor = (value, out) => {
 };
 
 /**
- * TBD.
- * @param {number} color - TBD.
- * @returns {{ alpha: number, red: number, green: number, blue: number, a: number, r: number, g: number, b: number}} TBD.
+ * Extracts RGB components from a 32-bit color value.
+ * @param {number} color - The 32-bit color value.
+ * @returns {{ alpha: number, red: number, green: number, blue: number, a: number, r: number, g: number, b: number}} An object containing the color components.
  */
 export const getRGB = (color) => {
   if (color > 16777215) {
@@ -261,10 +261,10 @@ export const getRGB = (color) => {
 };
 
 /**
- * TBD.
- * @param {string|number} value - TBD.
- * @param {{a?: number, r?: number, g?: number, b?: number, rgba?: string, color?: number, color32?: number}} out - TBD.
- * @returns {{a?: number, r?: number, g?: number, b?: number, rgba?: string, color?: number, color32?: number}} TBD.
+ * Converts a color value (string or number) to an object with various color formats.
+ * @param {string|number} value - The color value (e.g. "#FF0000" or 0xFF0000).
+ * @param {{a?: number, r?: number, g?: number, b?: number, rgba?: string, color?: number, color32?: number}} out - The object to store the result in.
+ * @returns {{a?: number, r?: number, g?: number, b?: number, rgba?: string, color?: number, color32?: number}} The updated out object.
  */
 export const valueToColor = (value, out) => {
   if (typeof value === 'string') {