melonjs 18.1.0 → 18.2.1

package/build/input/gamepad.d.ts

@@ -1,11 +1,78 @@
+interface GamepadMapping {
+    axes: number[];
+    buttons: number[];
+    analog: number[];
+    normalize_fn: (value: number, axis: number, button: number) => number;
+}
+/**
+ * Namespace for standard gamepad mapping constants
+ */
+export declare const GAMEPAD: {
+    /**
+     * Standard gamepad mapping information for axes<br>
+     * <ul>
+     *   <li>Left control stick: <code>LX</code> (horizontal), <code>LY</code> (vertical)</li>
+     *   <li>Right control stick: <code>RX</code> (horizontal), <code>RY</code> (vertical)</li>
+     *   <li>Extras: <code>EXTRA_1</code>, <code>EXTRA_2</code>, <code>EXTRA_3</code>, <code>EXTRA_4</code></li>
+     * </ul>
+     * @see {@link https://w3c.github.io/gamepad/#remapping}
+     */
+    readonly AXES: {
+        readonly LX: 0;
+        readonly LY: 1;
+        readonly RX: 2;
+        readonly RY: 3;
+        readonly EXTRA_1: 4;
+        readonly EXTRA_2: 5;
+        readonly EXTRA_3: 6;
+        readonly EXTRA_4: 7;
+    };
+    /**
+     * Standard gamepad mapping information for buttons<br>
+     * <ul>
+     *   <li>Face buttons: <code>FACE_1</code>, <code>FACE_2</code>, <code>FACE_3</code>, <code>FACE_4</code></li>
+     *   <li>D-Pad: <code>UP</code>, <code>DOWN</code>, <code>LEFT</code>, <code>RIGHT</code></li>
+     *   <li>Shoulder buttons: <code>L1</code>, <code>L2</code>, <code>R1</code>, <code>R2</code></li>
+     *   <li>Analog stick (clicks): <code>L3</code>, <code>R3</code></li>
+     *   <li>Navigation: <code>SELECT</code> (<code>BACK</code>), <code>START</code> (<code>FORWARD</code>), <code>HOME</code></li>
+     *   <li>Extras: <code>EXTRA_1</code>, <code>EXTRA_2</code>, <code>EXTRA_3</code>, <code>EXTRA_4</code></li>
+     * </ul>
+     * @see {@link https://w3c.github.io/gamepad/#remapping}
+     */
+    readonly BUTTONS: {
+        readonly FACE_1: 0;
+        readonly FACE_2: 1;
+        readonly FACE_3: 2;
+        readonly FACE_4: 3;
+        readonly L1: 4;
+        readonly R1: 5;
+        readonly L2: 6;
+        readonly R2: 7;
+        readonly SELECT: 8;
+        readonly BACK: 8;
+        readonly START: 9;
+        readonly FORWARD: 9;
+        readonly L3: 10;
+        readonly R3: 11;
+        readonly UP: 12;
+        readonly DOWN: 13;
+        readonly LEFT: 14;
+        readonly RIGHT: 15;
+        readonly HOME: 16;
+        readonly EXTRA_1: 17;
+        readonly EXTRA_2: 18;
+        readonly EXTRA_3: 19;
+        readonly EXTRA_4: 20;
+    };
+};
 /**
  * Associate a gamepad event to a keycode
- * @param {number} index - Gamepad index
- * @param {object} button - Button/Axis definition
- * @param {string} button.type - "buttons" or "axes"
- * @param {number} button.code - button or axis code id (See {@link input.GAMEPAD})
- * @param {number} [button.threshold=1] - value indicating when the axis should trigger the keycode (e.g. -0.5 or 0.5)
- * @param {number} keyCode - (See {@link input.KEY})
+ * @param index - Gamepad index
+ * @param button - Button/Axis definition
+ * @param button.type - "buttons" or "axes"
+ * @param button.code - button or axis code id
+ * @param button.threshold - value indicating when the axis should trigger the keycode
+ * @param keyCode - (See {@link input.KEY})
  * @example
  * // enable the keyboard
  * me.input.bindKey(me.input.KEY.X, "shoot");
@@ -16,75 +83,57 @@
  * me.input.bindGamepad(0, {type:"axes", code: me.input.GAMEPAD.AXES.LX, threshold: -0.5}, me.input.KEY.LEFT);
  * @category Input
  */
-export function bindGamepad(index: number, button: {
-    type: string;
+export declare function bindGamepad(index: number, button: {
+    type: "buttons" | "axes";
     code: number;
-    threshold?: number | undefined;
+    threshold?: number;
 }, keyCode: number): void;
 /**
  * unbind the defined keycode
- * @param {number} index - Gamepad index
- * @param {number} button - (See {@link input.GAMEPAD})
+ * @param index - Gamepad index
+ * @param button - (See {@link input.GAMEPAD})
  * @example
  * me.input.unbindGamepad(0, me.input.GAMEPAD.BUTTONS.FACE_1);
  * @category Input
  */
-export function unbindGamepad(index: number, button: number): void;
+export declare function unbindGamepad(index: number, button: number): void;
 /**
  * Set deadzone for analog gamepad inputs<br>
  * The default deadzone is 0.1 (10%) Analog values less than this will be ignored
- * @param {number} value - Deadzone value
+ * @param value - Deadzone value
  * @category Input
  */
-export function setGamepadDeadzone(value: number): void;
-export namespace GAMEPAD {
-    namespace AXES {
-        let LX: number;
-        let LY: number;
-        let RX: number;
-        let RY: number;
-        let EXTRA_1: number;
-        let EXTRA_2: number;
-        let EXTRA_3: number;
-        let EXTRA_4: number;
-    }
-    namespace BUTTONS {
-        export let FACE_1: number;
-        export let FACE_2: number;
-        export let FACE_3: number;
-        export let FACE_4: number;
-        export let L1: number;
-        export let R1: number;
-        export let L2: number;
-        export let R2: number;
-        export let SELECT: number;
-        export let BACK: number;
-        export let START: number;
-        export let FORWARD: number;
-        export let L3: number;
-        export let R3: number;
-        export let UP: number;
-        export let DOWN: number;
-        export let LEFT: number;
-        export let RIGHT: number;
-        export let HOME: number;
-        let EXTRA_1_1: number;
-        export { EXTRA_1_1 as EXTRA_1 };
-        let EXTRA_2_1: number;
-        export { EXTRA_2_1 as EXTRA_2 };
-        let EXTRA_3_1: number;
-        export { EXTRA_3_1 as EXTRA_3 };
-        let EXTRA_4_1: number;
-        export { EXTRA_4_1 as EXTRA_4 };
-    }
-}
+export declare function setGamepadDeadzone(value: number): void;
 /**
- * Firefox reports different ids for gamepads depending on the platform:
- * - Windows: vendor and product codes contain leading zeroes
- * - Mac: vendor and product codes are sparse (no leading zeroes)
+ * specify a custom mapping for a specific gamepad id<br>
+ * see below for the default mapping : <br>
+ * <center><img src="images/gamepad_diagram.png"/></center><br>
+ * @param id - Gamepad id string
+ * @param mapping - A hash table
+ * @example
+ * // A weird controller that has its axis mappings reversed
+ * me.input.setGamepadMapping("Generic USB Controller", {
+ *   "axes" : [ 3, 2, 1, 0 ],
+ *   "buttons" : [ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16 ]
+ * });
+ *
+ * // Mapping extra axes to analog buttons
+ * me.input.setGamepadMapping("Generic Analog Controller", {
+ *   "axes" : [ 0, 1, 2, 3 ],
+ *   "buttons" : [ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16 ],
+ *
+ *   // Raw axis 4 is mapped to GAMEPAD.BUTTONS.FACE_1
+ *   // Raw axis 5 is mapped to GAMEPAD.BUTTONS.FACE_2
+ *   // etc...
+ *   // Also maps left and right triggers
+ *   "analog" : [ 4, 5, 6, 7, -1, -1, 8, 9, -1, -1, -1, -1, -1, -1, -1, -1, -1 ],
  *
- * This function normalizes the id to support both formats
- * @ignore
+ *   // Normalize the value of button L2: [-1.0..1.0] => [0.0..1.0]
+ *   "normalize_fn" : function (value, axis, button) {
+ *     return ((button === me.input.GAMEPAD.BUTTONS.L2) ? ((value + 1) / 2) : value) || 0;
+ *   }
+ * });
  */
-export function setGamepadMapping(id: any, mapping: any): void;
+export declare const setGamepadMapping: (id: string, mapping: Partial<GamepadMapping>) => void;
+export {};
 //# sourceMappingURL=gamepad.d.ts.map

package/build/input/gamepad.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"gamepad.d.ts","sourceRoot":"","sources":["../../src/input/gamepad.js"],"names":[],"mappings":"AAiXA;;;;;;;;;;;;;;;;;GAiBG;AACH,mCAhBW,MAAM,UAEd;IAAuB,IAAI,EAAnB,MAAM;IACS,IAAI,EAAnB,MAAM;IACU,SAAS;CACjC,WAAQ,MAAM,QAkEhB;AAED;;;;;;;GAOG;AACH,qCANW,MAAM,UACN,MAAM,QAUhB;AAED;;;;;GAKG;AACH,0CAHW,MAAM,QAKhB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA7ZD;;;;;;;GAOG;AACH,+DA0BC"}
+{"version":3,"file":"gamepad.d.ts","sourceRoot":"","sources":["../../src/input/gamepad.ts"],"names":[],"mappings":"AASA,UAAU,cAAc;IACvB,IAAI,EAAE,MAAM,EAAE,CAAC;IACf,OAAO,EAAE,MAAM,EAAE,CAAC;IAClB,MAAM,EAAE,MAAM,EAAE,CAAC;IACjB,YAAY,EAAE,CAAC,KAAK,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,KAAK,MAAM,CAAC;CACtE;AA2UD;;GAEG;AACH,eAAO,MAAM,OAAO;IACnB;;;;;;;;OAQG;;;;;;;;;;;IAYH;;;;;;;;;;;OAWG;;;;;;;;;;;;;;;;;;;;;;;;;;CA0BM,CAAC;AAEX;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,WAAW,CAC1B,KAAK,EAAE,MAAM,EACb,MAAM,EAAE;IAAE,IAAI,EAAE,SAAS,GAAG,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,SAAS,CAAC,EAAE,MAAM,CAAA;CAAE,EACtE,OAAO,EAAE,MAAM,GACb,IAAI,CAuDN;AAED;;;;;;;GAOG;AACH,wBAAgB,aAAa,CAAC,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,IAAI,CAKjE;AAED;;;;;GAKG;AACH,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI,CAEtD;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,eAAO,MAAM,iBAAiB,EAAE,CAC/B,EAAE,EAAE,MAAM,EACV,OAAO,EAAE,OAAO,CAAC,cAAc,CAAC,KAC5B,IAAiB,CAAC"}

package/build/input/input.d.ts

@@ -3,15 +3,11 @@
  */
 /**
  * specify if melonJS should prevent all default browser action on registered events.
- * @public
- * @type {boolean}
  * @default true
- * @name preventDefault
- * @memberof input
  */
-export let preventDefault: boolean;
-export * from "./gamepad.js";
+export declare let preventDefault: boolean;
+export * from "./gamepad.ts";
 export * from "./key.ts";
 export * from "./keyboard.ts";
-export * from "./pointerevent.js";
+export * from "./pointerevent.ts";
 //# sourceMappingURL=input.d.ts.map

package/build/input/input.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"input.d.ts","sourceRoot":"","sources":["../../src/input/input.js"],"names":[],"mappings":"AAAA;;GAEG;AAEH;;;;;;;GAOG;AACH,2BALU,OAAO,CAKgB"}
+{"version":3,"file":"input.d.ts","sourceRoot":"","sources":["../../src/input/input.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH;;;GAGG;AAEH,eAAO,IAAI,cAAc,EAAE,OAAc,CAAC;AAE1C,cAAc,cAAc,CAAC;AAC7B,cAAc,UAAU,CAAC;AACzB,cAAc,eAAe,CAAC;AAC9B,cAAc,mBAAmB,CAAC"}

package/build/input/pointer.d.ts

@@ -1,180 +1,154 @@
-export default Pointer;
+import { Bounds } from "./../physics/bounds.ts";
 /**
  * a pointer object, representing a single finger on a touch enabled device.
  */
 declare class Pointer extends Bounds {
-    /**
-     * @ignore
-     */
-    constructor(x?: number, y?: number, w?: number, h?: number);
     /**
      * constant for left button
-     * @public
-     * @type {number}
      */
-    public LEFT: number;
+    LEFT: number;
     /**
      * constant for middle button
-     * @public
-     * @type {number}
      */
-    public MIDDLE: number;
+    MIDDLE: number;
     /**
      * constant for right button
-     * @public
-     * @type {number}
      */
-    public RIGHT: number;
+    RIGHT: number;
     /**
      * the originating Event Object
-     * @type {PointerEvent|TouchEvent|MouseEvent}
      * @see {@link https://developer.mozilla.org/en-US/docs/Web/API/PointerEvent}
      * @see {@link https://developer.mozilla.org/en-US/docs/Web/API/TouchEvent}
      * @see {@link https://developer.mozilla.org/en-US/docs/Web/API/MouseEvent}
      */
-    event: PointerEvent | TouchEvent | MouseEvent;
+    event: PointerEvent | TouchEvent | MouseEvent | undefined;
+    /**
+     * a string containing the event's type.
+     * @see {@link https://developer.mozilla.org/en-US/docs/Web/API/Event/type}
+     */
+    type: string;
     /**
      * the button property indicates which button was pressed on the mouse to trigger the event.
-     * @type {number}
      * @see {@link https://developer.mozilla.org/en-US/docs/Web/API/MouseEvent/button}
      */
     button: number;
     /**
      * indicates whether or not the pointer device that created the event is the primary pointer.
-     * @type {boolean}
      * @see {@link https://developer.mozilla.org/en-US/docs/Web/API/PointerEvent/isPrimary}
      */
     isPrimary: boolean;
     /**
      * the horizontal coordinate at which the event occurred, relative to the left edge of the entire document.
-     * @type {number}
      * @see {@link https://developer.mozilla.org/en-US/docs/Web/API/MouseEvent/pageX}
      */
     pageX: number;
     /**
      * the vertical coordinate at which the event occurred, relative to the left edge of the entire document.
-     * @type {number}
      * @see {@link https://developer.mozilla.org/en-US/docs/Web/API/MouseEvent/pageY}
      */
     pageY: number;
     /**
      * the horizontal coordinate within the application's client area at which the event occurred
-     * @type {number}
      * @see {@link https://developer.mozilla.org/en-US/docs/Web/API/MouseEvent/clientX}
      */
     clientX: number;
     /**
      * the vertical coordinate within the application's client area at which the event occurred
-     * @type {number}
      * @see {@link https://developer.mozilla.org/en-US/docs/Web/API/MouseEvent/clientY}
      */
     clientY: number;
     /**
      * the difference in the X coordinate of the pointer since the previous move event
-     * @type {number}
      * @see {@link https://developer.mozilla.org/en-US/docs/Web/API/MouseEvent/movementX}
      */
     movementX: number;
     /**
      * the difference in the Y coordinate of the pointer since the previous move event
-     * @type {number}
      * @see {@link https://developer.mozilla.org/en-US/docs/Web/API/MouseEvent/movementY}
      */
     movementY: number;
     /**
      * an unsigned long representing the unit of the delta values scroll amount
-     * @type {number}
      * @see {@link https://developer.mozilla.org/en-US/docs/Web/API/WheelEvent/deltaMode}
      */
     deltaMode: number;
     /**
      * a double representing the horizontal scroll amount in the Wheel Event deltaMode unit.
-     * @type {number}
      * @see {@link https://developer.mozilla.org/en-US/docs/Web/API/WheelEvent/deltaX}
      */
     deltaX: number;
     /**
      * a double representing the vertical scroll amount in the Wheel Event deltaMode unit.
-     * @type {number}
      * @see {@link https://developer.mozilla.org/en-US/docs/Web/API/WheelEvent/deltaY}
      */
     deltaY: number;
     /**
      * a double representing the scroll amount in the z-axis, in the Wheel Event deltaMode unit.
-     * @type {number}
      * @see {@link https://developer.mozilla.org/en-US/docs/Web/API/WheelEvent/deltaZ}
      */
     deltaZ: number;
     /**
      * Event normalized X coordinate within the game canvas itself<br>
      * <img src="images/event_coord.png"/>
-     * @type {number}
      */
     gameX: number;
     /**
      * Event normalized Y coordinate within the game canvas itself<br>
      * <img src="images/event_coord.png"/>
-     * @type {number}
      */
     gameY: number;
     /**
      * Event X coordinate relative to the viewport
-     * @type {number}
      */
     gameScreenX: number;
     /**
      * Event Y coordinate relative to the viewport
-     * @type {number}
      */
     gameScreenY: number;
     /**
      * Event X coordinate relative to the map
-     * @type {number}
      */
     gameWorldX: number;
     /**
      * Event Y coordinate relative to the map
-     * @type {number}
      */
     gameWorldY: number;
     /**
      * Event X coordinate relative to the holding container
-     * @type {number}
      */
     gameLocalX: number;
     /**
      * Event Y coordinate relative to the holding container
-     * @type {number}
      */
     gameLocalY: number;
     /**
      * The unique identifier of the contact for a touch, mouse or pen
-     * @type {number}
      * @see {@link https://developer.mozilla.org/en-US/docs/Web/API/PointerEvent/pointerId}
      */
-    pointerId: number;
+    pointerId: number | undefined;
     /**
      * true if not originally a pointer event
-     * @type {boolean}
      */
     isNormalized: boolean;
     /**
      * true if the pointer is currently locked
-     * @type {boolean}
      */
     locked: boolean;
-    bind: number[];
+    bind: (number | null)[];
+    /**
+     * @ignore
+     */
+    constructor(x?: number, y?: number, w?: number, h?: number);
     /**
      * initialize the Pointer object using the given Event Object
-     * @private
-     * @param {Event} event - the original Event object
-     * @param {number} [pageX=0] - the horizontal coordinate at which the event occurred, relative to the left edge of the entire document
-     * @param {number} [pageY=0] - the vertical coordinate at which the event occurred, relative to the left edge of the entire document
-     * @param {number} [clientX=0] - the horizontal coordinate within the application's client area at which the event occurred
-     * @param {number} [clientY=0] - the vertical coordinate within the application's client area at which the event occurred
-     * @param {number} [pointerId=1] - the Pointer, Touch or Mouse event Id (1)
-     */
-    private setEvent;
+     * @param event - the original Event object
+     * @param pageX - the horizontal coordinate at which the event occurred, relative to the left edge of the entire document
+     * @param pageY - the vertical coordinate at which the event occurred, relative to the left edge of the entire document
+     * @param clientX - the horizontal coordinate within the application's client area at which the event occurred
+     * @param clientY - the vertical coordinate within the application's client area at which the event occurred
+     * @param pointerId - the Pointer, Touch or Mouse event Id (1)
+     */
+    setEvent(event: Event, pageX?: number, pageY?: number, clientX?: number, clientY?: number, pointerId?: number): void;
 }
-import { Bounds } from "./../physics/bounds.ts";
+export default Pointer;
 //# sourceMappingURL=pointer.d.ts.map

package/build/input/pointer.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"pointer.d.ts","sourceRoot":"","sources":["../../src/input/pointer.js"],"names":[],"mappings":";AAYA;;GAEG;AACH;IACC;;OAEG;IACH,4DAuMC;IAhMA;;;;OAIG;IACH,aAFU,MAAM,CAEH;IAEb;;;;OAIG;IACH,eAFU,MAAM,CAED;IAEf;;;;OAIG;IACH,cAFU,MAAM,CAEF;IAEd;;;;;;OAMG;IACH,OALU,YAAY,GAAC,UAAU,GAAC,UAAU,CAKtB;IAStB;;;;OAIG;IACH,QAHU,MAAM,CAGD;IAEf;;;;OAIG;IACH,WAHU,OAAO,CAGK;IAEtB;;;;OAIG;IACH,OAHU,MAAM,CAGF;IAEd;;;;OAIG;IACH,OAHU,MAAM,CAGF;IAEd;;;;OAIG;IACH,SAHU,MAAM,CAGA;IAEhB;;;;OAIG;IACH,SAHU,MAAM,CAGA;IAEhB;;;;OAIG;IACH,WAHU,MAAM,CAGE;IAElB;;;;OAIG;IACH,WAHU,MAAM,CAGE;IAElB;;;;OAIG;IACH,WAHU,MAAM,CAGE;IAElB;;;;OAIG;IACH,QAHU,MAAM,CAGD;IAEf;;;;OAIG;IACH,QAHU,MAAM,CAGD;IAEf;;;;OAIG;IACH,QAHU,MAAM,CAGD;IAEf;;;;OAIG;IACH,OAFU,MAAM,CAEF;IAEd;;;;OAIG;IACH,OAFU,MAAM,CAEF;IAEd;;;OAGG;IACH,aAFU,MAAM,CAEI;IAEpB;;;OAGG;IACH,aAFU,MAAM,CAEI;IAEpB;;;OAGG;IACH,YAFU,MAAM,CAEG;IAEnB;;;OAGG;IACH,YAFU,MAAM,CAEG;IAEnB;;;OAGG;IACH,YAFU,MAAM,CAEG;IAEnB;;;OAGG;IACH,YAFU,MAAM,CAEG;IAEnB;;;;OAIG;IACH,WAHU,MAAM,CAGU;IAE1B;;;OAGG;IACH,cAFU,OAAO,CAEQ;IAEzB;;;OAGG;IACH,QAFU,OAAO,CAEE;IAGnB,eAAqB;IAGtB;;;;;;;;;OASG;IACH,iBAyEC;CACD;uBA9SsB,wBAAwB"}
+{"version":3,"file":"pointer.d.ts","sourceRoot":"","sources":["../../src/input/pointer.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,MAAM,EAAE,MAAM,wBAAwB,CAAC;AAUhD;;GAEG;AACH,cAAM,OAAQ,SAAQ,MAAM;IAC3B;;OAEG;IACH,IAAI,EAAE,MAAM,CAAC;IAEb;;OAEG;IACH,MAAM,EAAE,MAAM,CAAC;IAEf;;OAEG;IACH,KAAK,EAAE,MAAM,CAAC;IAEd;;;;;OAKG;IACH,KAAK,EAAE,YAAY,GAAG,UAAU,GAAG,UAAU,GAAG,SAAS,CAAC;IAE1D;;;OAGG;IACM,IAAI,EAAE,MAAM,CAAM;IAE3B;;;OAGG;IACH,MAAM,EAAE,MAAM,CAAC;IAEf;;;OAGG;IACH,SAAS,EAAE,OAAO,CAAC;IAEnB;;;OAGG;IACH,KAAK,EAAE,MAAM,CAAC;IAEd;;;OAGG;IACH,KAAK,EAAE,MAAM,CAAC;IAEd;;;OAGG;IACH,OAAO,EAAE,MAAM,CAAC;IAEhB;;;OAGG;IACH,OAAO,EAAE,MAAM,CAAC;IAEhB;;;OAGG;IACH,SAAS,EAAE,MAAM,CAAC;IAElB;;;OAGG;IACH,SAAS,EAAE,MAAM,CAAC;IAElB;;;OAGG;IACH,SAAS,EAAE,MAAM,CAAC;IAElB;;;OAGG;IACH,MAAM,EAAE,MAAM,CAAC;IAEf;;;OAGG;IACH,MAAM,EAAE,MAAM,CAAC;IAEf;;;OAGG;IACH,MAAM,EAAE,MAAM,CAAC;IAEf;;;OAGG;IACH,KAAK,EAAE,MAAM,CAAC;IAEd;;;OAGG;IACH,KAAK,EAAE,MAAM,CAAC;IAEd;;OAEG;IACH,WAAW,EAAE,MAAM,CAAC;IAEpB;;OAEG;IACH,WAAW,EAAE,MAAM,CAAC;IAEpB;;OAEG;IACH,UAAU,EAAE,MAAM,CAAC;IAEnB;;OAEG;IACH,UAAU,EAAE,MAAM,CAAC;IAEnB;;OAEG;IACH,UAAU,EAAE,MAAM,CAAC;IAEnB;;OAEG;IACH,UAAU,EAAE,MAAM,CAAC;IAEnB;;;OAGG;IACH,SAAS,EAAE,MAAM,GAAG,SAAS,CAAC;IAE9B;;OAEG;IACH,YAAY,EAAE,OAAO,CAAC;IAEtB;;OAEG;IACH,MAAM,EAAE,OAAO,CAAC;IAGhB,IAAI,EAAE,CAAC,MAAM,GAAG,IAAI,CAAC,EAAE,CAAC;IAExB;;OAEG;gBACS,CAAC,GAAE,MAAU,EAAE,CAAC,GAAE,MAAU,EAAE,CAAC,GAAE,MAAU,EAAE,CAAC,GAAE,MAAU;IAyCtE;;;;;;;;OAQG;IACH,QAAQ,CACP,KAAK,EAAE,KAAK,EACZ,KAAK,GAAE,MAAU,EACjB,KAAK,GAAE,MAAU,EACjB,OAAO,GAAE,MAAU,EACnB,OAAO,GAAE,MAAU,EACnB,SAAS,GAAE,MAAU,GACnB,IAAI;CAqEP;AAED,eAAe,OAAO,CAAC"}

package/build/input/pointerevent.d.ts

@@ -1,24 +1,41 @@
+import type { Vector2d } from "../math/vector2d.ts";
+import Pointer from "./pointer.ts";
+/**
+ * the default target element for pointer events (usually the canvas element in which the game is rendered)
+ */
+export declare let pointerEventTarget: EventTarget | null;
+/**
+ * Pointer information (current position and size)
+ */
+export declare const pointer: Pointer;
+/**
+ * indicates if the pointer is currently locked
+ */
+export declare let locked: boolean;
+/**
+ * time interval for event throttling in milliseconds<br>
+ * default value : "1000/me.timer.maxfps" ms<br>
+ * set to 0 ms to disable the feature
+ */
+export declare let throttlingInterval: number | undefined;
 /**
  * return true if there are pending pointer events in the queue
- * @memberof input
  * @returns true if there are pending events
  */
-export function hasActiveEvents(): boolean;
+export declare function hasActiveEvents(): boolean;
 /**
  * return true if there are register pointer events
- * @memberof input
  * @see {@link registerPointerEvent}
  * @returns true if there are pending events
  */
-export function hasRegisteredEvents(): boolean;
+export declare function hasRegisteredEvents(): boolean;
 /**
  * Translate the specified x and y values from the global (absolute)
  * coordinate to local (viewport) relative coordinate.
- * @memberof input
- * @param {number} x - the global x coordinate to be translated.
- * @param {number} y - the global y coordinate to be translated.
- * @param {Vector2d} [v] - an optional vector object where to set the translated coordinates
- * @returns {Vector2d} A vector object with the corresponding translated coordinates
+ * @param x - the global x coordinate to be translated.
+ * @param y - the global y coordinate to be translated.
+ * @param v - an optional vector object where to set the translated coordinates
+ * @returns A vector object with the corresponding translated coordinates
  * @example
  * onMouseEvent : function (pointer) {
  *    // convert the given into local (viewport) relative coordinates
@@ -26,24 +43,21 @@ export function hasRegisteredEvents(): boolean;
  *    // do something with pos !
  * };
  */
-export function globalToLocal(x: number, y: number, v?: Vector2d): Vector2d;
+export declare function globalToLocal(x: number, y: number, v?: Vector2d): Vector2d;
 /**
  * enable/disable all gestures on the given element.<br>
  * by default melonJS will disable browser handling of all panning and zooming gestures.
- * @memberof input
  * @see {@link https://developer.mozilla.org/en-US/docs/Web/CSS/touch-action}
- * @param {HTMLCanvasElement} element
- * @param {string} [value="none"]
+ * @param element - the HTML element to configure
+ * @param value - the touch-action CSS value
  */
-export function setTouchAction(element: HTMLCanvasElement, value?: string): void;
+export declare function setTouchAction(element: HTMLCanvasElement, value?: string): void;
 /**
  * Associate a pointer event to a keycode<br>
- * Left button – 0
- * Middle button – 1
- * Right button – 2
- * @memberof input
- * @param {number} [button=input.pointer.LEFT] - (accordingly to W3C values : 0,1,2 for left, middle and right buttons)
- * @param {input.KEY} keyCode
+ * Left button -- 0
+ * Middle button -- 1
+ * Right button -- 2
+ * @param args - button and/or keyCode
  * @example
  * // enable the keyboard
  * me.input.bindKey(me.input.KEY.X, "shoot");
@@ -52,22 +66,20 @@ export function setTouchAction(element: HTMLCanvasElement, value?: string): void
  * // map the right button click on the X key
  * me.input.bindPointer(me.input.pointer.RIGHT, me.input.KEY.X);
  */
-export function bindPointer(...args: any[]): void;
+export declare function bindPointer(...args: number[]): void;
 /**
  * unbind the defined keycode
- * @memberof input
- * @param {number} [button=input.pointer.LEFT] - (accordingly to W3C values : 0,1,2 for left, middle and right buttons)
+ * @param button - (accordingly to W3C values : 0,1,2 for left, middle and right buttons)
  * @example
  * me.input.unbindPointer(me.input.pointer.LEFT);
  */
-export function unbindPointer(button?: number): void;
+export declare function unbindPointer(button?: number): void;
 /**
  * allows registration of event listeners on the object target. <br>
  * melonJS will pass a me.Pointer object to the defined callback.
  * @see Pointer
  * @see {@link http://www.w3.org/TR/pointerevents/#list-of-pointer-events | W3C Pointer Event list}
- * @memberof input
- * @param {string} eventType - The event type for which the object is registering <br>
+ * @param eventType - The event type for which the object is registering <br>
  * melonJS currently supports: <br>
  * <ul>
  *   <li><code>"pointermove"</code></li>
@@ -79,8 +91,8 @@ export function unbindPointer(button?: number): void;
  *   <li><code>"pointercancel"</code></li>
  *   <li><code>"wheel"</code></li>
  * </ul>
- * @param {Rect|Polygon|Line|Ellipse} region - a shape representing the region to register on
- * @param {Function} callback - methods to be called when the event occurs.
+ * @param region - a shape representing the region to register on
+ * @param callback - methods to be called when the event occurs.
  * Returning `false` from the defined callback will prevent the event to be propagated to other objects
  * @example
  *  // onActivate function
@@ -97,33 +109,30 @@ export function unbindPointer(button?: number): void;
  *    return false;
  *  },
  */
-export function registerPointerEvent(eventType: string, region: Rect | Polygon | Line | Ellipse, callback: Function): void;
+export declare function registerPointerEvent(eventType: string, region: any, callback: (pointer: Pointer) => boolean | void): void;
 /**
  * allows the removal of event listeners from the object target.
  * @see {@link http://www.w3.org/TR/pointerevents/#list-of-pointer-events|W3C Pointer Event list}
- * @memberof input
- * @param {string} eventType - The event type for which the object was registered. See {@link input.registerPointerEvent}
- * @param {Rect|Polygon|Line|Ellipse} region - the registered region to release for this event
- * @param {Function} [callback="all"] - if specified unregister the event only for the specific callback
+ * @param eventType - The event type for which the object was registered. See {@link input.registerPointerEvent}
+ * @param region - the registered region to release for this event
+ * @param callback - if specified unregister the event only for the specific callback
  * @example
  * // release the registered region on the 'pointerdown' event
  * me.input.releasePointerEvent('pointerdown', this);
  */
-export function releasePointerEvent(eventType: string, region: Rect | Polygon | Line | Ellipse, callback?: Function): void;
+export declare function releasePointerEvent(eventType: string, region: any, callback?: (pointer: Pointer) => boolean | void): void;
 /**
  * allows the removal of all registered event listeners from the object target.
- * @memberof input
- * @param {Rect|Polygon|Line|Ellipse} region - the registered region to release event from
+ * @param region - the registered region to release event from
  * @example
  * // release all registered event on the
  * me.input.releaseAllPointerEvents(this);
  */
-export function releaseAllPointerEvents(region: Rect | Polygon | Line | Ellipse): void;
+export declare function releaseAllPointerEvents(region: any): void;
 /**
  * request for the pointer to be locked on the parent DOM element.
  * (Must be called in a click event or an event that requires user interaction)
- * @memberof input
- * @returns {boolean} return true if the request was successfully submitted
+ * @returns return true if the request was successfully submitted
  * @example
  * // register on the pointer lock change event
  * event.on(event.POINTERLOCKCHANGE, (locked)=> {
@@ -132,47 +141,10 @@ export function releaseAllPointerEvents(region: Rect | Polygon | Line | Ellipse)
  * // request for pointer lock
  * me.input.requestPointerLock();
  */
-export function requestPointerLock(): boolean;
+export declare function requestPointerLock(): boolean;
 /**
  * Initiates an exit from pointer lock state
- * @memberof input
- * @returns {boolean} return true if the request was successfully submitted
- */
-export function exitPointerLock(): boolean;
-/**
- * the default target element for pointer events (usually the canvas element in which the game is rendered)
- * @public
- * @type {EventTarget}
- * @name pointerEventTarget
- * @memberof input
- */
-export let pointerEventTarget: EventTarget;
-/**
- * Pointer information (current position and size)
- * @public
- * @type {Rect}
- * @name pointer
- * @memberof input
- */
-export const pointer: Rect;
-/**
- * indicates if the pointer is currently locked
- * @public
- * @type {boolean}
- * @name locked
- * @memberof input
- */
-export let locked: boolean;
-/**
- * time interval for event throttling in milliseconds<br>
- * default value : "1000/me.timer.maxfps" ms<br>
- * set to 0 ms to disable the feature
- * @public
- * @type {number}
- * @name throttlingInterval
- * @memberof input
+ * @returns return true if the request was successfully submitted
  */
-export let throttlingInterval: number;
-import type { Vector2d } from "../math/vector2d.js";
-import { Rect } from "./../geometries/rectangle.ts";
+export declare function exitPointerLock(): boolean;
 //# sourceMappingURL=pointerevent.d.ts.map