melonjs 15.1.6 → 15.2.0

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";

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/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.6",
+  "version": "15.2.0",
   "description": "melonJS Game Engine",
   "homepage": "http://www.melonjs.org/",
   "type": "module",
@@ -72,13 +72,13 @@
     "cross-env": "^7.0.3",
     "del-cli": "^5.0.0",
     "eslint": "^8.40.0",
-    "eslint-plugin-jsdoc": "^44.1.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.2",
+    "puppeteer": "^20.2.0",
     "rollup": "^3.21.6",
     "rollup-plugin-bundle-size": "^1.0.3",
     "rollup-plugin-string": "^3.0.0",

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/index.js

@@ -72,9 +72,10 @@ import * as event from "./system/event.js";
 import * as device from "./system/device.js";
 import * as loader from "./loader/loader.js";
 import * as Math from "./math/math.js";
-import utils from "./utils/utils.js";
+import * as utils from "./utils/utils.js";
 import * as input from "./input/input.js";
-import { plugin, plugins } from "./plugin/plugin.js";
+import * as plugin from "./plugin/plugin.js";
+import { cache as plugins } from "./plugin/plugin.js";
 import * as video from "./video/video.js";
 import save from "./system/save.js";
 import timer from "./system/timer.js";

package/src/level/level.js

@@ -1,4 +1,5 @@
-import utils from "./../utils/utils.js";
+import { resetGUID } from "./../utils/utils.js";
+import { defer } from "../utils/function.js";
 import * as event from "./../system/event.js";
 import state from "./../state/state.js";
 import { getTMX } from "./../loader/loader.js";
@@ -62,7 +63,7 @@ function loadTMXLevel(levelId, container, flatten, setViewportBounds) {
 
     // reset the GUID generator
     // and pass the level id as parameter
-    utils.resetGUID(levelId, level.nextobjectid);
+    resetGUID(levelId, level.nextobjectid);
 
     // Tiled use 0,0 anchor coordinates
     container.anchorPoint.set(0, 0);
@@ -178,7 +179,7 @@ let level = {
                 // some silly side effects
                 state.stop();
 
-                utils.function.defer(safeLoadLevel, this, levelId, options, true);
+                defer(safeLoadLevel, this, levelId, options, true);
             }
             else {
                 safeLoadLevel(levelId, options);

package/src/level/tiled/TMXTileMap.js

@@ -1,7 +1,7 @@
 import pool from "./../../system/pooling.js";
 import * as event from "./../../system/event.js";
 import { game } from "../../index.js";
-import utils from "./../../utils/utils.js";
+import { checkVersion } from "./../../utils/utils.js";
 import collision from "./../../physics/collision.js";
 import Body from "./../../physics/body.js";
 import TMXTileset from "./TMXTileset.js";
@@ -198,7 +198,7 @@ function readObjectGroup(map, data, z) {
         // if version is undefined or empty it usually means the map was not created with Tiled
         if (this.version !== "undefined" && this.version !== "") {
             // deprecation warning if map tiled version is older than 1.5
-            if (utils.checkVersion(this.version, "1.5") < 0) {
+            if (checkVersion(this.version, "1.5") < 0) {
                 warning("("+this.name+") Tiled Map format version 1.4 and below", "format 1.5 or higher", "10.4.4");
             }
         }

package/src/level/tiled/TMXUtils.js

@@ -1,4 +1,5 @@
-import utils from "../../utils/utils.js";
+import { isBoolean, isNumeric } from "../../utils/string.js";
+import * as utils from "../../utils/utils.js";
 
 /**
  * set and interpret a TMX property value
@@ -25,11 +26,11 @@ function setTMXValue(name, type, value) {
 
         default :
             // try to parse it anyway
-            if (!value || utils.string.isBoolean(value)) {
+            if (!value || isBoolean(value)) {
                 // if value not defined or boolean
                 value = value ? (value === "true") : true;
             }
-            else if (utils.string.isNumeric(value)) {
+            else if (isNumeric(value)) {
                 // check if numeric
                 value = Number(value);
             }

package/src/plugin/plugin.js

@@ -1,132 +1,130 @@
-import utils from "./../utils/utils.js";
+import { checkVersion } from "./../utils/utils.js";
 import { version } from "./../index.js";
 
 /**
- * This namespace is a container for all registered plugins.
- * @see plugin.register
- * @namespace plugins
+ * Contains all registered plugins.
+ * @name cache
+ * @memberof plugin
  */
-export let plugins = {};
+export let cache = {};
 
+/**
+ * @namespace plugin
+ */
 
-class BasePlugin {
+/**
+ * a base Object class for plugin
+ * (plugin must be installed using the register function)
+ * @class
+ * @name BasePlugin
+ * @memberof plugin
+ */
+export class BasePlugin {
 
     constructor() {
         /**
          * define the minimum required version of melonJS<br>
          * this can be overridden by the plugin
-         * @public
          * @type {string}
          * @default "__VERSION__"
-         * @name plugin.Base#version
          */
         this.version = "__VERSION__";
     }
 }
 
+
 /**
- * @namespace plugin
+ * @class
+ * @name Base
+ * @memberof plugin
+ * @deprecated since 15.1.6, see {@link plugin.BasePlugin}
  */
-export let plugin = {
-
-    /**
-     * a base Object for plugin <br>
-     * plugin must be installed using the register function
-     * @see plugin
-     * @class
-     * @name Base
-     * @memberof plugin
-     */
-    Base : BasePlugin,
-
-    /**
-     * patch a melonJS function
-     * @name patch
-     * @memberof plugin
-     * @public
-     * @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();
-     * });
-     */
-    patch : function (proto, name, fn) {
-        // use the object prototype if possible
-        if (typeof proto.prototype !== "undefined") {
-            proto = proto.prototype;
-        }
-        // reuse the logic behind object extends
-        if (typeof(proto[name]) === "function") {
-            // save the original function
-            let _parent = proto[name];
-            // override the function with the new one
-            Object.defineProperty(proto, name, {
-                "configurable" : true,
-                "value" : (function (name, fn) {
-                    return function () {
-                        this._patched = _parent;
-                        let ret = fn.apply(this, arguments);
-                        this._patched = null;
-                        return ret;
-                    };
-                })(name, fn)
-            });
-        }
-        else {
-            throw new Error(name + " is not an existing function");
-        }
-    },
+export class Base extends BasePlugin {}
 
-    /**
-     * Register a plugin.
-     * @name register
-     * @memberof plugin
-     * @see Base
-     * @public
-     * @param {plugin.Base} pluginObj - Plugin object to instantiate and register
-     * @param {string} [name=pluginObj.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 ();
-     */
-    register : function (pluginObj, name = pluginObj.toString().match(/ (\w+)/)[1]) {
-        // ensure me.plugins[name] is not already "used"
-        if (plugins[name]) {
-            throw new Error("plugin " + name + " already registered");
-        }
+/**
+ * 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 function patch(proto, name, fn) {
+    // use the object prototype if possible
+    if (typeof proto.prototype !== "undefined") {
+        proto = proto.prototype;
+    }
+    // reuse the logic behind object extends
+    if (typeof(proto[name]) === "function") {
+        // save the original function
+        let _parent = proto[name];
+        // override the function with the new one
+        Object.defineProperty(proto, name, {
+            "configurable" : true,
+            "value" : (function (name, fn) {
+                return function () {
+                    this._patched = _parent;
+                    let ret = fn.apply(this, arguments);
+                    this._patched = null;
+                    return ret;
+                };
+            })(name, fn)
+        });
+    }
+    else {
+        throw new Error(name + " is not an existing function");
+    }
+}
 
-        // get extra arguments
-        let _args = [];
-        if (arguments.length > 2) {
-            // store extra arguments if any
-            _args = Array.prototype.slice.call(arguments, 1);
-        }
+/**
+ * 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, name = plugin.toString().match(/ (\w+)/)[1]) {
+    // ensure me.plugins[name] is not already "used"
+    if (cache[name]) {
+        throw new Error("plugin " + name + " already registered");
+    }
 
-        // try to instantiate the plugin
-        _args[0] = pluginObj;
-        let instance = new (pluginObj.bind.apply(pluginObj, _args))();
+    // get extra arguments
+    let _args = [];
+    if (arguments.length > 2) {
+        // store extra arguments if any
+        _args = Array.prototype.slice.call(arguments, 1);
+    }
 
-        // inheritance check
-        if (typeof instance === "undefined" || !(instance instanceof plugin.Base)) {
-            throw new Error("Plugin should extend the me.plugin.Base Class !");
-        }
+    // try to instantiate the plugin
+    _args[0] = plugin;
+    let instance = new (plugin.bind.apply(plugin, _args))();
 
-        // compatibility testing
-        if (utils.checkVersion(instance.version, version) > 0) {
-            throw new Error("Plugin version mismatch, expected: " + instance.version + ", got: " + version);
-        }
+    // inheritance check
+    if (typeof instance === "undefined" || !(instance instanceof BasePlugin)) {
+        throw new Error("Plugin should extend the BasePlugin Class !");
+    }
 
-        // create a reference to the new plugin
-        plugins[name] = instance;
+    // compatibility testing
+    if (checkVersion(instance.version, version) > 0) {
+        throw new Error("Plugin version mismatch, expected: " + instance.version + ", got: " + version);
     }
-};
+
+    // create a reference to the new plugin
+    cache[name] = instance;
+}

package/src/renderable/container.js

@@ -1,5 +1,6 @@
 import Renderable from "./renderable";
-import utils from "../utils/utils.js";
+import { createGUID } from "../utils/utils";
+import { defer } from "../utils/function";
 import { game } from "../index.js";
 import * as event from "../system/event.js";
 import pool from "../system/pooling.js";
@@ -189,7 +190,7 @@ let globalFloatingCounter = 0;
             // (e.g. move one child from one container to another)
             if (child.isRenderable) {
                 // allocated a GUID value (use child.id as based index if defined)
-                child.GUID = utils.createGUID(child.id);
+                child.GUID = createGUID(child.id);
             }
         }
 
@@ -272,7 +273,7 @@ let globalFloatingCounter = 0;
                 // (e.g. move one child from one container to another)
                 if (child.isRenderable) {
                     // allocated a GUID value
-                    child.GUID = utils.createGUID();
+                    child.GUID = createGUID();
                 }
             }
 
@@ -643,7 +644,7 @@ let globalFloatingCounter = 0;
      */
     removeChild(child, keepalive) {
         if (this.hasChild(child)) {
-            utils.function.defer(deferredRemove, this, child, keepalive);
+            defer(deferredRemove, this, child, keepalive);
         }
         else {
             throw new Error("Child is not mine.");
@@ -794,7 +795,7 @@ let globalFloatingCounter = 0;
                 });
             }
             /** @ignore */
-            this.pendingSort = utils.function.defer(function () {
+            this.pendingSort = defer(function () {
                 // sort everything in this container
                 this.getChildren().sort(this["_sort" + this.sortOn.toUpperCase()]);
                 // clear the defer id

package/src/system/timer.js

@@ -1,4 +1,4 @@
-import utils from "./../utils/utils.js";
+import { defer } from "./../utils/function.js";
 import * as event from "./event.js";
 import state from "./../state/state.js";
 import { clamp } from "./../math/math.js";
@@ -161,7 +161,7 @@ class Timer {
      */
     clearTimeout(timeoutID) {
         if (timeoutID > 0) {
-            utils.function.defer(this.clearTimer.bind(this), this, timeoutID);
+            defer(this.clearTimer.bind(this), this, timeoutID);
         }
     }
 
@@ -171,7 +171,7 @@ class Timer {
      */
     clearInterval(intervalID) {
         if (intervalID > 0) {
-            utils.function.defer(this.clearTimer.bind(this), this, intervalID);
+            defer(this.clearTimer.bind(this), this, intervalID);
         }
     }