melonjs 15.1.6 → 15.2.1

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);
         }
     }
 

package/src/utils/utils.js

@@ -1,8 +1,10 @@
-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";
+import { toHex } from "./string.js";
+
+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";
 
 /**
  * a collection of utility functions
@@ -13,124 +15,113 @@ import * as fnUtils from "./function.js";
 let GUID_base  = "";
 let GUID_index = 0;
 
-let utils = {
-
-    agent : agentUtils,
-    array : arrayUtils,
-    file : fileUtils,
-    string : stringUtils,
-    function : fnUtils,
-
-    /**
-     * 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"
-     *     );
-     * }
-     */
-    checkVersion : function (first, second) {
-        let a = first.split(".");
-        let b = second.split(".");
-        let len = Math.min(a.length, b.length);
-        let result = 0;
+/**
+ * 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, second) {
+    let a = first.split(".");
+    let b = second.split(".");
+    let len = Math.min(a.length, b.length);
+    let result = 0;
 
-        for (let i = 0; i < len; i++) {
-            if ((result = +a[i] - +b[i])) {
-                break;
-            }
+    for (let i = 0; i < len; i++) {
+        if ((result = +a[i] - +b[i])) {
+            break;
         }
+    }
 
-        return result ? result : a.length - b.length;
-    },
+    return result ? result : a.length - b.length;
+}
 
-    /**
-     * 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"
-     */
-    getUriFragment : function (url) {
-        let hash = {};
+/**
+ * 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) {
+    let hash = {};
 
-        if (typeof url === "undefined") {
-            if (typeof globalThis.document !== "undefined") {
-                let location = globalThis.document.location;
+    if (typeof url === "undefined") {
+        if (typeof globalThis.document !== "undefined") {
+            let location = globalThis.document.location;
 
-                if (location && location.hash) {
-                    url = location.hash;
-                } else {
-                    // No "document.location" exist for Wechat mini game platform.
-                    return hash;
-                }
+            if (location && location.hash) {
+                url = location.hash;
             } else {
-                // "document" undefined on node.js
+                // No "document.location" exist for Wechat mini game platform.
                 return hash;
             }
         } else {
-            // never cache if a url is passed as parameter
-            let index = url.indexOf("#");
-            if (index !== -1) {
-                url = url.slice(index, url.length);
-            } else {
-                return hash;
-            }
+            // "document" undefined on node.js
+            return hash;
         }
+    } else {
+        // never cache if a url is passed as parameter
+        let index = url.indexOf("#");
+        if (index !== -1) {
+            url = url.slice(index, url.length);
+        } else {
+            return hash;
+        }
+    }
 
-        // parse the url
-        url.slice(1).split("&").filter((value) => value !== "").forEach((value) => {
-            let kv = value.split("=");
-            let k = kv.shift();
-            let v = kv.join("=");
-            hash[k] = v || true;
-        });
-
-        return hash;
-    },
+    // parse the url
+    url.slice(1).split("&").filter((value) => value !== "").forEach((value) => {
+        let kv = value.split("=");
+        let k = kv.shift();
+        let v = kv.join("=");
+        hash[k] = v || true;
+    });
 
-    /**
-     * reset the GUID Base Name
-     * the idea here being to have a unique ID
-     * per level / object
-     * @ignore
-     */
-    resetGUID : function (base, index = 0) {
-        // also ensure it's only 8bit ASCII characters
-        GUID_base  = stringUtils.toHex(base.toString().toUpperCase());
-        GUID_index = index;
-    },
+    return hash;
+}
 
-    /**
-     * create and return a very simple GUID
-     * Game Unique ID
-     * @ignore
-     */
-    createGUID : function (index = 1) {
-        // to cover the case of undefined id for groups
-        GUID_index += index;
-        return GUID_base + "-" + (index || GUID_index);
-    }
-};
+/**
+ * reset the GUID Base Name
+ * the idea here being to have a unique ID
+ * per level / object
+ * @ignore
+ */
+export function resetGUID(base, index = 0) {
+    // also ensure it's only 8bit ASCII characters
+    GUID_base  = toHex(base.toString().toUpperCase());
+    GUID_index = index;
+}
 
-export default utils;
+/**
+ * create and return a very simple GUID
+ * Game Unique ID
+ * @ignore
+ */
+export function createGUID(index = 1) {
+    // to cover the case of undefined id for groups
+    GUID_index += index;
+    return GUID_base + "-" + (index || GUID_index);
+}

package/src/video/video.js

@@ -1,34 +1,32 @@
 import * as event from "./../system/event.js";
 import { initialized, game } from "./../index.js";
 import * as device from "./../system/device.js";
-import utils from "./../utils/utils.js";
-import * as vc from "../const";
+import { throttle } from "../utils/function.js";
 
 /**
  * @namespace video
  */
 
-
 /**
  * Select the HTML5 Canvas renderer
  * @memberof video
  * @static
  */
-export const CANVAS = vc.CANVAS;
+export { CANVAS } from "../const";
 
 /**
  * Select the WebGL renderer
  * @memberof video
  * @static
  */
-export const WEBGL = vc.WEBGL;
+export { WEBGL } from "../const";
 
 /**
  * Auto-select the renderer (Attempt WebGL first, with fallback to Canvas)
  * @memberof video
  * @static
  */
-export const AUTO = vc.AUTO;
+export { AUTO } from "../const";
 
 /**
  * A reference to the active Canvas or WebGL active renderer renderer
@@ -98,7 +96,7 @@ export function init(width, height, options) {
     //add a channel for the onresize/onorientationchange event
     globalThis.addEventListener(
         "resize",
-        utils.function.throttle(
+        throttle(
             (e) => {
                 event.emit(event.WINDOW_ONRESIZE, e);
             }, 100
@@ -130,7 +128,7 @@ export function init(width, height, options) {
     }
 
     // Automatically update relative canvas position on scroll
-    globalThis.addEventListener("scroll", utils.function.throttle((e) => {
+    globalThis.addEventListener("scroll", throttle((e) => {
         event.emit(event.WINDOW_ONSCROLL, e);
     }, 100), false);