melonjs 14.1.2 → 14.3.0

package/dist/types/tweens/tween.d.ts

@@ -0,0 +1,195 @@
+/**
+ * @classdesc
+ * Javascript Tweening Engine<p>
+ * Super simple, fast and easy to use tweening engine which incorporates optimised Robert Penner's equation<p>
+ * <a href="https://github.com/sole/Tween.js">https://github.com/sole/Tween.js</a><p>
+ * author sole / http://soledadpenades.com<br>
+ * author mr.doob / http://mrdoob.com<br>
+ * author Robert Eisele / http://www.xarg.org<br>
+ * author Philippe / http://philippe.elsass.me<br>
+ * author Robert Penner / http://www.robertpenner.com/easing_terms_of_use.html<br>
+ * author Paul Lewis / http://www.aerotwist.com/<br>
+ * author lechecacharro<br>
+ * author Josh Faul / http://jocafa.com/
+ */
+export default class Tween {
+    static get Easing(): any;
+    static get Interpolation(): any;
+    /**
+     * @param {object} object - object on which to apply the tween
+     * @example
+     * // add a tween to change the object pos.x and pos.y variable to 200 in 3 seconds
+     * tween = new me.Tween(myObject.pos).to({
+     *       x: 200,
+     *       y: 200,
+     *    }, {
+     *       duration: 3000,
+     *       easing: me.Tween.Easing.Bounce.Out,
+     *       autoStart : true
+     * }).onComplete(myFunc);
+     */
+    constructor(object: object);
+    /**
+     * reset the tween object to default value
+     * @ignore
+     */
+    onResetEvent(object: any): void;
+    /**
+     * @ignore
+     */
+    setProperties(object: any): void;
+    _object: any;
+    _valuesStart: {} | undefined;
+    _valuesEnd: {} | undefined;
+    _valuesStartRepeat: {} | undefined;
+    _duration: any;
+    _repeat: number | undefined;
+    _yoyo: boolean | undefined;
+    _reversed: any;
+    _delayTime: number | undefined;
+    _startTime: any;
+    _easingFunction: any;
+    _interpolationFunction: any;
+    _chainedTweens: IArguments | any[] | undefined;
+    _onStartCallback: Function | null | undefined;
+    _onStartCallbackFired: boolean | undefined;
+    _onUpdateCallback: Function | null | undefined;
+    _onCompleteCallback: Function | null | undefined;
+    _tweenTimeTracker: any;
+    isPersistent: boolean | undefined;
+    updateWhenPaused: boolean | undefined;
+    isRenderable: boolean | undefined;
+    /**
+     * @ignore
+     */
+    _resumeCallback(elapsed: any): void;
+    /**
+     * subscribe to the resume event when added
+     * @ignore
+     */
+    onActivateEvent(): void;
+    /**
+     * Unsubscribe when tween is removed
+     * @ignore
+     */
+    onDeactivateEvent(): void;
+    /**
+     * object properties to be updated and duration
+     * @name to
+     * @memberof Tween
+     * @public
+     * @param {object} properties - hash of properties
+     * @param {object|number} [options] - object of tween properties, or a duration if a numeric value is passed
+     * @param {number} [options.duration] - tween duration
+     * @param {Tween.Easing} [options.easing] - easing function
+     * @param {number} [options.delay] - delay amount expressed in milliseconds
+     * @param {boolean} [options.yoyo] - allows the tween to bounce back to their original value when finished. To be used together with repeat to create endless loops.
+     * @param {number} [options.repeat] - amount of times the tween should be repeated
+     * @param {Tween.Interpolation} [options.interpolation] - interpolation function
+     * @param {boolean} [options.autoStart] - allow this tween to start automatically. Otherwise call me.Tween.start().
+     * @returns {Tween} this instance for object chaining
+     */
+    public to(properties: object, options?: number | object | undefined): Tween;
+    /**
+     * start the tween
+     * @name start
+     * @memberof Tween
+     * @public
+     * @param {number} [time] - the current time when the tween was started
+     * @returns {Tween} this instance for object chaining
+     */
+    public start(time?: number | undefined): Tween;
+    /**
+     * stop the tween
+     * @name stop
+     * @memberof Tween
+     * @public
+     * @returns {Tween} this instance for object chaining
+     */
+    public stop(): Tween;
+    /**
+     * delay the tween
+     * @name delay
+     * @memberof Tween
+     * @public
+     * @param {number} amount - delay amount expressed in milliseconds
+     * @returns {Tween} this instance for object chaining
+     */
+    public delay(amount: number): Tween;
+    /**
+     * Repeat the tween
+     * @name repeat
+     * @memberof Tween
+     * @public
+     * @param {number} times - amount of times the tween should be repeated
+     * @returns {Tween} this instance for object chaining
+     */
+    public repeat(times: number): Tween;
+    /**
+     * Allows the tween to bounce back to their original value when finished.
+     * To be used together with repeat to create endless loops.
+     * @name yoyo
+     * @memberof Tween
+     * @public
+     * @see Tween#repeat
+     * @param {boolean} yoyo
+     * @returns {Tween} this instance for object chaining
+     */
+    public yoyo(yoyo: boolean): Tween;
+    /**
+     * set the easing function
+     * @name easing
+     * @memberof Tween
+     * @public
+     * @param {Tween.Easing} easing - easing function
+     * @returns {Tween} this instance for object chaining
+     */
+    public easing(easing: any): Tween;
+    /**
+     * set the interpolation function
+     * @name interpolation
+     * @memberof Tween
+     * @public
+     * @param {Tween.Interpolation} interpolation - interpolation function
+     * @returns {Tween} this instance for object chaining
+     */
+    public interpolation(interpolation: any): Tween;
+    /**
+     * chain the tween
+     * @name chain
+     * @memberof Tween
+     * @public
+     * @param {...Tween} chainedTween - Tween(s) to be chained
+     * @returns {Tween} this instance for object chaining
+     */
+    public chain(...args: Tween[]): Tween;
+    /**
+     * onStart callback
+     * @name onStart
+     * @memberof Tween
+     * @public
+     * @param {Function} onStartCallback - callback
+     * @returns {Tween} this instance for object chaining
+     */
+    public onStart(onStartCallback: Function): Tween;
+    /**
+     * onUpdate callback
+     * @name onUpdate
+     * @memberof Tween
+     * @public
+     * @param {Function} onUpdateCallback - callback
+     * @returns {Tween} this instance for object chaining
+     */
+    public onUpdate(onUpdateCallback: Function): Tween;
+    /**
+     * onComplete callback
+     * @name onComplete
+     * @memberof Tween
+     * @public
+     * @param {Function} onCompleteCallback - callback
+     * @returns {Tween} this instance for object chaining
+     */
+    public onComplete(onCompleteCallback: Function): Tween;
+    /** @ignore */
+    update(dt: any): boolean;
+}

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

@@ -0,0 +1,21 @@
+/**
+ * Get a vendor-prefixed property
+ * @public
+ * @name prefixed
+ * @param {string} name - Property name
+ * @param {object} [obj=globalThis] - Object or element reference to access
+ * @returns {string} Value of property
+ * @memberof utils.agent
+ */
+export function prefixed(name: string, obj?: object | undefined): string;
+/**
+ * Set a vendor-prefixed property
+ * @public
+ * @name setPrefixed
+ * @param {string} name - Property name
+ * @param {string} value - Property value
+ * @param {object} [obj=globalThis] - Object or element reference to access
+ * @returns {boolean} true if one of the vendor-prefixed property was found
+ * @memberof utils.agent
+ */
+export function setPrefixed(name: string, value: string, obj?: object | undefined): boolean;

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

@@ -0,0 +1,39 @@
+/**
+ * a collection of array utility functions
+ * @namespace utils.array
+ */
+/**
+ * Remove the specified object from the given Array
+ * @public
+ * @memberof utils.array
+ * @name remove
+ * @param {Array} arr - array from which to remove an object
+ * @param {object} obj - to be removed
+ * @returns {Array} the modified Array
+ * var arr = [ "foo", "bar", "baz" ];
+ * // remove "foo" from the array
+ * me.utils.array.remove(arr, "foo");
+ */
+export function remove(arr: any[], obj: object): any[];
+/**
+ * return a random array element
+ * @public
+ * @memberof utils.array
+ * @name random
+ * @param {Array} arr - array to pick a element
+ * @returns {any} random member of array
+ * @example
+ * // Select a random array element
+ * var arr = [ "foo", "bar", "baz" ];
+ * console.log(me.utils.array.random(arr));
+ */
+export function random(arr: any[]): any;
+/**
+ * return a weighted random array element, favoring the earlier entries
+ * @public
+ * @memberof utils.array
+ * @name weightedRandom
+ * @param {Array} arr - array to pick a element
+ * @returns {any} random member of array
+ */
+export function weightedRandom(arr: any[]): any;

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

@@ -0,0 +1,18 @@
+/**
+ * return the base name of the file without path info
+ * @public
+ * @memberof utils.file
+ * @name getBasename
+ * @param  {string} path- -  path containing the filename
+ * @returns {string} the base name without path information.
+ */
+export function getBasename(path: any): string;
+/**
+ * return the extension of the file in the given path
+ * @public
+ * @memberof utils.file
+ * @name getExtension
+ * @param  {string} path- -  path containing the filename
+ * @returns {string} filename extension.
+ */
+export function getExtension(path: any): string;

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

@@ -0,0 +1,32 @@
+/**
+ * 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);
+ */
+export function defer(func: Function, thisArg: object, ...args: any[]): number;
+/**
+ * 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
+ */
+export function throttle(fn: Function, delay: number, no_trailing: any): Function;

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

@@ -0,0 +1,50 @@
+/**
+ * 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
+ */
+export function capitalize(str: string): string;
+/**
+ * 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
+ */
+export function isNumeric(str: string): boolean;
+/**
+ * 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
+ */
+export function isBoolean(str: string): boolean;
+/**
+ * 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
+ */
+export function toHex(str: string): string;
+/**
+ * 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
+ */
+export function isDataUrl(str: string): boolean;

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

@@ -0,0 +1,17 @@
+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";