melonjs 15.2.1 → 15.4.0

package/dist/types/geometries/poly.d.ts

@@ -17,21 +17,15 @@ export default class Polygon {
     constructor(x: number, y: number, points: Vector2d[]);
     /**
      * origin point of the Polygon
-     * @public
      * @type {Vector2d}
-     * @name pos
-     * @memberof Polygon
      */
-    public pos: Vector2d;
+    pos: Vector2d;
     /**
      * Array of points defining the Polygon <br>
      * Note: If you manually change `points`, you **must** call `recalc`afterwards so that the changes get applied correctly.
-     * @public
      * @type {Vector2d[]}
-     * @name points
-     * @memberof Polygon
      */
-    public points: Vector2d[];
+    points: Vector2d[];
     /**
      * The edges here are the direction of the `n`th edge of the polygon, relative to
      * the `n`th point. If you want to draw a given edge from the edge value, you must
@@ -56,8 +50,6 @@ export default class Polygon {
     onResetEvent(x: any, y: any, points: any): void;
     /**
      * set new value to the Polygon
-     * @name setShape
-     * @memberof Polygon
      * @param {number} x - position of the Polygon
      * @param {number} y - position of the Polygon
      * @param {Vector2d[]|number[]} points - array of vector or vertice defining the Polygon
@@ -66,38 +58,28 @@ export default class Polygon {
     setShape(x: number, y: number, points: Vector2d[] | number[]): Polygon;
     /**
      * set the vertices defining this Polygon
-     * @name setVertices
-     * @memberof Polygon
      * @param {Vector2d[]} vertices - array of vector or vertice defining the Polygon
      * @returns {Polygon} this instance for objecf chaining
      */
     setVertices(vertices: Vector2d[]): Polygon;
     /**
      * apply the given transformation matrix to this Polygon
-     * @name transform
-     * @memberof Polygon
      * @param {Matrix2d} m - the transformation matrix
      * @returns {Polygon} Reference to this object for method chaining
      */
     transform(m: Matrix2d): Polygon;
     /**
      * apply an isometric projection to this shape
-     * @name toIso
-     * @memberof Polygon
      * @returns {Polygon} Reference to this object for method chaining
      */
     toIso(): Polygon;
     /**
-     * apply a 2d projection to this shape
-     * @name to2d
-     * @memberof Polygon
+     * apply a 2d projection to this shapen
      * @returns {Polygon} Reference to this object for method chaining
      */
     to2d(): Polygon;
     /**
      * Rotate this Polygon (counter-clockwise) by the specified angle (in radians).
-     * @name rotate
-     * @memberof Polygon
      * @param {number} angle - The angle to rotate (in radians)
      * @param {Vector2d|ObservableVector2d} [v] - an optional point to rotate around
      * @returns {Polygon} Reference to this object for method chaining
@@ -105,8 +87,6 @@ export default class Polygon {
     rotate(angle: number, v?: Vector2d | ObservableVector2d): Polygon;
     /**
      * Scale this Polygon by the given scalar.
-     * @name scale
-     * @memberof Polygon
      * @param {number} x
      * @param {number} [y=x]
      * @returns {Polygon} Reference to this object for method chaining
@@ -114,8 +94,6 @@ export default class Polygon {
     scale(x: number, y?: number | undefined): Polygon;
     /**
      * Scale this Polygon by the given vector
-     * @name scaleV
-     * @memberof Polygon
      * @param {Vector2d} v
      * @returns {Polygon} Reference to this object for method chaining
      */
@@ -123,97 +101,70 @@ export default class Polygon {
     /**
      * Computes the calculated collision polygon.
      * This **must** be called if the `points` array, `angle`, or `offset` is modified manually.
-     * @name recalc
-     * @memberof Polygon
      * @returns {Polygon} Reference to this object for method chaining
      */
     recalc(): Polygon;
     /**
      * returns a list of indices for all triangles defined in this polygon
-     * @name getIndices
-     * @memberof Polygon
      * @returns {Array} an array of vertex indices for all triangles forming this polygon.
      */
     getIndices(): any[];
     /**
      * Returns true if the vertices composing this polygon form a convex shape (vertices must be in clockwise order).
-     * @name isConvex
-     * @memberof Polygon
      * @returns {boolean} true if the vertices are convex, false if not, null if not computable
      */
     isConvex(): boolean;
     /**
      * translate the Polygon by the specified offset
-     * @name translate
-     * @memberof Polygon
-     * @method
-     * @param {number} x - x offset
-     * @param {number} y - y offset
-     * @returns {Polygon} this Polygon
-     */
-    /**
-     * translate the Polygon by the specified vector
-     * @name translate
-     * @memberof Polygon
-     * @param {Vector2d} v - vector offset
+     * @param {number|Vector2d} x -  x offset or a vector point to translate by
+     * @param {number} [y] - y offset
      * @returns {Polygon} Reference to this object for method chaining
+     * @example
+     * polygon.translate(10, 10);
+     * // or
+     * polygon.translate(myVector2d);
      */
     translate(...args: any[]): Polygon;
     /**
      * Shifts the Polygon to the given position vector.
-     * @name shift
-     * @memberof Polygon
-     * @method
-     * @param {Vector2d} position
-     */
-    /**
-     * Shifts the Polygon to the given x, y position.
-     * @name shift
-     * @memberof Polygon
-     * @param {number} x
-     * @param {number} y
+     * @param {number|Vector2d} x -  x coordinate or a vector point to shift to
+     * @param {number} [y]
+     * @example
+     * polygon.shift(10, 10);
+     * // or
+     * polygon.shift(myVector2d);
      */
     shift(...args: any[]): void;
-    /**
-     * Returns true if the polygon contains the given point.
-     * (Note: it is highly recommended to first do a hit test on the corresponding <br>
-     *  bounding rect, as the function can be highly consuming with complex shapes)
-     * @name contains
-     * @memberof Polygon
-     * @method
-     * @param {Vector2d} point
-     * @returns {boolean} true if contains
-     */
     /**
      * Returns true if the polygon contains the given point. <br>
      * (Note: it is highly recommended to first do a hit test on the corresponding <br>
      *  bounding rect, as the function can be highly consuming with complex shapes)
-     * @name contains
-     * @memberof Polygon
-     * @param  {number} x -  x coordinate
-     * @param  {number} y -  y coordinate
-     * @returns {boolean} true if contains
+     * @param {number|Vector2d} x -  x coordinate or a vector point to check
+     * @param {number} [y] - y coordinate
+     * @returns {boolean} True if the polygon contain the point, otherwise false
+     * @example
+     * if (polygon.contains(10, 10)) {
+     *   // do something
+     * }
+     * // or
+     * if (polygon.contains(myVector2d)) {
+     *   // do something
+     * }
      */
     contains(...args: any[]): boolean;
     /**
      * returns the bounding box for this shape, the smallest Rectangle object completely containing this shape.
-     * @name getBounds
-     * @memberof Polygon
      * @returns {Bounds} this shape bounding box Rectangle object
      */
     getBounds(): Bounds;
     _bounds: object | undefined;
     /**
      * update the bounding box for this shape.
-     * @name updateBounds
-     * @memberof Polygon
      * @returns {Bounds} this shape bounding box Rectangle object
      */
     updateBounds(): Bounds;
     /**
      * clone this Polygon
-     * @name clone
-     * @memberof Polygon
      * @returns {Polygon} new Polygon
      */
     clone(): Polygon;

package/dist/types/geometries/rectangle.d.ts

@@ -15,8 +15,6 @@ export default class Rect extends Polygon {
     onResetEvent(x: any, y: any, w: any, h: any): void;
     /**
      * set new value to the rectangle shape
-     * @name setShape
-     * @memberof Rect
      * @param {number} x - position of the Rectangle
      * @param {number} y - position of the Rectangle
      * @param {number|Vector2d[]} w - width of the rectangle, or an array of vector defining the rectangle
@@ -26,76 +24,50 @@ export default class Rect extends Polygon {
     setShape(x: number, y: number, w: number | Vector2d[], h?: number | undefined, ...args: any[]): Rect;
     /**
      * left coordinate of the Rectangle
-     * @public
      * @type {number}
-     * @name left
-     * @memberof Rect
      */
-    public get left(): number;
+    get left(): number;
     /**
      * right coordinate of the Rectangle
-     * @public
      * @type {number}
-     * @name right
-     * @memberof Rect
      */
-    public get right(): number;
+    get right(): number;
     /**
      * top coordinate of the Rectangle
-     * @public
      * @type {number}
-     * @name top
-     * @memberof Rect
      */
-    public get top(): number;
+    get top(): number;
     /**
      * bottom coordinate of the Rectangle
-     * @public
      * @type {number}
-     * @name bottom
-     * @memberof Rect
      */
-    public get bottom(): number;
-    public set width(arg: number);
+    get bottom(): number;
+    set width(arg: number);
     /**
      * width of the Rectangle
-     * @public
      * @type {number}
-     * @name width
-     * @memberof Rect
      */
-    public get width(): number;
-    public set height(arg: number);
+    get width(): number;
+    set height(arg: number);
     /**
      * height of the Rectangle
-     * @public
      * @type {number}
-     * @name height
-     * @memberof Rect
      */
-    public get height(): number;
-    public set centerX(arg: number);
+    get height(): number;
+    set centerX(arg: number);
     /**
      * absolute center of this rectangle on the horizontal axis
-     * @public
      * @type {number}
-     * @name centerX
-     * @memberof Rect
      */
-    public get centerX(): number;
-    public set centerY(arg: number);
+    get centerX(): number;
+    set centerY(arg: number);
     /**
      * absolute center of this rectangle on the vertical axis
-     * @public
      * @type {number}
-     * @name centerY
-     * @memberof Rect
      */
-    public get centerY(): number;
+    get centerY(): number;
     /**
      * center the rectangle position around the given coordinates
-     * @name centerOn
-     * @memberof Rect
      * @param {number} x - the x coordinate around which to center this rectangle
      * @param {number} y - the y coordinate around which to center this rectangle
      * @returns {Rect} this rectangle
@@ -103,8 +75,6 @@ export default class Rect extends Polygon {
     centerOn(x: number, y: number): Rect;
     /**
      * resize the rectangle
-     * @name resize
-     * @memberof Rect
      * @param {number} w - new width of the rectangle
      * @param {number} h - new height of the rectangle
      * @returns {Rect} this rectangle
@@ -112,8 +82,6 @@ export default class Rect extends Polygon {
     resize(w: number, h: number): Rect;
     /**
      * scale the rectangle
-     * @name scale
-     * @memberof Rect
      * @param {number} x - a number representing the abscissa of the scaling vector.
      * @param {number} [y=x] - a number representing the ordinate of the scaling vector.
      * @returns {Rect} this rectangle
@@ -121,54 +89,40 @@ export default class Rect extends Polygon {
     scale(x: number, y?: number | undefined): Rect;
     /**
      * clone this rectangle
-     * @name clone
-     * @memberof Rect
      * @returns {Rect} new rectangle
      */
     clone(): Rect;
     /**
      * copy the position and size of the given rectangle into this one
-     * @name copy
-     * @memberof Rect
      * @param {Rect} rect - Source rectangle
      * @returns {Rect} new rectangle
      */
     copy(rect: Rect): Rect;
     /**
      * merge this rectangle with another one
-     * @name union
-     * @memberof Rect
      * @param {Rect} rect - other rectangle to union with
      * @returns {Rect} the union(ed) rectangle
      */
     union(rect: Rect): Rect;
     /**
      * check if this rectangle is intersecting with the specified one
-     * @name overlaps
-     * @memberof Rect
      * @param {Rect} rect
      * @returns {boolean} true if overlaps
      */
     overlaps(rect: Rect): boolean;
     /**
      * check if this rectangle is identical to the specified one
-     * @name equals
-     * @memberof Rect
      * @param {Rect} rect
      * @returns {boolean} true if equals
      */
     equals(rect: Rect): boolean;
     /**
      * determines whether all coordinates of this rectangle are finite numbers.
-     * @name isFinite
-     * @memberof Rect
      * @returns {boolean} false if all coordinates are positive or negative Infinity or NaN; otherwise, true.
      */
     isFinite(): boolean;
     /**
      * Returns a polygon whose edges are the same as this box.
-     * @name toPolygon
-     * @memberof Rect
      * @returns {Polygon} a new Polygon that represents this rectangle.
      */
     toPolygon(): Polygon;

package/dist/types/geometries/roundrect.d.ts

@@ -12,39 +12,30 @@ export default class RoundRect extends Rect {
      * @param {number} [radius=20] - the radius of the rounded corner
      */
     constructor(x: number, y: number, width: number, height: number, radius?: number | undefined);
-    public set radius(arg: number);
+    set radius(arg: number);
     /**
      * the radius of the rounded corner
-     * @public
      * @type {number}
      * @default 20
-     * @name radius
-     * @memberof RoundRect
      */
-    public get radius(): number;
+    get radius(): number;
     /** @ignore */
     onResetEvent(x: any, y: any, w: any, h: any, radius: any): void;
     _radius: number | undefined;
     /**
      * copy the position, size and radius of the given rounded rectangle into this one
-     * @name copy
-     * @memberof RoundRect
      * @param {RoundRect} rrect - source rounded rectangle
      * @returns {RoundRect} new rectangle
      */
     copy(rrect: RoundRect): RoundRect;
     /**
      * check if this RoundRect is identical to the specified one
-     * @name equals
-     * @memberof RoundRect
      * @param {RoundRect} rrect
      * @returns {boolean} true if equals
      */
     equals(rrect: RoundRect): boolean;
     /**
      * clone this RoundRect
-     * @name clone
-     * @memberof RoundRect
      * @returns {RoundRect} new RoundRect
      */
     clone(): RoundRect;

package/dist/types/index.d.ts

@@ -75,9 +75,9 @@ import { TextureAtlas } from "./video/texture/atlas.js";
 import Renderable from "./renderable/renderable.js";
 import Body from "./physics/body.js";
 import Bounds from "./physics/bounds.js";
-import Text from "./text/text.js";
-import BitmapText from "./text/bitmaptext.js";
-import BitmapTextData from "./text/bitmaptextdata.js";
+import Text from "./renderable/text/text.js";
+import BitmapText from "./renderable/text/bitmaptext.js";
+import BitmapTextData from "./renderable/text/bitmaptextdata.js";
 import ColorLayer from "./renderable/colorlayer.js";
 import ImageLayer from "./renderable/imagelayer.js";
 import Sprite from "./renderable/sprite.js";

package/dist/types/input/gamepad.d.ts

@@ -45,42 +45,42 @@ export function unbindGamepad(index: number, button: number): void;
 export function setGamepadDeadzone(value: number): void;
 export namespace GAMEPAD {
     namespace AXES {
-        const LX: number;
-        const LY: number;
-        const RX: number;
-        const RY: number;
-        const EXTRA_1: number;
-        const EXTRA_2: number;
-        const EXTRA_3: number;
-        const EXTRA_4: number;
+        let LX: number;
+        let LY: number;
+        let RX: number;
+        let RY: number;
+        let EXTRA_1: number;
+        let EXTRA_2: number;
+        let EXTRA_3: number;
+        let EXTRA_4: number;
     }
     namespace BUTTONS {
-        export const FACE_1: number;
-        export const FACE_2: number;
-        export const FACE_3: number;
-        export const FACE_4: number;
-        export const L1: number;
-        export const R1: number;
-        export const L2: number;
-        export const R2: number;
-        export const SELECT: number;
-        export const BACK: number;
-        export const START: number;
-        export const FORWARD: number;
-        export const L3: number;
-        export const R3: number;
-        export const UP: number;
-        export const DOWN: number;
-        export const LEFT: number;
-        export const RIGHT: number;
-        export const HOME: number;
-        const EXTRA_1_1: number;
+        export let FACE_1: number;
+        export let FACE_2: number;
+        export let FACE_3: number;
+        export let FACE_4: number;
+        export let L1: number;
+        export let R1: number;
+        export let L2: number;
+        export let R2: number;
+        export let SELECT: number;
+        export let BACK: number;
+        export let START: number;
+        export let FORWARD: number;
+        export let L3: number;
+        export let R3: number;
+        export let UP: number;
+        export let DOWN: number;
+        export let LEFT: number;
+        export let RIGHT: number;
+        export let HOME: number;
+        let EXTRA_1_1: number;
         export { EXTRA_1_1 as EXTRA_1 };
-        const EXTRA_2_1: number;
+        let EXTRA_2_1: number;
         export { EXTRA_2_1 as EXTRA_2 };
-        const EXTRA_3_1: number;
+        let EXTRA_3_1: number;
         export { EXTRA_3_1 as EXTRA_3 };
-        const EXTRA_4_1: number;
+        let EXTRA_4_1: number;
         export { EXTRA_4_1 as EXTRA_4 };
     }
 }