melonjs 15.1.5 → 15.2.0

package/dist/types/camera/camera2d.d.ts

@@ -236,18 +236,18 @@ export default class Camera2d extends Renderable {
      * set the camera position around the specified object
      * @name focusOn
      * @memberof Camera2d
-     * @param {Renderable} target - the renderable to focus the camera on
+     * @param {Renderable|Entity|Sprite|NineSliceSprite} target - the renderable to focus the camera on
      */
-    focusOn(target: Renderable): void;
+    focusOn(target: Renderable | Entity | Sprite | NineSliceSprite): void;
     /**
      * check if the specified renderable is in the camera
      * @name isVisible
      * @memberof Camera2d
-     * @param {Renderable} obj - to be checked against
+     * @param {Renderable|Entity|Sprite|NineSliceSprite} obj - to be checked against
      * @param {boolean} [floating = obj.floating] - if visibility check should be done against screen coordinates
      * @returns {boolean}
      */
-    isVisible(obj: Renderable, floating?: boolean | undefined): boolean;
+    isVisible(obj: Renderable | Entity | Sprite | NineSliceSprite, floating?: boolean | undefined): boolean;
     /**
      * convert the given "local" (screen) coordinates into world coordinates
      * @name localToWorld

package/dist/types/index.d.ts

@@ -40,9 +40,9 @@ import * as loader from "./loader/loader.js";
 import level from "./level/level.js";
 import * as input from "./input/input.js";
 import * as Math from "./math/math.js";
-import { plugin } from "./plugin/plugin.js";
-import { plugins } from "./plugin/plugin.js";
-import utils from "./utils/utils.js";
+import * as plugin from "./plugin/plugin.js";
+import { cache as plugins } from "./plugin/plugin.js";
+import * as utils from "./utils/utils.js";
 import save from "./system/save.js";
 import timer from "./system/timer.js";
 import pool from "./system/pooling.js";
@@ -88,7 +88,7 @@ import UISpriteElement from "./renderable/ui/uispriteelement.js";
 import Collectable from "./renderable/collectable.js";
 import Trigger from "./renderable/trigger.js";
 import Light2d from "./renderable/light2d.js";
-import { Draggable } from "./renderable/dragndrop.js";
+import { Draggable } from "./renderable/draggable.js";
 import { DropTarget } from "./renderable/dragndrop.js";
 import TMXRenderer from "./level/tiled/renderer/TMXRenderer.js";
 import TMXOrthogonalRenderer from "./level/tiled/renderer/TMXOrthogonalRenderer.js";

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

@@ -5,19 +5,19 @@
  */
 export default class Body {
     /**
-     * @param {Renderable} ancestor - the parent object this body is attached to
+     * @param {Renderable|Container|Entity|Sprite|NineSliceSprite} ancestor - the parent object this body is attached to
      * @param {Rect|Rect[]|Polygon|Polygon[]|Line|Line[]|Ellipse|Ellipse[]|Point|Point[]|Bounds|Bounds[]|object} [shapes] - a initial shape, list of shapes, or JSON object defining the body
      * @param {Function} [onBodyUpdate] - callback for when the body is updated (e.g. add/remove shapes)
      */
-    constructor(ancestor: Renderable, shapes?: Rect | Rect[] | Polygon | Polygon[] | Line | Line[] | Ellipse | Ellipse[] | Point | Point[] | Bounds | Bounds[] | object, onBodyUpdate?: Function | undefined);
+    constructor(ancestor: Renderable | Container | Entity | Sprite | NineSliceSprite, shapes?: Rect | Rect[] | Polygon | Polygon[] | Line | Line[] | Ellipse | Ellipse[] | Point | Point[] | Bounds | Bounds[] | object, onBodyUpdate?: Function | undefined);
     /**
      * a reference to the parent object that contains this body,
      * or undefined if it has not been added to one.
      * @public
-     * @type {Renderable}
+     * @type {Renderable|Container|Entity|Sprite|NineSliceSprite}
      * @default undefined
      */
-    public ancestor: Renderable;
+    public ancestor: Renderable | Container | Entity | Sprite | NineSliceSprite;
     /**
      * The AABB bounds box reprensenting this body
      * @public

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

@@ -16,11 +16,11 @@ export default class Detector {
     /**
      * determine if two objects should collide (based on both respective objects body collision mask and type).<br>
      * you can redefine this function if you need any specific rules over what should collide with what.
-     * @param {Renderable} a - a reference to the object A.
-     * @param {Renderable} b - a reference to the object B.
+     * @param {Renderable|Container|Entity|Sprite|NineSliceSprite} a - a reference to the object A.
+     * @param {Renderable|Container|Entity|Sprite|NineSliceSprite} b - a reference to the object B.
      * @returns {boolean} true if they should collide, false otherwise
      */
-    shouldCollide(a: Renderable, b: Renderable): boolean;
+    shouldCollide(a: Renderable | Container | Entity | Sprite | NineSliceSprite, b: Renderable | Container | Entity | Sprite | NineSliceSprite): boolean;
     /**
      * detect collision between two bodies.
      * @param {Body} bodyA - a reference to body A.
@@ -31,10 +31,10 @@ export default class Detector {
     /**
      * find all the collisions for the specified object using a broadphase algorithm
      * @ignore
-     * @param {Renderable} objA - object to be tested for collision
+     * @param {Renderable|Container|Entity|Sprite|NineSliceSprite} objA - object to be tested for collision
      * @returns {boolean} in case of collision, false otherwise
      */
-    collisions(objA: Renderable): boolean;
+    collisions(objA: Renderable | Container | Entity | Sprite | NineSliceSprite): boolean;
     /**
      * Checks for object colliding with the given line
      * @ignore

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

@@ -1,48 +1,48 @@
 /**
  * Checks whether polygons collide.
  * @ignore
- * @param {Renderable} a - a reference to the object A.
+ * @param {Renderable|Container|Entity|Sprite|NineSliceSprite} a - a reference to the object A.
  * @param {Polygon} polyA - a reference to the object A Polygon to be tested
- * @param {Renderable} b - a reference to the object B.
+ * @param {Renderable|Container|Entity|Sprite|NineSliceSprite} b - a reference to the object B.
  * @param {Polygon} polyB - a reference to the object B Polygon to be tested
  * @param {Response=} response - Response object (optional) that will be populated if they intersect.
  * @returns {boolean} true if they intersect, false if they don't.
  */
-export function testPolygonPolygon(a: Renderable, polyA: Polygon, b: Renderable, polyB: Polygon, response?: Response | undefined): boolean;
+export function testPolygonPolygon(a: Renderable | Container | Entity | Sprite | NineSliceSprite, polyA: Polygon, b: Renderable | Container | Entity | Sprite | NineSliceSprite, polyB: Polygon, response?: Response | undefined): boolean;
 /**
  * Check if two Ellipse collide.
  * @ignore
- * @param {Renderable} a - a reference to the object A.
+ * @param {Renderable|Container|Entity|Sprite|NineSliceSprite} a - a reference to the object A.
  * @param {Ellipse} ellipseA - a reference to the object A Ellipse to be tested
- * @param {Renderable} b - a reference to the object B.
+ * @param {Renderable|Container|Entity|Sprite|NineSliceSprite} b - a reference to the object B.
  * @param {Ellipse} ellipseB - a reference to the object B Ellipse to be tested
  * @param {Response=} response - Response object (optional) that will be populated if
  *   the circles intersect.
  * @returns {boolean} true if the circles intersect, false if they don't.
  */
-export function testEllipseEllipse(a: Renderable, ellipseA: Ellipse, b: Renderable, ellipseB: Ellipse, response?: Response | undefined): boolean;
+export function testEllipseEllipse(a: Renderable | Container | Entity | Sprite | NineSliceSprite, ellipseA: Ellipse, b: Renderable | Container | Entity | Sprite | NineSliceSprite, ellipseB: Ellipse, response?: Response | undefined): boolean;
 /**
  * Check if a polygon and an ellipse collide.
  * @ignore
- * @param {Renderable} a - a reference to the object A.
+ * @param {Renderable|Container|Entity|Sprite|NineSliceSprite} a - a reference to the object A.
  * @param {Polygon} polyA - a reference to the object A Polygon to be tested
- * @param {Renderable} b - a reference to the object B.
+ * @param {Renderable|Container|Entity|Sprite|NineSliceSprite} b - a reference to the object B.
  * @param {Ellipse} ellipseB - a reference to the object B Ellipse to be tested
  * @param {Response=} response - Response object (optional) that will be populated if they intersect.
  * @returns {boolean} true if they intersect, false if they don't.
  */
-export function testPolygonEllipse(a: Renderable, polyA: Polygon, b: Renderable, ellipseB: Ellipse, response?: Response | undefined): boolean;
+export function testPolygonEllipse(a: Renderable | Container | Entity | Sprite | NineSliceSprite, polyA: Polygon, b: Renderable | Container | Entity | Sprite | NineSliceSprite, ellipseB: Ellipse, response?: Response | undefined): boolean;
 /**
  * Check if an ellipse and a polygon collide. <br>
  * **NOTE:** This is slightly less efficient than testPolygonEllipse as it just
  * runs testPolygonEllipse and reverses the response at the end.
  * @ignore
- * @param {Renderable} a - a reference to the object A.
+ * @param {Renderable|Container|Entity|Sprite|NineSliceSprite} a - a reference to the object A.
  * @param {Ellipse} ellipseA - a reference to the object A Ellipse to be tested
- * @param {Renderable} b - a reference to the object B.
+ * @param {Renderable|Container|Entity|Sprite|NineSliceSprite} b - a reference to the object B.
  * @param {Polygon} polyB - a reference to the object B Polygon to be tested
  * @param {Response=} response - Response object (optional) that will be populated if
  *   they intersect.
  * @returns {boolean} true if they intersect, false if they don't.
  */
-export function testEllipsePolygon(a: Renderable, ellipseA: Ellipse, b: Renderable, polyB: Polygon, response?: Response | undefined): boolean;
+export function testEllipsePolygon(a: Renderable | Container | Entity | Sprite | NineSliceSprite, ellipseA: Ellipse, b: Renderable | Container | Entity | Sprite | NineSliceSprite, polyB: Polygon, response?: Response | undefined): boolean;

package/dist/types/plugin/plugin.d.ts

@@ -1,10 +1,65 @@
 /**
- * This namespace is a container for all registered plugins.
- * @see plugin.register
- * @namespace plugins
+ * patch a melonJS function
+ * @name patch
+ * @memberof plugin
+ * @param {object} proto - target object
+ * @param {string} name - target function
+ * @param {Function} fn - replacement function
+ * @example
+ * // redefine the me.game.update function with a new one
+ * me.plugin.patch(me.game, "update", function () {
+ *   // display something in the console
+ *   console.log("duh");
+ *   // call the original me.game.update function
+ *   this._patched();
+ * });
  */
-export let plugins: {};
+export function patch(proto: object, name: string, fn: Function): void;
+/**
+ * Register a plugin.
+ * @name register
+ * @memberof plugin
+ * @param {plugin.BasePlugin} plugin - Plugin object to instantiate and register
+ * @param {string} [name=plugin.constructor.name] - a unique name for this plugin
+ * @param {object} [...arguments] - all extra parameters will be passed to the plugin constructor
+ * @example
+ * // register a new plugin
+ * me.plugin.register(TestPlugin, "testPlugin");
+ * // the plugin then also become available
+ * // under then me.plugins namespace
+ * me.plugins.testPlugin.myfunction ();
+ */
+export function register(plugin: plugin.BasePlugin, name?: string | undefined, ...args: any[]): void;
+/**
+ * Contains all registered plugins.
+ * @name cache
+ * @memberof plugin
+ */
+export let cache: {};
 /**
  * @namespace plugin
  */
-export let plugin: any;
+/**
+ * a base Object class for plugin
+ * (plugin must be installed using the register function)
+ * @class
+ * @name BasePlugin
+ * @memberof plugin
+ */
+export class BasePlugin {
+    /**
+     * define the minimum required version of melonJS<br>
+     * this can be overridden by the plugin
+     * @type {string}
+     * @default "__VERSION__"
+     */
+    version: string;
+}
+/**
+ * @class
+ * @name Base
+ * @memberof plugin
+ * @deprecated since 15.1.6, see {@link plugin.BasePlugin}
+ */
+export class Base extends BasePlugin {
+}

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

@@ -93,19 +93,19 @@ export default class Container extends Renderable {
      * will not be in any container. <br>
      * if the given child implements a onActivateEvent method, that method will be called
      * once the child is added to this container.
-     * @param {Renderable} child
+     * @param {Renderable|Entity|Sprite|Collectable|Trigger|Draggable|DropTarget|NineSliceSprite|ImageLayer|ColorLayer|Light2d|UIBaseElement|UISpriteElement|UITextButton|Text|BitmapText} child
      * @param {number} [z] - forces the z index of the child to the specified value
      * @returns {Renderable} the added child
      */
-    addChild(child: Renderable, z?: number | undefined): Renderable;
+    addChild(child: Renderable | Entity | Sprite | Collectable | Trigger | Draggable | DropTarget | NineSliceSprite | ImageLayer | ColorLayer | Light2d | UIBaseElement | UISpriteElement | UITextButton | Text | BitmapText, z?: number | undefined): Renderable;
     /**
      * Add a child to the container at the specified index<br>
      * (the list won't be sorted after insertion)
-     * @param {Renderable} child
+     * @param {Renderable|Entity|Sprite|Collectable|Trigger|Draggable|DropTarget|NineSliceSprite|ImageLayer|ColorLayer|Light2d|UIBaseElement|UISpriteElement|UITextButton|Text|BitmapText} child
      * @param {number} index
      * @returns {Renderable} the added child
      */
-    addChildAt(child: Renderable, index: number): Renderable;
+    addChildAt(child: Renderable | Entity | Sprite | Collectable | Trigger | Draggable | DropTarget | NineSliceSprite | ImageLayer | ColorLayer | Light2d | UIBaseElement | UISpriteElement | UITextButton | Text | BitmapText, index: number): Renderable;
     /**
      * The forEach() method executes a provided function once per child element. <br>
      * the callback function is invoked with three arguments: <br>
@@ -127,10 +127,10 @@ export default class Container extends Renderable {
     forEach(callback: Function, thisArg?: object | undefined, ...args: any[]): void;
     /**
      * Swaps the position (z-index) of 2 children
-     * @param {Renderable} child
-     * @param {Renderable} child2
+     * @param {Renderable|Entity|Sprite|Collectable|Trigger|Draggable|DropTarget|NineSliceSprite|ImageLayer|ColorLayer|Light2d|UIBaseElement|UISpriteElement|UITextButton|Text|BitmapText} child
+     * @param {Renderable|Entity|Sprite|Collectable|Trigger|Draggable|DropTarget|NineSliceSprite|ImageLayer|ColorLayer|Light2d|UIBaseElement|UISpriteElement|UITextButton|Text|BitmapText} child2
      */
-    swapChildren(child: Renderable, child2: Renderable): void;
+    swapChildren(child: Renderable | Entity | Sprite | Collectable | Trigger | Draggable | DropTarget | NineSliceSprite | ImageLayer | ColorLayer | Light2d | UIBaseElement | UISpriteElement | UITextButton | Text | BitmapText, child2: Renderable | Entity | Sprite | Collectable | Trigger | Draggable | DropTarget | NineSliceSprite | ImageLayer | ColorLayer | Light2d | UIBaseElement | UISpriteElement | UITextButton | Text | BitmapText): void;
     /**
      * Returns the Child at the specified index
      * @param {number} index
@@ -139,22 +139,22 @@ export default class Container extends Renderable {
     getChildAt(index: number): Renderable;
     /**
      * Returns the index of the given Child
-     * @param {Renderable} child
+     * @param {Renderable|Entity|Sprite|Collectable|Trigger|Draggable|DropTarget|NineSliceSprite|ImageLayer|ColorLayer|Light2d|UIBaseElement|UISpriteElement|UITextButton|Text|BitmapText} child
      * @returns {number} index
      */
-    getChildIndex(child: Renderable): number;
+    getChildIndex(child: Renderable | Entity | Sprite | Collectable | Trigger | Draggable | DropTarget | NineSliceSprite | ImageLayer | ColorLayer | Light2d | UIBaseElement | UISpriteElement | UITextButton | Text | BitmapText): number;
     /**
      * Returns the next child within the container or undefined if none
-     * @param {Renderable} child
+     * @param {Renderable|Entity|Sprite|Collectable|Trigger|Draggable|DropTarget|NineSliceSprite|ImageLayer|ColorLayer|Light2d|UIBaseElement|UISpriteElement|UITextButton|Text|BitmapText} child
      * @returns {Renderable} child
      */
-    getNextChild(child: Renderable): Renderable;
+    getNextChild(child: Renderable | Entity | Sprite | Collectable | Trigger | Draggable | DropTarget | NineSliceSprite | ImageLayer | ColorLayer | Light2d | UIBaseElement | UISpriteElement | UITextButton | Text | BitmapText): Renderable;
     /**
      * Returns true if contains the specified Child
-     * @param {Renderable} child
+     * @param {Renderable|Entity|Sprite|Collectable|Trigger|Draggable|DropTarget|NineSliceSprite|ImageLayer|ColorLayer|Light2d|UIBaseElement|UISpriteElement|UITextButton|Text|BitmapText} child
      * @returns {boolean}
      */
-    hasChild(child: Renderable): boolean;
+    hasChild(child: Renderable | Entity | Sprite | Collectable | Trigger | Draggable | DropTarget | NineSliceSprite | ImageLayer | ColorLayer | Light2d | UIBaseElement | UISpriteElement | UITextButton | Text | BitmapText): boolean;
     /**
      * return the child corresponding to the given property and value.<br>
      * note : avoid calling this function every frame since
@@ -223,18 +223,18 @@ export default class Container extends Renderable {
     /**
      * Invokes the removeChildNow in a defer, to ensure the child is removed safely after the update & draw stack has completed. <br>
      * if the given child implements a onDeactivateEvent() method, that method will be called once the child is removed from this container.
-     * @param {Renderable} child
+     * @param {RendRenderable|Sprite|Collectable|Trigger|Draggable|DropTarget|NineSliceSprite|ImageLayer|ColorLayer|Light2d|UIBaseElement|UISpriteElement|UITextButton|Text|BitmapTexterable} child
      * @param {boolean} [keepalive=false] - true to prevent calling child.destroy()
      */
-    removeChild(child: Renderable, keepalive?: boolean | undefined): void;
+    removeChild(child: RendRenderable | Sprite | Collectable | Trigger | Draggable | DropTarget | NineSliceSprite | ImageLayer | ColorLayer | Light2d | UIBaseElement | UISpriteElement | UITextButton | Text | BitmapTexterable, keepalive?: boolean | undefined): void;
     /**
      * Removes (and optionally destroys) a child from the container.<br>
      * (removal is immediate and unconditional)<br>
      * Never use keepalive=true with objects from {@link pool}. Doing so will create a memory leak.
-     * @param {Renderable} child
+     * @param {Renderable|Entity|Sprite|Collectable|Trigger|Draggable|DropTarget|NineSliceSprite|ImageLayer|ColorLayer|Light2d|UIBaseElement|UISpriteElement|UITextButton|Text|BitmapText} child
      * @param {boolean} [keepalive=False] - True to prevent calling child.destroy()
      */
-    removeChildNow(child: Renderable, keepalive?: boolean | undefined): void;
+    removeChildNow(child: Renderable | Entity | Sprite | Collectable | Trigger | Draggable | DropTarget | NineSliceSprite | ImageLayer | ColorLayer | Light2d | UIBaseElement | UISpriteElement | UITextButton | Text | BitmapText, keepalive?: boolean | undefined): void;
     /**
      * Automatically set the specified property of all childs to the given value
      * @param {string} prop - property name
@@ -244,24 +244,24 @@ export default class Container extends Renderable {
     setChildsProperty(prop: string, value: object, recursive?: boolean | undefined): void;
     /**
      * Move the child in the group one step forward (z depth).
-     * @param {Renderable} child
+     * @param {Renderable|Entity|Sprite|Collectable|Trigger|Draggable|DropTarget|NineSliceSprite|ImageLayer|ColorLayer|Light2d|UIBaseElement|UISpriteElement|UITextButton|Text|BitmapText} child
      */
-    moveUp(child: Renderable): void;
+    moveUp(child: Renderable | Entity | Sprite | Collectable | Trigger | Draggable | DropTarget | NineSliceSprite | ImageLayer | ColorLayer | Light2d | UIBaseElement | UISpriteElement | UITextButton | Text | BitmapText): void;
     /**
      * Move the child in the group one step backward (z depth).
-     * @param {Renderable} child
+     * @param {Renderable|Entity|Sprite|Collectable|Trigger|Draggable|DropTarget|NineSliceSprite|ImageLayer|ColorLayer|Light2d|UIBaseElement|UISpriteElement|UITextButton|Text|BitmapText} child
      */
-    moveDown(child: Renderable): void;
+    moveDown(child: Renderable | Entity | Sprite | Collectable | Trigger | Draggable | DropTarget | NineSliceSprite | ImageLayer | ColorLayer | Light2d | UIBaseElement | UISpriteElement | UITextButton | Text | BitmapText): void;
     /**
      * Move the specified child to the top(z depth).
-     * @param {Renderable} child
+     * @param {Renderable|Entity|Sprite|Collectable|Trigger|Draggable|DropTarget|NineSliceSprite|ImageLayer|ColorLayer|Light2d|UIBaseElement|UISpriteElement|UITextButton|Text|BitmapText} child
      */
-    moveToTop(child: Renderable): void;
+    moveToTop(child: Renderable | Entity | Sprite | Collectable | Trigger | Draggable | DropTarget | NineSliceSprite | ImageLayer | ColorLayer | Light2d | UIBaseElement | UISpriteElement | UITextButton | Text | BitmapText): void;
     /**
      * Move the specified child the bottom (z depth).
-     * @param {Renderable} child
+     * @param {Renderable|Entity|Sprite|Collectable|Trigger|Draggable|DropTarget|NineSliceSprite|ImageLayer|ColorLayer|Light2d|UIBaseElement|UISpriteElement|UITextButton|Text|BitmapText} child
      */
-    moveToBottom(child: Renderable): void;
+    moveToBottom(child: Renderable | Entity | Sprite | Collectable | Trigger | Draggable | DropTarget | NineSliceSprite | ImageLayer | ColorLayer | Light2d | UIBaseElement | UISpriteElement | UITextButton | Text | BitmapText): void;
     /**
      * Manually trigger the sort of all the childs in the container</p>
      * @param {boolean} [recursive=false] - recursively sort all containers if true

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

@@ -0,0 +1,53 @@
+/**
+ * @classdesc
+ * A Draggable base object
+ * @see DropTarget
+ * @augments Renderable
+ */
+export class Draggable extends Renderable {
+    dragging: boolean;
+    dragId: any;
+    grabOffset: Vector2d;
+    /**
+     * Initializes the events the modules needs to listen to
+     * It translates the pointer events to me.events
+     * in order to make them pass through the system and to make
+     * this module testable. Then we subscribe this module to the
+     * transformed events.
+     * @name initEvents
+     * @memberof Draggable
+     * @private
+     */
+    private initEvents;
+    /**
+     * Gets called when the user starts dragging the entity
+     * @name dragStart
+     * @memberof Draggable
+     * @param {object} e - the pointer event
+     * @returns {boolean} false if the object is being dragged
+     */
+    dragStart(e: object): boolean;
+    /**
+     * Gets called when the user drags this entity around
+     * @name dragMove
+     * @memberof Draggable
+     * @param {object} e - the pointer event
+     */
+    dragMove(e: object): void;
+    /**
+     * Gets called when the user stops dragging the entity
+     * @name dragEnd
+     * @memberof Draggable
+     * @returns {boolean} false if the object stopped being dragged
+     */
+    dragEnd(): boolean;
+    /**
+     * Destructor
+     * @name destroy
+     * @memberof Draggable
+     * @ignore
+     */
+    destroy(): void;
+}
+import Renderable from "./../renderable/renderable.js";
+import Vector2d from "./../math/vector2.js";

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

@@ -1,54 +1,3 @@
-/**
- * @classdesc
- * A Draggable base object
- * @see DropTarget
- * @augments Renderable
- */
-export class Draggable extends Renderable {
-    dragging: boolean;
-    dragId: any;
-    grabOffset: Vector2d;
-    /**
-     * Initializes the events the modules needs to listen to
-     * It translates the pointer events to me.events
-     * in order to make them pass through the system and to make
-     * this module testable. Then we subscribe this module to the
-     * transformed events.
-     * @name initEvents
-     * @memberof Draggable
-     * @private
-     */
-    private initEvents;
-    /**
-     * Gets called when the user starts dragging the entity
-     * @name dragStart
-     * @memberof Draggable
-     * @param {object} e - the pointer event
-     * @returns {boolean} false if the object is being dragged
-     */
-    dragStart(e: object): boolean;
-    /**
-     * Gets called when the user drags this entity around
-     * @name dragMove
-     * @memberof Draggable
-     * @param {object} e - the pointer event
-     */
-    dragMove(e: object): void;
-    /**
-     * Gets called when the user stops dragging the entity
-     * @name dragEnd
-     * @memberof Draggable
-     * @returns {boolean} false if the object stopped being dragged
-     */
-    dragEnd(): boolean;
-    /**
-     * Destructor
-     * @name destroy
-     * @memberof Draggable
-     * @ignore
-     */
-    destroy(): void;
-}
 /**
  * @classdesc
  * a base drop target object
@@ -115,4 +64,3 @@ export class DropTarget extends Renderable {
     destroy(): void;
 }
 import Renderable from "./../renderable/renderable.js";
-import Vector2d from "./../math/vector2.js";

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

@@ -380,7 +380,7 @@ export default class Renderable extends Rect {
      * onCollision callback, triggered in case of collision,
      * when this renderable body is colliding with another one
      * @param {ResponseObject} response - the collision response object
-     * @param {Renderable} other - the other renderable touching this one (a reference to response.a or response.b)
+     * @param {Renderable|Container|Entity|Sprite|NineSliceSprite} other - the other renderable touching this one (a reference to response.a or response.b)
      * @returns {boolean} true if the object should respond to the collision (its position and velocity will be corrected)
      * @example
      * // colision handler
@@ -396,7 +396,7 @@ export default class Renderable extends Rect {
      *     return true;
      * },
      */
-    onCollision(response: ResponseObject, other: Renderable): boolean;
+    onCollision(response: ResponseObject, other: Renderable | Container | Entity | Sprite | NineSliceSprite): boolean;
     /**
      * Destroy function<br>
      * @ignore

package/dist/types/utils/utils.d.ts

@@ -1,17 +1,56 @@
-export default utils;
-declare namespace utils {
-    export { agentUtils as agent };
-    export { arrayUtils as array };
-    export { fileUtils as file };
-    export { stringUtils as string };
-    export { fnUtils as function };
-    export function checkVersion(first: string, second: string): number;
-    export function getUriFragment(url?: string | undefined): object;
-    export function resetGUID(base: any, index?: number): void;
-    export function createGUID(index?: number): string;
-}
-import * as agentUtils from "./agent.js";
-import * as arrayUtils from "./array.js";
-import * as fileUtils from "./file.js";
-import * as stringUtils from "./string.js";
-import * as fnUtils from "./function.js";
+/**
+ * Compare two version strings
+ * @public
+ * @memberof utils
+ * @name checkVersion
+ * @param {string} first - First version string to compare
+ * @param {string} second - second version string to compare
+ * @returns {number} comparison result <br>&lt; 0 : first &lt; second<br>
+ * 0 : first == second<br>
+ * &gt; 0 : first &gt; second
+ * @example
+ * if (me.utils.checkVersion("7.0.0") > 0) {
+ *     console.error(
+ *         "melonJS is too old. Expected: 7.0.0, Got: 6.3.0"
+ *     );
+ * }
+ */
+export function checkVersion(first: string, second: string): number;
+/**
+ * parse the fragment (hash) from a URL and returns them into
+ * @public
+ * @memberof utils
+ * @name getUriFragment
+ * @param {string} [url=document.location] - an optional params string or URL containing fragment (hash) params to be parsed
+ * @returns {object} an object representing the deserialized params string.
+ * @property {boolean} [hitbox=false] draw the hitbox in the debug panel (if enabled)
+ * @property {boolean} [velocity=false] draw the entities velocity in the debug panel (if enabled)
+ * @property {boolean} [quadtree=false] draw the quadtree in the debug panel (if enabled)
+ * @property {boolean} [webgl=false] force the renderer to WebGL
+ * @property {boolean} [debug=false] display the debug panel (if preloaded)
+ * @property {string} [debugToggleKey="s"] show/hide the debug panel (if preloaded)
+ * @example
+ * // http://www.example.com/index.html#debug&hitbox=true&mytag=value
+ * let UriFragment = me.utils.getUriFragment();
+ * console.log(UriFragment["mytag"]); //> "value"
+ */
+export function getUriFragment(url?: string | undefined): object;
+/**
+ * reset the GUID Base Name
+ * the idea here being to have a unique ID
+ * per level / object
+ * @ignore
+ */
+export function resetGUID(base: any, index?: number): void;
+/**
+ * create and return a very simple GUID
+ * Game Unique ID
+ * @ignore
+ */
+export function createGUID(index?: number): string;
+export * as agent from "./agent.js";
+export * as array from "./array.js";
+export * as file from "./file.js";
+export * as string from "./string.js";
+export * as _function from "./function.js";
+export { _function as function };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "melonjs",
-  "version": "15.1.5",
+  "version": "15.2.0",
   "description": "melonJS Game Engine",
   "homepage": "http://www.melonjs.org/",
   "type": "module",
@@ -53,7 +53,7 @@
   ],
   "dependencies": {
     "@teppeis/multimaps": "^3.0.0",
-    "core-js": "^3.30.1",
+    "core-js": "^3.30.2",
     "earcut": "2.2.4",
     "eventemitter3": "^5.0.1",
     "howler": "2.2.3"
@@ -68,21 +68,21 @@
     "@rollup/plugin-node-resolve": "^15.0.2",
     "@rollup/plugin-replace": "^5.0.2",
     "@webdoc/cli": "^2.2.0",
-    "chromedriver": "^112.0.1",
+    "chromedriver": "^113.0.0",
     "cross-env": "^7.0.3",
     "del-cli": "^5.0.0",
-    "eslint": "^8.39.0",
-    "eslint-plugin-jsdoc": "^43.1.1",
+    "eslint": "^8.40.0",
+    "eslint-plugin-jsdoc": "^44.2.3",
     "expect": "^29.5.0",
     "expect-mocha-image-snapshot": "^3.0.13",
     "fastify": "^4.17.0",
     "mocha": "^10.2.0",
     "npm-self-link": "^1.1.7",
-    "puppeteer": "^20.1.0",
-    "rollup": "^3.21.5",
+    "puppeteer": "^20.2.0",
+    "rollup": "^3.21.6",
     "rollup-plugin-bundle-size": "^1.0.3",
     "rollup-plugin-string": "^3.0.0",
-    "terser": "^5.17.1",
+    "terser": "^5.17.3",
     "typescript": "^5.0.4"
   },
   "scripts": {

package/src/application/application.js

@@ -2,7 +2,7 @@ import { autoDetectRenderer } from "../video/utils/autodetect.js";
 import CanvasRenderer from "./../video/canvas/canvas_renderer.js";
 import * as device from "./../system/device.js";
 import * as event from "./../system/event.js";
-import utils from "./../utils/utils.js";
+import { getUriFragment } from "./../utils/utils.js";
 import timer from "./../system/timer.js";
 import state from "./../state/state.js";
 import World from "./../physics/world.js";
@@ -149,7 +149,7 @@ import { CANVAS, WEBGL, AUTO } from "../const.js";
         }
 
         // override renderer settings if &webgl or &canvas is defined in the URL
-        let uriFragment = utils.getUriFragment();
+        let uriFragment = getUriFragment();
         if (uriFragment.webgl === true || uriFragment.webgl1 === true || uriFragment.webgl2 === true) {
             this.settings.renderer = WEBGL;
             if (uriFragment.webgl1 === true) {

package/src/camera/camera2d.js

@@ -574,7 +574,7 @@ let targetV = new Vector2d();
      * set the camera position around the specified object
      * @name focusOn
      * @memberof Camera2d
-     * @param {Renderable} target - the renderable to focus the camera on
+     * @param {Renderable|Entity|Sprite|NineSliceSprite} target - the renderable to focus the camera on
      */
     focusOn(target) {
         let bounds = target.getBounds();
@@ -588,7 +588,7 @@ let targetV = new Vector2d();
      * check if the specified renderable is in the camera
      * @name isVisible
      * @memberof Camera2d
-     * @param {Renderable} obj - to be checked against
+     * @param {Renderable|Entity|Sprite|NineSliceSprite} obj - to be checked against
      * @param {boolean} [floating = obj.floating] - if visibility check should be done against screen coordinates
      * @returns {boolean}
      */