melonjs 14.4.0 → 15.0.0

package/dist/types/loader/settings.d.ts

@@ -0,0 +1,57 @@
+/**
+ * enable the nocache mechanism
+ * @ignore
+ */
+export function setNocache(enable?: boolean): void;
+/**
+ * change the default baseURL for the given asset type.<br>
+ * (this will prepend the asset URL and must finish with a '/')
+ * @name setBaseURL
+ * @memberof loader
+ * @public
+ * @param {string} type  - "*", "audio", binary", "image", "json", "js", "tmx", "tsx"
+ * @param {string} [url="./"] - default base URL
+ * @example
+ * // change the base URL relative address for audio assets
+ * me.loader.setBaseURL("audio", "data/audio/");
+ * // change the base URL absolute address for all object types
+ * me.loader.setBaseURL("*", "http://myurl.com/")
+ */
+export function setBaseURL(type: string, url?: string | undefined): void;
+export let nocache: string;
+export let baseURL: {};
+/**
+ * crossOrigin attribute to configure the CORS requests for Image data element.
+ * By default (that is, when the attribute is not specified), CORS is not used at all.
+ * The "anonymous" keyword means that there will be no exchange of user credentials via cookies,
+ * client-side SSL certificates or HTTP authentication as described in the Terminology section of the CORS specification.<br>
+ * @type {string}
+ * @name crossOrigin
+ * @default undefined
+ * @memberof loader
+ * @see https://developer.mozilla.org/en-US/docs/Web/HTML/CORS_settings_attributes
+ * @example
+ *  // allow for cross-origin texture loading in WebGL
+ * me.loader.crossOrigin = "anonymous";
+ *
+ * // set all ressources to be loaded
+ * me.loader.preload(game.resources, this.loaded.bind(this));
+ */
+export let crossOrigin: string;
+/**
+ * indicates whether or not cross-site Access-Control requests should be made using credentials such as cookies,
+ * authorization headers or TLS client certificates. Setting withCredentials has no effect on same-site requests.
+ * @public
+ * @type {boolean}
+ * @name withCredentials
+ * @default false
+ * @memberof loader
+ * @see https://developer.mozilla.org/en-US/docs/Web/API/XMLHttpRequest/withCredentials
+ * @example
+ *  // enable withCredentials
+ * me.loader.withCredentials = true;
+ *
+ * // set all ressources to be loaded
+ * me.loader.preload(game.resources, this.loaded.bind(this));
+ */
+export let withCredentials: boolean;

package/dist/types/particles/emitter.d.ts

@@ -168,18 +168,18 @@ export default class ParticleEmitter extends Container {
     isRunning(): boolean;
     /**
      * Launch particles from emitter constantly (e.g. for stream)
-     * @param {number} duration - [optional] time that the emitter releases particles in ms
+     * @param {number} [duration] - time that the emitter releases particles in ms
      */
-    streamParticles(duration: number): void;
+    streamParticles(duration?: number | undefined): void;
     /**
      * Stop the emitter from generating new particles (used only if emitter is Stream)
      */
     stopStream(): void;
     /**
      * Launch all particles from emitter and stop (e.g. for explosion)
-     * @param {number} total - [optional] number of particles to launch
+     * @param {number} [total] - number of particles to launch
      */
-    burstParticles(total: number): void;
+    burstParticles(total?: number | undefined): void;
     /**
      * @ignore
      */

package/dist/types/physics/bounds.d.ts

@@ -4,9 +4,9 @@
  */
 export default class Bounds {
     /**
-     * @param {Vector2d[]} [vertices] - an array of me.Vector2d points
+     * @param {Vector2d[]|Point[]} [vertices] - an array of Vector2d or Point
      */
-    constructor(vertices?: Vector2d[] | undefined);
+    constructor(vertices?: Vector2d[] | Point[] | undefined);
     _center: Vector2d;
     /**
      * @ignore
@@ -22,147 +22,106 @@ export default class Bounds {
     } | undefined;
     /**
      * reset the bound
-     * @name clear
-     * @memberof Bounds
      */
     clear(): void;
     /**
      * sets the bounds to the given min and max value
-     * @name setMinMax
-     * @memberof Bounds
      * @param {number} minX
      * @param {number} minY
      * @param {number} maxX
      * @param {number} maxY
      */
     setMinMax(minX: number, minY: number, maxX: number, maxY: number): void;
-    public set x(arg: number);
+    set x(arg: number);
     /**
      * x position of the bound
-     * @public
      * @type {number}
-     * @name x
-     * @memberof Bounds
      */
-    public get x(): number;
-    public set y(arg: number);
+    get x(): number;
+    set y(arg: number);
     /**
      * y position of the bounds
-     * @public
      * @type {number}
-     * @name y
-     * @memberof Bounds
      */
-    public get y(): number;
-    public set width(arg: number);
+    get y(): number;
+    set width(arg: number);
     /**
      * width of the bounds
-     * @public
      * @type {number}
-     * @name width
-     * @memberof Bounds
      */
-    public get width(): number;
-    public set height(arg: number);
+    get width(): number;
+    set height(arg: number);
     /**
      * width of the bounds
-     * @public
      * @type {number}
-     * @name width
-     * @memberof Bounds
      */
-    public get height(): number;
+    get height(): number;
     /**
      * left coordinate of the bound
-     * @public
      * @type {number}
-     * @name left
-     * @memberof Bounds
      */
-    public get left(): number;
+    get left(): number;
     /**
      * right coordinate of the bound
-     * @public
      * @type {number}
-     * @name right
-     * @memberof Bounds
      */
-    public get right(): number;
+    get right(): number;
     /**
      * top coordinate of the bound
-     * @public
      * @type {number}
-     * @name top
-     * @memberof Bounds
      */
-    public get top(): number;
+    get top(): number;
     /**
      * bottom coordinate of the bound
-     * @public
      * @type {number}
-     * @name bottom
-     * @memberof Bounds
      */
-    public get bottom(): number;
+    get bottom(): number;
     /**
      * center position of the bound on the x axis
-     * @public
      * @type {number}
-     * @name centerX
-     * @memberof Bounds
      */
-    public get centerX(): number;
+    get centerX(): number;
     /**
      * center position of the bound on the y axis
-     * @public
      * @type {number}
-     * @name centerY
-     * @memberof Bounds
      */
-    public get centerY(): number;
+    get centerY(): number;
     /**
      * return the center position of the bound
-     * @public
      * @type {Vector2d}
-     * @name center
-     * @memberof Bounds
      */
-    public get center(): Vector2d;
+    get center(): Vector2d;
+    /**
+     * center the bounds position around the given coordinates
+     * @param {number} x - the x coordinate around which to center this bounds
+     * @param {number} y - the y coordinate around which to center this bounds
+     */
+    centerOn(x: number, y: number): Bounds;
     /**
      * Updates bounds using the given vertices
-     * @name update
-     * @memberof Bounds
-     * @param {Vector2d[]} vertices - an array of me.Vector2d points
+     * @param {Vector2d[]|Point[]} vertices - an array of Vector2d or Point
      */
-    update(vertices: Vector2d[]): void;
+    update(vertices: Vector2d[] | Point[]): void;
     /**
      * add the given vertices to the bounds definition.
-     * @name add
-     * @memberof Bounds
-     * @param {Vector2d[]} vertices - an array of me.Vector2d points
+     * @param {Vector2d[]|Point[]} vertices - an array of Vector2d or Point
      * @param {boolean} [clear=false] - either to reset the bounds before adding the new vertices
      */
-    add(vertices: Vector2d[], clear?: boolean | undefined): void;
+    add(vertices: Vector2d[] | Point[], clear?: boolean | undefined): void;
     /**
      * add the given bounds to the bounds definition.
-     * @name addBounds
-     * @memberof Bounds
      * @param {Bounds} bounds
      * @param {boolean} [clear=false] - either to reset the bounds before adding the new vertices
      */
     addBounds(bounds: Bounds, clear?: boolean | undefined): void;
     /**
      * add the given point to the bounds definition.
-     * @name addPoint
-     * @memberof Bounds
-     * @param {Vector2d|Point} point - the point to be added to the bounds
-     * @param {Matrix2d} [m] - an optional transform to apply to the given point (only if the given point is a vector)
+     * @param {Vector2d|Point} point - the vector or point to be added to the bounds
+     * @param {Matrix2d} [m] - an optional transform to apply to the given point (if the given point is a Vector2d)
      */
     addPoint(point: Vector2d | Point, m?: any): void;
     /**
      * add the given quad coordinates to this bound definition, multiplied by the given matrix
-     * @name addFrame
-     * @memberof Bounds
      * @param {number} x0 - left X coordinates of the quad
      * @param {number} y0 - top Y coordinates of the quad
      * @param {number} x1 - right X coordinates of the quad
@@ -180,8 +139,6 @@ export default class Bounds {
      */
     /**
      * Returns true if the bounds contains the given point.
-     * @name contains
-     * @memberof Bounds
      * @param {number} x
      * @param {number} y
      * @returns {boolean} True if the bounds contain the point, otherwise false
@@ -189,16 +146,12 @@ export default class Bounds {
     contains(...args: any[]): boolean;
     /**
      * Returns true if the two bounds intersect.
-     * @name overlaps
-     * @memberof Bounds
      * @param {Bounds|Rect} bounds
      * @returns {boolean} True if the bounds overlap, otherwise false
      */
     overlaps(bounds: Bounds | Rect): boolean;
     /**
      * determines whether all coordinates of this bounds are finite numbers.
-     * @name isFinite
-     * @memberof Bounds
      * @returns {boolean} false if all coordinates are positive or negative Infinity or NaN; otherwise, true.
      */
     isFinite(): boolean;
@@ -211,8 +164,6 @@ export default class Bounds {
      */
     /**
      * Translates the bounds by x on the x axis, and y on the y axis
-     * @name translate
-     * @memberof Bounds
      * @param {number} x
      * @param {number} y
      */
@@ -226,23 +177,17 @@ export default class Bounds {
      */
     /**
      * Shifts the bounds to the given x, y position.
-     * @name shift
-     * @memberof Bounds
      * @param {number} x
      * @param {number} y
      */
     shift(...args: any[]): void;
     /**
      * clone this bounds
-     * @name clone
-     * @memberof Bounds
      * @returns {Bounds}
      */
     clone(): Bounds;
     /**
      * Returns a polygon whose edges are the same as this bounds.
-     * @name toPolygon
-     * @memberof Bounds
      * @returns {Polygon} a new Polygon that represents this bounds.
      */
     toPolygon(): Polygon;

package/dist/types/renderable/container.d.ts

@@ -206,23 +206,12 @@ export default class Container extends Renderable {
      * @returns {Renderable[]} an array of renderable object
      */
     getChildren(): Renderable[];
-    /**
-     * update the bounding box for this shape.
-     * @ignore
-     * @returns {Bounds} this shape bounding box Rectangle object
-     */
-    updateBounds(forceUpdateChildBounds?: boolean): Bounds;
     /**
      * Checks if this container is root or if it's attached to the root container.
      * @private
      * @returns {boolean}
      */
     private isAttachedToRoot;
-    /**
-     * update the cointainer's bounding rect (private)
-     * @ignore
-     */
-    updateBoundsPos(newX: any, newY: any): Bounds;
     /**
      * @ignore
      */

package/dist/types/renderable/renderable.d.ts

@@ -5,16 +5,28 @@
  */
 export default class Renderable extends Rect {
     /**
-     * to identify the object as a renderable object
-     * @ignore
+     * Position of the Renderable relative to its parent container
+     * @public
+     * @type {ObservableVector3d}
      */
-    isRenderable: boolean;
+    public pos: ObservableVector3d;
     /**
-     * If true then physic collision and input events will not impact this renderable
-     * @type {boolean}
-     * @default true
+     * The anchor point is used for attachment behavior, and/or when applying transformations.<br>
+     * The coordinate system places the origin at the top left corner of the frame (0, 0) and (1, 1) means the bottom-right corner<br>
+     * <img src="images/anchor_point.png"/><br>
+     * a Renderable's anchor point defaults to (0.5,0.5), which corresponds to the center position.<br>
+     * <br>
+     * <i><b>Note:</b> Object created through Tiled will have their anchorPoint set to (0, 0) to match Tiled Level editor implementation.
+     * To specify a value through Tiled, use a json expression like `json:{"x":0.5,"y":0.5}`. </i>
+     * @type {ObservableVector2d}
+     * @default <0.5,0.5>
      */
-    isKinematic: boolean;
+    anchorPoint: ObservableVector2d;
+    /**
+     * the renderable default transformation matrix
+     * @type {Matrix2d}
+     */
+    currentTransform: Matrix2d;
     /**
      * the renderable physic body
      * @type {Body}
@@ -51,11 +63,6 @@ export default class Renderable extends Rect {
      * }
      */
     body: Body;
-    /**
-     * the renderable default transformation matrix
-     * @type {Matrix2d}
-     */
-    currentTransform: Matrix2d;
     /**
      * (G)ame (U)nique (Id)entifier" <br>
      * a GUID will be allocated for any renderable object added <br>
@@ -100,18 +107,6 @@ export default class Renderable extends Rect {
      * @default false
      */
     floating: boolean;
-    /**
-     * The anchor point is used for attachment behavior, and/or when applying transformations.<br>
-     * The coordinate system places the origin at the top left corner of the frame (0, 0) and (1, 1) means the bottom-right corner<br>
-     * <img src="images/anchor_point.png"/><br>
-     * a Renderable's anchor point defaults to (0.5,0.5), which corresponds to the center position.<br>
-     * <br>
-     * <i><b>Note:</b> Object created through Tiled will have their anchorPoint set to (0, 0) to match Tiled Level editor implementation.
-     * To specify a value through Tiled, use a json expression like `json:{"x":0.5,"y":0.5}`. </i>
-     * @type {ObservableVector2d}
-     * @default <0.5,0.5>
-     */
-    anchorPoint: ObservableVector2d;
     /**
      * When enabled, an object container will automatically apply
      * any defined transformation before calling the child draw method.
@@ -167,6 +162,12 @@ export default class Renderable extends Rect {
      * ]);
      */
     mask: Rect | RoundRect | Polygon | Line | Ellipse;
+    /**
+      * (Experimental) an optional shader, to be used instead of the default built-in one, when drawing this renderable (WebGL only)
+      * @type {GLShader}
+      * @default undefined
+    */
+    shader: GLShader;
     /**
      * the blend mode to be applied to this renderable (see renderer setBlendMode for available blend mode)
      * @type {string}
@@ -182,15 +183,20 @@ export default class Renderable extends Rect {
      */
     name: string;
     /**
-     * Position of the Renderable relative to its parent container
-     * @public
-     * @type {ObservableVector3d}
+     * to identify the object as a renderable object
+     * @ignore
      */
-    public pos: ObservableVector3d;
+    isRenderable: boolean;
+    /**
+     * If true then physic collision and input events will not impact this renderable
+     * @type {boolean}
+     * @default true
+     */
+    isKinematic: boolean;
     /**
      * when true the renderable will be redrawn during the next update cycle
      * @type {boolean}
-     * @default false
+     * @default true
      */
     isDirty: boolean;
     _flip: {
@@ -317,11 +323,17 @@ export default class Renderable extends Rect {
      * @returns {boolean} true if the renderable is dirty
      */
     update(dt: number): boolean;
+    /**
+     * update the bounding box for this shape.
+     * @param {boolean} [absolute=true] - update the bounds size and position in (world) absolute coordinates
+     * @returns {Bounds} this shape bounding box Rectangle object
+     */
+    updateBounds(absolute?: boolean | undefined): Bounds;
     /**
      * update the renderable's bounding rect (private)
      * @ignore
      */
-    updateBoundsPos(newX: any, newY: any): void;
+    updateBoundsPos(newX?: number, newY?: number): void;
     /**
      * return the renderable absolute position in the game world
      * @returns {Vector2d}
@@ -397,6 +409,6 @@ export default class Renderable extends Rect {
     onDestroyEvent(): void;
 }
 import Rect from "./../geometries/rectangle.js";
-import ObservableVector2d from "./../math/observable_vector2.js";
 import ObservableVector3d from "./../math/observable_vector3.js";
+import ObservableVector2d from "./../math/observable_vector2.js";
 import Color from "./../math/color.js";

package/dist/types/renderable/sprite.d.ts

@@ -83,7 +83,7 @@ export default class Sprite extends Renderable {
     anim: {};
     resetAnim: Function | (() => Sprite) | undefined;
     current: {
-        name: string;
+        name: undefined;
         length: number;
         offset: object;
         width: number;
@@ -234,13 +234,13 @@ export default class Sprite extends Renderable {
      * force the current animation frame index.
      * @name setAnimationFrame
      * @memberof Sprite
-     * @param {number} [idx=0] - animation frame index
+     * @param {number} [index=0] - animation frame index
      * @returns {Sprite} Reference to this object for method chaining
      * @example
      * // reset the current animation to the first frame
      * this.setAnimationFrame();
      */
-    setAnimationFrame(idx?: number | undefined): Sprite;
+    setAnimationFrame(index?: number | undefined): Sprite;
     /**
      * return the current animation frame index.
      * @name getCurrentAnimationFrame

package/dist/types/renderable/ui/uitextbutton.d.ts

@@ -18,7 +18,6 @@ export default class UITextButton extends UIBaseElement {
      * @param {string} [settings.backgroundColor] - The css value of a background color
      * @param {string} [settings.hoverColor] - The css value of a color to be used if the pointer hovers over the button
      * @param {string} [settings.borderStrokeColor] - The css value of a color to be used to draw the border
-     * @param {boolean} [settings.offScreenCanvas] - Weather to use an offScreen canvas or not
      * @param {string} [settings.fillStyle] - The css value of a tint color to be used to tint the text
      * @param {number} [settings.borderWidth] - Width of the button
      * @param {number} [settings.borderHeight] - Height of the button

package/dist/types/state/state.d.ts

@@ -135,7 +135,7 @@ declare namespace state {
      */
     function transition(effect: string, color: any, duration?: number | undefined): void;
     /**
-     * enable/disable transition for a specific state (by default enabled for all)
+     * enable/disable the transition to a particular state (by default enabled for all)
      * @name setTransition
      * @memberof state
      * @public

package/dist/types/system/pooling.d.ts

@@ -26,14 +26,14 @@ declare class ObjectPool {
      * @param {boolean} [recycling=false] - enables object recycling for the specified class
      * @example
      * // implement CherryEntity
-     * class CherryEntity extends Spritesheet {
+     * class Cherry extends Sprite {
      *    onResetEvent() {
      *        // reset object mutable properties
      *        this.lifeBar = 100;
      *    }
      * };
      * // add our users defined entities in the object pool and enable object recycling
-     * me.pool.register("cherryentity", CherryEntity, true);
+     * me.pool.register("cherrysprite", Cherry, true);
      */
     register(className: string, classObj: object, recycling?: boolean | undefined): void;
     /**

package/dist/types/text/text.d.ts

@@ -12,12 +12,11 @@ export default class Text extends Renderable {
      * @param {number|string} settings.size - size, or size + suffix (px, em, pt)
      * @param {Color|string} [settings.fillStyle="#000000"] - a CSS color value
      * @param {Color|string} [settings.strokeStyle="#000000"] - a CSS color value
-     * @param {number} [settings.lineWidth=1] - line width, in pixels, when drawing stroke
+     * @param {number} [settings.lineWidth=0] - line width, in pixels, when drawing stroke
      * @param {string} [settings.textAlign="left"] - horizontal text alignment
      * @param {string} [settings.textBaseline="top"] - the text baseline
      * @param {number} [settings.lineHeight=1.0] - line spacing height
      * @param {Vector2d} [settings.anchorPoint={x:0.0, y:0.0}] - anchor point to draw the text at
-     * @param {boolean} [settings.offScreenCanvas=false] - whether to draw the font to an individual "cache" texture first
      * @param {number} [settings.wordWrapWidth] - the maximum length in CSS pixel for a single segment of text
      * @param {(string|string[])} [settings.text=""] - a string, or an array of strings
      * @example
@@ -33,7 +32,6 @@ export default class Text extends Renderable {
         textBaseline?: string | undefined;
         lineHeight?: number | undefined;
         anchorPoint?: any;
-        offScreenCanvas?: boolean | undefined;
         wordWrapWidth?: number | undefined;
         text?: string | string[] | undefined;
     });
@@ -45,7 +43,7 @@ export default class Text extends Renderable {
      * sets the current line width, in pixels, when drawing stroke
      * @public
      * @type {number}
-     * @default 1
+     * @default 0
      */
     public lineWidth: number | undefined;
     /**
@@ -72,15 +70,6 @@ export default class Text extends Renderable {
      * @default 1.0
      */
     public lineHeight: number | undefined;
-    /**
-     * whether to draw the font to a indidividual offscreen canvas texture first <br>
-     * Note: this will improve performances when using WebGL, but will impact
-     * memory consumption as every text element will have its own canvas texture
-     * @public
-     * @type {boolean}
-     * @default false
-     */
-    public offScreenCanvas: boolean | undefined;
     /**
      * the maximum length in CSS pixel for a single segment of text.
      * (use -1 to disable word wrapping)
@@ -144,13 +133,11 @@ export default class Text extends Renderable {
      * @param {string} [text]
      * @param {number} [x]
      * @param {number} [y]
-     * @param {boolean} [stroke=false] - draw stroke the the text if true
      */
-    draw(renderer: CanvasRenderer | WebGLRenderer, text?: string | undefined, x?: number | undefined, y?: number | undefined, stroke?: boolean | undefined): void;
+    draw(renderer: CanvasRenderer | WebGLRenderer, text?: string | undefined, x?: number | undefined, y?: number | undefined): void;
     /**
-     * draw a stroke text at the specified coord, as defined <br>
-     * by the `lineWidth` and `fillStroke` properties. <br>
-     * Note : using drawStroke is not recommended for performance reasons
+     * draw a stroke text at the specified coord, as defined by the `lineWidth` and `fillStroke` properties.
+     * @deprecated since 15.0.0
      * @param {CanvasRenderer|WebGLRenderer} renderer - Reference to the destination renderer instance
      * @param {string} text
      * @param {number} x
@@ -160,7 +147,7 @@ export default class Text extends Renderable {
     /**
      * @ignore
      */
-    _drawFont(context: any, text: any, x: any, y: any, stroke?: boolean): TextMetrics | undefined;
+    _drawFont(context: any, text: any, x: any, y: any): TextMetrics | undefined;
     /**
      * Destroy function
      * @ignore
@@ -169,5 +156,4 @@ export default class Text extends Renderable {
 }
 import Renderable from "./../renderable/renderable.js";
 import TextMetrics from "./textmetrics.js";
-import WebGLRenderer from "./../video/webgl/webgl_renderer.js";
 import Color from "./../math/color.js";

package/dist/types/text/textstyle.d.ts

@@ -2,4 +2,4 @@
  * apply the current text style to the given context
  * @ignore
  */
-export default function setContextStyle(context: any, style: any, stroke?: boolean): void;
+export default function setContextStyle(context: any, style: any): void;

package/dist/types/video/canvas/canvas_renderer.d.ts

@@ -263,11 +263,6 @@ export default class CanvasRenderer extends Renderer {
      * @param {number} height
      */
     fillPoint(x: number, y: number): void;
-    /**
-     * return a reference to the font 2d Context
-     * @ignore
-     */
-    getFontContext(): CanvasRenderingContext2D | WebGLRenderingContext;
     /**
      * save the canvas context
      * @name save

package/dist/types/video/renderer.d.ts

@@ -188,7 +188,7 @@ export default class Renderer {
      * @param {Rect|RoundRect|Polygon|Line|Ellipse} [mask] - the shape defining the mask to be applied
      * @param {boolean} [invert=false] - either the given shape should define what is visible (default) or the opposite
      */
-    setMask(mask?: Rect | Polygon | Ellipse | RoundRect | Line | undefined): void;
+    setMask(mask?: Polygon | Line | Ellipse | Rect | RoundRect | undefined): void;
     /**
      * disable (remove) the rendering mask set through setMask.
      * @see Renderer#setMask
@@ -205,10 +205,6 @@ export default class Renderer {
      * @see Renderer#setTint
      */
     clearTint(): void;
-    /**
-     * @ignore
-     */
-    drawFont(): void;
 }
 import Vector2d from "../math/vector2.js";
 import Path2D from "./../geometries/path2d.js";