melonjs 14.3.0 → 14.4.0

package/dist/types/level/tiled/TMXTileMap.d.ts

@@ -21,85 +21,63 @@ export default class TMXTileMap {
     data: object;
     /**
      * name of the tilemap
-     * @public
      * @type {string}
-     * @name TMXTileMap#name
      */
-    public name: string;
+    name: string;
     /**
      * width of the tilemap in tiles
-     * @public
      * @type {number}
-     * @name TMXTileMap#cols
      */
-    public cols: number;
+    cols: number;
     /**
      * height of the tilemap in tiles
-     * @public
      * @type {number}
-     * @name TMXTileMap#rows
      */
-    public rows: number;
+    rows: number;
     /**
      * Tile width
-     * @public
      * @type {number}
-     * @name TMXTileMap#tilewidth
      */
-    public tilewidth: number;
+    tilewidth: number;
     /**
      * Tile height
-     * @public
      * @type {number}
-     * @name TMXTileMap#tileheight
      */
-    public tileheight: number;
+    tileheight: number;
     /**
      * is the map an infinite map
-     * @public
      * @type {number}
      * @default 0
-     * @name TMXTileMap#infinite
      */
-    public infinite: number;
+    infinite: number;
     /**
      * the map orientation type. melonJS supports “orthogonal”, “isometric”, “staggered” and “hexagonal”.
-     * @public
      * @type {string}
      * @default "orthogonal"
-     * @name TMXTileMap#orientation
      */
-    public orientation: string;
+    orientation: string;
     /**
      * the order in which tiles on orthogonal tile layers are rendered.
      * (valid values are "left-down", "left-up", "right-down", "right-up")
-     * @public
      * @type {string}
      * @default "right-down"
-     * @name TMXTileMap#renderorder
      */
-    public renderorder: string;
+    renderorder: string;
     /**
      * the TMX format version
-     * @public
      * @type {string}
-     * @name TMXTileMap#version
      */
-    public version: string;
+    version: string;
     /**
      * The Tiled version used to save the file (since Tiled 1.0.1).
-     * @public
      * @type {string}
-     * @name TMXTileMap#tiledversion
      */
-    public tiledversion: string;
+    tiledversion: string;
     /**
      * The map class.
-     * @public
      * @type {string}
-     * @name TMXTileMap#class
      */
-    public class: string;
+    class: string;
     tilesets: TMXTilesetGroup | null | undefined;
     layers: any[];
     objectGroups: any[];
@@ -115,20 +93,15 @@ export default class TMXTileMap {
     initialized: boolean;
     /**
      * Return the map default renderer
-     * @name getRenderer
-     * @memberof TMXTileMap
-     * @public
      * @returns {TMXRenderer} a TMX renderer
      */
-    public getRenderer(): TMXRenderer;
-    renderer: TMXOrthogonalRenderer | TMXIsometricRenderer | TMXHexagonalRenderer | undefined;
+    getRenderer(): TMXRenderer;
+    renderer: import("./renderer/TMXOrthogonalRenderer.js").default | import("./renderer/TMXIsometricRenderer.js").default | import("./renderer/TMXHexagonalRenderer.js").default | undefined;
     /**
      * return the map bounding rect
-     * @name TMXRenderer#getBounds
-     * @public
      * @returns {Bounds}
      */
-    public getBounds(): Bounds;
+    getBounds(): Bounds;
     /**
      * parse the map
      * @ignore
@@ -137,8 +110,6 @@ export default class TMXTileMap {
     /**
      * add all the map layers and objects to the given container.
      * note : this will not automatically update the camera viewport
-     * @name TMXTileMap#addTo
-     * @public
      * @param {Container} container - target container
      * @param {boolean} [flatten=true] - if true, flatten all objects into the given container, else a `me.Container` object will be created for each corresponding groups
      * @param {boolean} [setViewportBounds=false] - if true, set the viewport bounds to the map size, this should be set to true especially if adding a level to the game world container.
@@ -148,33 +119,24 @@ export default class TMXTileMap {
      * // add the level to the game world container
      * level.addTo(me.game.world, true, true);
      */
-    public addTo(container: Container, flatten?: boolean | undefined, setViewportBounds?: boolean | undefined): void;
+    addTo(container: Container, flatten?: boolean | undefined, setViewportBounds?: boolean | undefined): void;
     /**
      * return an Array of instantiated objects, based on the map object definition
-     * @name TMXTileMap#getObjects
-     * @public
      * @param {boolean} [flatten=true] - if true, flatten all objects into the returned array.
      * when false, a `me.Container` object will be created for each corresponding groups
      * @returns {Renderable[]} Array of Objects
      */
-    public getObjects(flatten?: boolean | undefined): Renderable[];
+    getObjects(flatten?: boolean | undefined): Renderable[];
     /**
      * return all the existing layers
-     * @name TMXTileMap#getLayers
-     * @public
      * @returns {TMXLayer[]} Array of Layers
      */
-    public getLayers(): TMXLayer[];
+    getLayers(): TMXLayer[];
     /**
      * destroy function, clean all allocated objects
-     * @name TMXTileMap#destroy
-     * @public
      */
-    public destroy(): void;
+    destroy(): void;
 }
 import TMXTilesetGroup from "./TMXTilesetGroup.js";
-import TMXOrthogonalRenderer from "./renderer/TMXOrthogonalRenderer.js";
-import TMXIsometricRenderer from "./renderer/TMXIsometricRenderer.js";
-import TMXHexagonalRenderer from "./renderer/TMXHexagonalRenderer.js";
 import Container from "../../renderable/container.js";
 import TMXLayer from "./TMXLayer.js";

package/dist/types/level/tiled/TMXTileset.d.ts

@@ -19,25 +19,19 @@ export default class TMXTileset {
     tileoffset: Vector2d;
     /**
      * Tileset contains animated tiles
-     * @public
      * @type {boolean}
-     * @name TMXTileset#isAnimated
      */
-    public isAnimated: boolean;
+    isAnimated: boolean;
     /**
      * true if the tileset is a "Collection of Image" Tileset
-     * @public
      * @type {boolean}
-     * @name TMXTileset#isCollection
      */
-    public isCollection: boolean;
+    isCollection: boolean;
     /**
      * the tileset class
-     * @public
      * @type {boolean}
-     * @name TMXTileset#class
      */
-    public class: boolean;
+    class: boolean;
     /**
      * Tileset animations
      * @private
@@ -53,12 +47,10 @@ export default class TMXTileset {
     atlas: any;
     /**
      * return the tile image from a "Collection of Image" tileset
-     * @name TMXTileset#getTileImage
-     * @public
      * @param {number} gid
      * @returns {Image} corresponding image or undefined
      */
-    public getTileImage(gid: number): new (width?: number | undefined, height?: number | undefined) => HTMLImageElement;
+    getTileImage(gid: number): new (width?: number | undefined, height?: number | undefined) => HTMLImageElement;
     /**
      * set the tile properties
      * @ignore
@@ -66,28 +58,22 @@ export default class TMXTileset {
     setTileProperty(gid: any, prop: any): void;
     /**
      * return true if the gid belongs to the tileset
-     * @name TMXTileset#contains
-     * @public
      * @param {number} gid
      * @returns {boolean}
      */
-    public contains(gid: number): boolean;
+    contains(gid: number): boolean;
     /**
      * Get the view (local) tile ID from a GID, with animations applied
-     * @name TMXTileset#getViewTileId
-     * @public
      * @param {number} gid - Global tile ID
      * @returns {number} View tile ID
      */
-    public getViewTileId(gid: number): number;
+    getViewTileId(gid: number): number;
     /**
      * return the properties of the specified tile
-     * @name TMXTileset#getTileProperties
-     * @public
      * @param {number} tileId
      * @returns {object}
      */
-    public getTileProperties(tileId: number): object;
+    getTileProperties(tileId: number): object;
     update(dt: any): boolean;
     drawTile(renderer: any, dx: any, dy: any, tmxTile: any): void;
 }

package/dist/types/level/tiled/TMXTilesetGroup.d.ts

@@ -7,26 +7,20 @@ export default class TMXTilesetGroup {
     length: number;
     /**
      * add a tileset to the tileset group
-     * @name TMXTilesetGroup#add
-     * @public
      * @param {TMXTileset} tileset
      */
-    public add(tileset: TMXTileset): void;
+    add(tileset: TMXTileset): void;
     /**
      * return the tileset at the specified index
-     * @name TMXTilesetGroup#getTilesetByIndex
-     * @public
      * @param {number} i
      * @returns {TMXTileset} corresponding tileset
      */
-    public getTilesetByIndex(i: number): TMXTileset;
+    getTilesetByIndex(i: number): TMXTileset;
     /**
      * return the tileset corresponding to the specified id <br>
      * will throw an exception if no matching tileset is found
-     * @name TMXTilesetGroup#getTilesetByGid
-     * @public
      * @param {number} gid
      * @returns {TMXTileset} corresponding tileset
      */
-    public getTilesetByGid(gid: number): TMXTileset;
+    getTilesetByGid(gid: number): TMXTileset;
 }

package/dist/types/level/tiled/constants.d.ts

@@ -0,0 +1,5 @@
+export const TMX_FLIP_H: 2147483648;
+export const TMX_FLIP_V: 1073741824;
+export const TMX_FLIP_AD: 536870912;
+export const TMX_CLEAR_BIT_MASK: number;
+export const COLLISION_GROUP: "collision";

package/dist/types/level/tiled/renderer/TMXHexagonalRenderer.d.ts

@@ -25,12 +25,9 @@ export default class TMXHexagonalRenderer extends TMXRenderer {
     canRender(layer: any): boolean;
     /**
      * return the bounding rect for this map renderer
-     * @name TMXHexagonalRenderer#getBounds
-     * @public
-     * @param {TMXLayer} [layer] - calculate the bounding rect for a specific layer (will return a new bounds object)
-     * @returns {Bounds}
+     * @ignore
      */
-    public getBounds(layer?: TMXLayer | undefined): Bounds;
+    getBounds(layer: any): object;
     /**
      * @ignore
      */
@@ -84,4 +81,3 @@ export default class TMXHexagonalRenderer extends TMXRenderer {
 }
 import TMXRenderer from "./TMXRenderer.js";
 import Vector2d from "./../../../math/vector2.js";
-import TMXLayer from "./../TMXLayer.js";

package/dist/types/level/tiled/renderer/TMXIsometricRenderer.d.ts

@@ -18,12 +18,9 @@ export default class TMXIsometricRenderer extends TMXRenderer {
     canRender(layer: any): boolean;
     /**
      * return the bounding rect for this map renderer
-     * @name TMXIsometricRenderer#getBounds
-     * @public
-     * @param {TMXLayer} [layer] - calculate the bounding rect for a specific layer (will return a new bounds object)
-     * @returns {Bounds}
+     * @ignore
      */
-    public getBounds(layer?: TMXLayer | undefined): Bounds;
+    getBounds(layer: any): object;
     /**
      * return the tile position corresponding to the specified pixel
      * @ignore
@@ -52,4 +49,3 @@ export default class TMXIsometricRenderer extends TMXRenderer {
     drawTileLayer(renderer: any, layer: any, rect: any): void;
 }
 import TMXRenderer from "./TMXRenderer.js";
-import TMXLayer from "./../TMXLayer.js";

package/dist/types/level/tiled/renderer/TMXRenderer.d.ts

@@ -17,59 +17,47 @@ export default class TMXRenderer {
     bounds: Bounds;
     /**
      * return true if the renderer can render the specified map or layer
-     * @name TMXRenderer#canRender
-     * @public
      * @param {TMXTileMap|TMXLayer} component - TMX Map or Layer
      * @returns {boolean}
      */
-    public canRender(component: TMXTileMap | TMXLayer): boolean;
+    canRender(component: TMXTileMap | TMXLayer): boolean;
     /**
      * return the bounding rect for this map renderer
-     * @name TMXRenderer#getBounds
-     * @public
      * @param {TMXLayer} [layer] - calculate the bounding rect for a specific layer (will return a new bounds object)
      * @returns {Bounds}
      */
-    public getBounds(layer?: TMXLayer | undefined): Bounds;
+    getBounds(layer?: TMXLayer | undefined): Bounds;
     /**
      * return the tile position corresponding to the specified pixel
-     * @name TMXRenderer#pixelToTileCoords
-     * @public
      * @param {number} x - X coordinate
      * @param {number} y - Y coordinate
      * @param {Vector2d} [v] - an optional vector object where to put the return values
      * @returns {Vector2d}
      */
-    public pixelToTileCoords(x: number, y: number, v?: any): Vector2d;
+    pixelToTileCoords(x: number, y: number, v?: any): Vector2d;
     /**
      * return the pixel position corresponding of the specified tile
-     * @name TMXRenderer#tileToPixelCoords
-     * @public
      * @param {number} col - tile horizontal position
      * @param {number} row - tile vertical position
      * @param {Vector2d} [v] - an optional vector object where to put the return values
      * @returns {Vector2d}
      */
-    public tileToPixelCoords(col: number, row: number, v?: any): Vector2d;
+    tileToPixelCoords(col: number, row: number, v?: any): Vector2d;
     /**
      * draw the given tile at the specified layer
-     * @name TMXRenderer#drawTile
-     * @public
      * @param {CanvasRenderer|WebGLRenderer} renderer - a renderer object
      * @param {number} x - X coordinate where to draw the tile
      * @param {number} y - Y coordinate where to draw the tile
      * @param {Tile} tile - the tile object to draw
      */
-    public drawTile(renderer: CanvasRenderer | WebGLRenderer, x: number, y: number, tile: Tile): void;
+    drawTile(renderer: CanvasRenderer | WebGLRenderer, x: number, y: number, tile: Tile): void;
     /**
      * draw the given TMX Layer for the given area
-     * @name TMXRenderer#drawTileLayer
-     * @public
      * @param {CanvasRenderer|WebGLRenderer} renderer - a renderer object
      * @param {TMXLayer} layer - a TMX Layer object
      * @param {Rect} rect - the area of the layer to draw
      */
-    public drawTileLayer(renderer: CanvasRenderer | WebGLRenderer, layer: TMXLayer, rect: Rect): void;
+    drawTileLayer(renderer: CanvasRenderer | WebGLRenderer, layer: TMXLayer, rect: Rect): void;
 }
 import Bounds from "./../../../physics/bounds.js";
 import TMXLayer from "./../TMXLayer.js";

package/dist/types/level/tiled/renderer/autodetect.d.ts

@@ -0,0 +1,9 @@
+/**
+ * return a compatible renderer object for the given map
+ * @param {TMXTileMap} map
+ * @ignore
+ */
+export function getNewTMXRenderer(map: TMXTileMap): TMXOrthogonalRenderer | TMXIsometricRenderer | TMXHexagonalRenderer;
+import TMXOrthogonalRenderer from "./TMXOrthogonalRenderer.js";
+import TMXIsometricRenderer from "./TMXIsometricRenderer.js";
+import TMXHexagonalRenderer from "./TMXHexagonalRenderer.js";

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

@@ -60,6 +60,7 @@ export function init(width: number, height: number, options?: {
 export function createCanvas(width: number, height: number, returnOffscreenCanvas?: boolean | undefined): HTMLCanvasElement | OffscreenCanvas;
 /**
  * return a reference to the parent DOM element holding the main canvas
+ * @memberof video
  * @returns {HTMLElement}
  */
 export function getParent(): HTMLElement;
@@ -69,21 +70,21 @@ export function getParent(): HTMLElement;
 /**
  * Select the HTML5 Canvas renderer
  * @memberof video
- * @constant
+ * @static
  */
-export const CANVAS: 0;
+export const CANVAS: number;
 /**
  * Select the WebGL renderer
  * @memberof video
- * @constant
+ * @static
  */
-export const WEBGL: 1;
+export const WEBGL: number;
 /**
  * Auto-select the renderer (Attempt WebGL first, with fallback to Canvas)
  * @memberof video
- * @constant
+ * @static
  */
-export const AUTO: 2;
+export const AUTO: any;
 /**
  * A reference to the active Canvas or WebGL active renderer renderer
  * @memberof video

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "melonjs",
-  "version": "14.3.0",
+  "version": "14.4.0",
   "description": "melonJS Game Engine",
   "homepage": "http://www.melonjs.org/",
   "type": "module",
@@ -72,15 +72,15 @@
     "chromedriver": "^108.0.0",
     "cross-env": "^7.0.3",
     "del-cli": "^5.0.0",
-    "eslint": "^8.30.0",
+    "eslint": "^8.31.0",
     "eslint-plugin-jsdoc": "^39.6.4",
     "expect": "^29.3.1",
-    "expect-mocha-image-snapshot": "^2.0.14",
-    "fastify": "^4.10.2",
+    "expect-mocha-image-snapshot": "^3.0.1",
+    "fastify": "^4.11.0",
     "mocha": "^10.2.0",
     "npm-self-link": "^1.1.7",
-    "puppeteer": "^19.4.1",
-    "rollup": "^3.9.0",
+    "puppeteer": "^19.5.0",
+    "rollup": "^3.9.1",
     "rollup-plugin-bundle-size": "^1.0.3",
     "rollup-plugin-string": "^3.0.0",
     "terser": "^5.16.1",

package/src/application/application.js

@@ -9,24 +9,7 @@ import World from "./../physics/world.js";
 import { onresize } from "./resize.js";
 import { defaultSettings } from "./settings.js";
 import { consoleHeader } from "./header.js";
-
-/**
- * Select the HTML5 Canvas renderer
- * @constant
- */
-const CANVAS = 0;
-
-/**
- * Select the WebGL renderer
- * @constant
- */
-const WEBGL = 1;
-
-/**
- * Auto-select the renderer (Attempt WebGL first, with fallback to Canvas)
- * @constant
- */
-const AUTO = 2;
+import { CANVAS, WEBGL, AUTO } from "../const.js";
 
 /**
  * @classdesc
@@ -40,7 +23,7 @@ const AUTO = 2;
      * @param {number} height - The height of the canvas viewport
      * @param {object} [options] - The optional video/renderer parameters.<br> (see Renderer(s) documentation for further specific options)
      * @param {string|HTMLElement} [options.parent=document.body] - the DOM parent element to hold the canvas in the HTML file
-     * @param {number|Renderer} [options.renderer=video.AUTO] - renderer to use (me.video.CANVAS, me.video.WEBGL, me.video.AUTO), or a custom renderer class
+     * @param {number|Renderer} [options.renderer=AUTO] - renderer to use (CANVAS, WEBGL, AUTO), or a custom renderer class
      * @param {number|string} [options.scale=1.0] - enable scaling of the canvas ('auto' for automatic scaling)
      * @param {string} [options.scaleMethod="fit"] - screen scaling modes ('fit','fill-min','fill-max','flex','flex-width','flex-height','stretch')
      * @param {boolean} [options.preferWebGL1=false] - if true the renderer will only use WebGL 1
@@ -49,6 +32,10 @@ const AUTO = 2;
      * @param {boolean} [options.antiAlias=false] - whether to enable or not video scaling interpolation
      * @param {boolean} [options.consoleHeader=true] - whether to display melonJS version and basic device information in the console
      * @throws Will throw an exception if it fails to instantiate a renderer
+     * @example
+     * var my game = new Application(640, 480, {renderer: me.video.AUTO}) {
+     *     ....
+     * }
      */
     constructor(width, height, options) {
 

package/src/application/resize.js

@@ -4,6 +4,7 @@ import * as device from "./../system/device";
  * scale the "displayed" canvas by the given scalar.
  * this will modify the size of canvas element directly.
  * Only use this if you are not using the automatic scaling feature.
+ * @private
  * @param {Application} game - the game application instance triggering the resize
  * @param {number} x - x scaling multiplier
  * @param {number} y - y scaling multiplier
@@ -35,6 +36,7 @@ function scale(game, x, y) {
 
 /**
  * callback for window resize event
+ * @private
  * @param {Application} game - the game application instance triggering the resize
  */
 export function onresize(game) {

package/src/const.js

@@ -0,0 +1,23 @@
+/**
+ * constant to select the HTML5 Canvas renderer
+ * @type {number}
+ * @static
+ * @see Application
+ */
+export const CANVAS = 0;
+
+/**
+ * constant to select select the WebGL renderer
+ * @type {number}
+ * @static
+ * @see Application
+ */
+export const WEBGL = 1;
+
+/**
+ * constant to auto-select the renderer (Attempt WebGL first, with fallback to Canvas)
+ * @static
+ * @type (number)
+ * @see Application
+ */
+export const AUTO = 2;

package/src/index.js

@@ -175,6 +175,8 @@ export {
 // Backward compatibility for deprecated method or properties
 export * from "./lang/deprecated.js";
 
+// export all public constants
+export * from "./const.js";
 
 /**
  * a flag indicating that melonJS is fully initialized

package/src/lang/console.js

@@ -0,0 +1,36 @@
+
+/**
+ * display a deprecation warning in the console
+ * @param {string} deprecated - deprecated class,function or property name
+ * @param {string} replacement - the replacement class, function, or property name
+ * @param {string} version - the version since when the lass,function or property is deprecated
+ */
+export function warning(deprecated, replacement, version) {
+    var msg = "melonJS: %s is deprecated since version %s, please use %s";
+    var stack = new Error().stack;
+
+    if (console.groupCollapsed) {
+        console.groupCollapsed(
+            "%c" + msg,
+            "font-weight:normal;color:yellow;",
+            deprecated,
+            version,
+            replacement
+        );
+    } else {
+        console.warn(
+            msg,
+            deprecated,
+            version,
+            replacement
+        );
+    }
+
+    if (typeof stack !== "undefined") {
+        console.warn(stack);
+    }
+
+    if (console.groupCollapsed) {
+        console.groupEnd();
+    }
+}

package/src/lang/deprecated.js

@@ -2,47 +2,12 @@ import { TextureAtlas } from "./../video/texture/atlas.js";
 import Renderer from "./../video/renderer.js";
 import { Draggable, DropTarget } from "./../renderable/dragndrop.js";
 import UISpriteElement from "./../renderable/ui/uispriteelement.js";
+import { warning } from "./console.js";
+
 /*
  * placeholder for all deprecated classes and corresponding alias for backward compatibility
  */
 
-/**
- * display a deprecation warning in the console
- * @ignore
- * @param {string} deprecated - deprecated class,function or property name
- * @param {string} replacement - the replacement class, function, or property name
- * @param {string} version - the version since when the lass,function or property is deprecated
- */
-export function warning(deprecated, replacement, version) {
-    var msg = "melonJS: %s is deprecated since version %s, please use %s";
-    var stack = new Error().stack;
-
-    if (console.groupCollapsed) {
-        console.groupCollapsed(
-            "%c" + msg,
-            "font-weight:normal;color:yellow;",
-            deprecated,
-            version,
-            replacement
-        );
-    } else {
-        console.warn(
-            msg,
-            deprecated,
-            version,
-            replacement
-        );
-    }
-
-    if (typeof stack !== "undefined") {
-        console.warn(stack);
-    }
-
-    if (console.groupCollapsed) {
-        console.groupEnd();
-    }
-}
-
 /**
  * Alias of {@link TextureAtlas}
  * @public