melonjs 14.0.1 → 14.1.0

package/dist/melonjs.mjs/utils/function.js

@@ -0,0 +1,70 @@
+/*!
+ * melonJS Game Engine - v14.1.0
+ * http://www.melonjs.org
+ * melonjs is licensed under the MIT License.
+ * http://www.opensource.org/licenses/mit-license
+ * @copyright (C) 2011 - 2022 Olivier Biot (AltByte Pte Ltd)
+ */
+/**
+ * a collection of utility functions
+ * @namespace utils.function
+ */
+
+/**
+ * Executes a function as soon as the interpreter is idle (stack empty).
+ * @public
+ * @memberof utils.function
+ * @name defer
+ * @param {Function} func - The function to be deferred.
+ * @param {object} thisArg - The value to be passed as the this parameter to the target function when the deferred function is called
+ * @param {...*} args - Optional additional arguments to carry for the function.
+ * @returns {number} id that can be used to clear the deferred function using
+ * clearTimeout
+ * @example
+ * // execute myFunc() when the stack is empty,
+ * // with the current context and [1, 2, 3] as parameter
+ * me.utils.function.defer(myFunc, this, 1, 2, 3);
+ */
+function defer(func, thisArg, ...args) {
+    return setTimeout(func.bind(thisArg), 0.01, ...args);
+}
+
+/**
+ * returns a function that, when invoked will only be triggered at most
+ * once during a given window of time
+ * @public
+ * @memberof utils.function
+ * @name throttle
+ * @param {Function} fn - the function to be throttled.
+ * @param {number} delay - The delay in ms
+ * @param {no_trailing} no_trailing - disable the execution on the trailing edge
+ * @returns {Function} the function that will be throttled
+ */
+function throttle(fn, delay, no_trailing) {
+    var last = globalThis.performance.now(), deferTimer;
+    // `no_trailing` defaults to false.
+    if (typeof no_trailing !== "boolean") {
+        no_trailing = false;
+    }
+    return function () {
+        var now = globalThis.performance.now();
+        var elasped = now - last;
+        var args = arguments;
+        if (elasped < delay) {
+            if (no_trailing === false) {
+                // hold on to it
+                clearTimeout(deferTimer);
+                deferTimer = setTimeout(() => {
+                    last = now;
+                    return fn.apply(null, args);
+                }, elasped);
+            }
+        }
+        else {
+            last = now;
+            return fn.apply(null, args);
+        }
+    };
+}
+
+export { defer, throttle };

package/dist/melonjs.mjs/utils/string.js

@@ -0,0 +1,82 @@
+/*!
+ * melonJS Game Engine - v14.1.0
+ * http://www.melonjs.org
+ * melonjs is licensed under the MIT License.
+ * http://www.opensource.org/licenses/mit-license
+ * @copyright (C) 2011 - 2022 Olivier Biot (AltByte Pte Ltd)
+ */
+/**
+ * a collection of string utility functions
+ * @namespace utils.string
+ */
+
+/**
+ * converts the first character of the given string to uppercase
+ * @public
+ * @memberof utils.string
+ * @name capitalize
+ * @param {string} str - the string to be capitalized
+ * @returns {string} the capitalized string
+ */
+function capitalize(str) {
+    return str.charAt(0).toUpperCase() + str.slice(1);
+}
+
+/**
+ * returns true if the given string contains a numeric integer or float value
+ * @public
+ * @memberof utils.string
+ * @name isNumeric
+ * @param {string} str - the string to be tested
+ * @returns {boolean} true if string contains only digits
+ */
+function isNumeric(str) {
+    if (typeof str === "string") {
+        str = str.trim();
+    }
+    return !isNaN(str) && /[+-]?([0-9]*[.])?[0-9]+/.test(str);
+}
+
+/**
+ * returns true if the given string contains a true or false
+ * @public
+ * @memberof utils.string
+ * @name isBoolean
+ * @param {string} str - the string to be tested
+ * @returns {boolean} true if the string is either true or false
+ */
+function isBoolean(str) {
+    var trimmed = str.trim();
+    return (trimmed === "true") || (trimmed === "false");
+}
+
+/**
+ * convert a string to the corresponding hexadecimal value
+ * @public
+ * @memberof utils.string
+ * @name toHex
+ * @param {string} str - the string to be converted
+ * @returns {string} the converted hexadecimal value
+ */
+function toHex(str) {
+    var res = "", c = 0;
+    while (c < str.length) {
+        res += str.charCodeAt(c++).toString(16);
+    }
+    return res;
+}
+
+/**
+ * returns true if the given string is a data url in the `data:[<mediatype>][;base64],<data>` format.
+ * (this will not test the validity of the Data or Base64 encoding)
+ * @public
+ * @memberof utils.string
+ * @name isDataUrl
+ * @param {string} str - the string (url) to be tested
+ * @returns {boolean} true if the string is a data url
+ */
+function isDataUrl(str) {
+    return /^data:(.+);base64,(.+)$/.test(str);
+}
+
+export { capitalize, isBoolean, isDataUrl, isNumeric, toHex };

package/dist/melonjs.mjs/utils/utils.js

@@ -0,0 +1,173 @@
+/*!
+ * melonJS Game Engine - v14.1.0
+ * http://www.melonjs.org
+ * melonjs is licensed under the MIT License.
+ * http://www.opensource.org/licenses/mit-license
+ * @copyright (C) 2011 - 2022 Olivier Biot (AltByte Pte Ltd)
+ */
+import * as agent from './agent.js';
+import * as array from './array.js';
+import * as file from './file.js';
+import * as string from './string.js';
+import { toHex } from './string.js';
+import * as _function from './function.js';
+import { createCanvas } from '../video/video.js';
+import CanvasRenderer from '../video/canvas/canvas_renderer.js';
+import { version } from '../index.js';
+
+/**
+ * a collection of utility functions
+ * @namespace utils
+ */
+
+// guid default value
+var GUID_base  = "";
+var GUID_index = 0;
+
+var utils = {
+
+    agent : agent,
+    array : array,
+    file : file,
+    string : string,
+    function : _function,
+
+    /**
+     * Get image pixels
+     * @public
+     * @memberof utils
+     * @name getPixels
+     * @param {HTMLImageElement|HTMLCanvasElement} image - Image to read
+     * @returns {ImageData} ImageData object
+     */
+    getPixels : function (image) {
+        if (image instanceof HTMLImageElement) {
+            var _context = CanvasRenderer.getContext2d(
+                createCanvas(image.width, image.height)
+            );
+            _context.drawImage(image, 0, 0);
+            return _context.getImageData(0, 0, image.width, image.height);
+        }
+        else {
+            // canvas !
+            return image.getContext("2d").getImageData(0, 0, image.width, image.height);
+        }
+    },
+
+    /**
+     * Compare two version strings
+     * @public
+     * @memberof utils
+     * @name checkVersion
+     * @param {string} first - First version string to compare
+     * @param {string} [second=version] - 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 = version) {
+        var a = first.split(".");
+        var b = second.split(".");
+        var len = Math.min(a.length, b.length);
+        var result = 0;
+
+        for (var i = 0; i < len; i++) {
+            if ((result = +a[i] - +b[i])) {
+                break;
+            }
+        }
+
+        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
+     * var UriFragment = me.utils.getUriFragment();
+     * console.log(UriFragment["mytag"]); //> "value"
+     */
+    getUriFragment : function (url) {
+        var hash = {};
+
+        if (typeof url === "undefined") {
+            if (typeof globalThis.document !== "undefined") {
+                var location = globalThis.document.location;
+
+                if (location && location.hash) {
+                    url = location.hash;
+                } else {
+                    // No "document.location" exist for Wechat mini game platform.
+                    return hash;
+                }
+            } else {
+                // "document" undefined on node.js
+                return hash;
+            }
+        } else {
+            // never cache if a url is passed as parameter
+            var index = url.indexOf("#");
+            if (index !== -1) {
+                url = url.slice(index, url.length);
+            } else {
+                return hash;
+            }
+        }
+
+        // parse the url
+        url.slice(1).split("&").filter((value) => {
+            return (value !== "");
+        }).forEach((value) => {
+            var kv = value.split("=");
+            var k = kv.shift();
+            var v = kv.join("=");
+            hash[k] = v || true;
+        });
+
+        return hash;
+    },
+
+    /**
+     * 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  = toHex(base.toString().toUpperCase());
+        GUID_index = index;
+    },
+
+    /**
+     * 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);
+    }
+};
+
+var utils$1 = utils;
+
+export { utils$1 as default };