melonjs 15.1.4 → 15.1.6

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

@@ -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/loader/loader.d.ts

@@ -2,8 +2,9 @@
  * an asset definition to be used with the loader
  * @typedef {object} loader.Asset
  * @property {string} name - name of the asset
- * @property {string} type  - the type of the asset : "audio", binary", "image", "json","js", "tmx", "tsx", "fontface"
- * @property {string} src  - path and/or file name of the resource (for audio assets only the path is required)
+ * @property {string} type  - the type of the asset : "audio", binary", "image", "json", "js", "tmx", "tmj", "tsx", "tsj", "fontface"
+ * @property {string} [src]  - path and/or file name of the resource (for audio assets only the path is required)
+ * @property {string} [data]  - TMX data if not provided through a src url
  * @property {boolean} [stream] - Set to true to force HTML5 Audio, which allows not to wait for large file to be downloaded before playing.
  * @see loader.preload
  * @see loader.load
@@ -145,13 +146,17 @@ export namespace loader {
          */
         name: string;
         /**
-         * - the type of the asset : "audio", binary", "image", "json","js", "tmx", "tsx", "fontface"
+         * - the type of the asset : "audio", binary", "image", "json", "js", "tmx", "tmj", "tsx", "tsj", "fontface"
          */
         type: string;
         /**
          * - path and/or file name of the resource (for audio assets only the path is required)
          */
-        src: string;
+        src?: string | undefined;
+        /**
+         * - TMX data if not provided through a src url
+         */
+        data?: string | undefined;
         /**
          * - Set to true to force HTML5 Audio, which allows not to wait for large file to be downloaded before playing.
          */

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/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

@@ -205,7 +205,7 @@ export default class Renderable extends Rect {
     };
     _inViewport: boolean;
     /**
-     * Whether the renderable object is floating, or contained in a floating container
+     * Whether the renderable object is floating (i.e. used screen coordinates), or contained in a floating parent container
      * @see Renderable#floating
      * @type {boolean}
      */
@@ -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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "melonjs",
-  "version": "15.1.4",
+  "version": "15.1.6",
   "description": "melonJS Game Engine",
   "homepage": "http://www.melonjs.org/",
   "type": "module",
@@ -53,13 +53,13 @@
   ],
   "dependencies": {
     "@teppeis/multimaps": "^3.0.0",
-    "core-js": "^3.30.1",
+    "core-js": "^3.30.2",
     "earcut": "2.2.4",
-    "eventemitter3": "^5.0.0",
+    "eventemitter3": "^5.0.1",
     "howler": "2.2.3"
   },
   "devDependencies": {
-    "@babel/eslint-parser": "^7.21.3",
+    "@babel/eslint-parser": "^7.21.8",
     "@babel/plugin-syntax-import-assertions": "^7.20.0",
     "@fastify/static": "^6.10.1",
     "@melonjs/webdoc-theme": "^1.1.1",
@@ -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.0",
+    "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.1.0",
     "expect": "^29.5.0",
     "expect-mocha-image-snapshot": "^3.0.13",
-    "fastify": "^4.16.3",
+    "fastify": "^4.17.0",
     "mocha": "^10.2.0",
     "npm-self-link": "^1.1.7",
-    "puppeteer": "^19.11.1",
-    "rollup": "^3.21.0",
+    "puppeteer": "^20.1.2",
+    "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/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}
      */

package/src/entity/entity.js

@@ -180,11 +180,8 @@ import Body from "./../physics/body.js";
         }
 
         if (absolute === true) {
-            bounds.centerOn(this.pos.x + bounds.x + bounds.width / 2,  this.pos.y + bounds.y + bounds.height / 2);
-             if (typeof this.ancestor !== "undefined" && typeof this.ancestor.addChild === "function" && this.floating !== true) {
-                 bounds.translate(this.ancestor.getAbsolutePosition());
-             }
-
+            var absPos = this.getAbsolutePosition();
+            bounds.centerOn(absPos.x + bounds.x + bounds.width / 2,  absPos.y + bounds.y + bounds.height / 2);
         }
 
         return bounds;

package/src/geometries/path2d.js

@@ -235,10 +235,10 @@ import earcut from "earcut";
         const cos_rotation = Math.cos(rotation);
         const sin_rotation = Math.sin(rotation);
         for (let j = 0; j < nr_of_interpolation_points; j++) {
-            let _x1 = radiusX * Math.cos(angle);
-            let _y1 = radiusY * Math.sin(angle);
-            let _x2 = x + _x1 * cos_rotation - _y1 * sin_rotation;
-            let _y2 = y + _x1 * sin_rotation + _y1 * cos_rotation;
+            const _x1 = radiusX * Math.cos(angle);
+            const _y1 = radiusY * Math.sin(angle);
+            const _x2 = x + _x1 * cos_rotation - _y1 * sin_rotation;
+            const _y2 = y + _x1 * sin_rotation + _y1 * cos_rotation;
             points.push(pool.pull("Point", _x2, _y2));
             angle += direction * dangle;
         }

package/src/geometries/poly.js

@@ -432,8 +432,8 @@ import pool from "./../system/pooling.js";
 
         //http://www.ecse.rpi.edu/Homepages/wrf/Research/Short_Notes/pnpoly.html
         for (let i = 0, j = len - 1; i < len; j = i++) {
-            let iy = points[i].y + posy, ix = points[i].x + posx,
-                jy = points[j].y + posy, jx = points[j].x + posx;
+            const iy = points[i].y + posy, ix = points[i].x + posx,
+                  jy = points[j].y + posy, jx = points[j].x + posx;
             if (((iy > _y) !== (jy > _y)) && (_x < (jx - ix) * (_y - iy) / (jy - iy) + ix)) {
                 intersects = !intersects;
             }

package/src/index.js

@@ -42,7 +42,8 @@ import Light2d from "./renderable/light2d.js";
 import Text from "./text/text.js";
 import BitmapText from "./text/bitmaptext.js";
 import BitmapTextData from "./text/bitmaptextdata.js";
-import { Draggable, DropTarget } 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";
 import TMXIsometricRenderer from "./level/tiled/renderer/TMXIsometricRenderer.js";

package/src/input/pointerevent.js

@@ -210,7 +210,7 @@ function enablePointerEvent() {
  */
 function findActiveEvent(activeEventList, eventTypes) {
     for (let i = 0; i < eventTypes.length; i++) {
-        let event = activeEventList.indexOf(eventTypes[i]);
+        const event = activeEventList.indexOf(eventTypes[i]);
         if (event !== -1) {
             return eventTypes[i];
         }
@@ -223,7 +223,7 @@ function findActiveEvent(activeEventList, eventTypes) {
 function findAllActiveEvents(activeEventList, eventTypes) {
     let events = [];
     for (let i = 0; i < eventTypes.length; i++) {
-        let event = activeEventList.indexOf(eventTypes[i]);
+        const event = activeEventList.indexOf(eventTypes[i]);
         if (event !== -1) {
             events.push(eventTypes[i]);
         }
@@ -293,10 +293,10 @@ function dispatchEvent(normalizedEvents) {
 
         for (let c = candidates.length, candidate; c--, (candidate = candidates[c]);) {
             if (eventHandlers.has(candidate) && (candidate.isKinematic !== true)) {
-                let handlers = eventHandlers.get(candidate);
-                let region = handlers.region;
-                let ancestor = region.ancestor;
-                let bounds = region.getBounds();
+                const handlers = eventHandlers.get(candidate);
+                const region = handlers.region;
+                const ancestor = region.ancestor;
+                const bounds = region.getBounds();
                 let eventInBounds = false;
 
                 if (region.isFloating === true) {
@@ -404,7 +404,7 @@ function normalizeEvent(originalEvent) {
     if (device.touchEvent && originalEvent.changedTouches) {
         // iOS/Android Touch event
         for (let i = 0, l = originalEvent.changedTouches.length; i < l; i++) {
-            let touchEvent = originalEvent.changedTouches[i];
+            const touchEvent = originalEvent.changedTouches[i];
             _pointer = T_POINTERS.pop();
             _pointer.setEvent(
                 originalEvent,
@@ -682,7 +682,7 @@ export function registerPointerEvent(eventType, region, callback) {
     // allocate array if not defined
     let handlers = eventHandlers.get(region);
     for (let i = 0; i < eventTypes.length; i++) {
-        eventType = eventTypes[i];
+        const eventType = eventTypes[i];
         if (handlers.callbacks[eventType]) {
             handlers.callbacks[eventType].push(callback);
         } else {
@@ -715,7 +715,7 @@ export function releasePointerEvent(eventType, region, callback) {
     let handlers = eventHandlers.get(region);
     if (typeof (handlers) !== "undefined") {
         for (let i = 0; i < eventTypes.length; i++) {
-            eventType = eventTypes[i];
+            const eventType = eventTypes[i];
             if (handlers.callbacks[eventType]) {
                 if (typeof (callback) !== "undefined") {
                     remove(handlers.callbacks[eventType], callback);