@woosh/meep-engine 2.165.6 → 2.165.7

package/src/engine/input/devices/KeyCodes.d.ts

@@ -1 +1,112 @@
-export const KeyCodes: { [name: string]: number };
+/**
+ * Valid keyboard keys
+ */
+export type KeyCodes = number;
+/**
+ * Valid keyboard keys
+ * @readonly
+ * @enum {number}
+ */
+export const KeyCodes: {
+    backspace: number;
+    tab: number;
+    enter: number;
+    shift: number;
+    ctrl: number;
+    alt: number;
+    pause_break: number;
+    caps_lock: number;
+    escape: number;
+    space: number;
+    page_up: number;
+    page_down: number;
+    end: number;
+    home: number;
+    left_arrow: number;
+    up_arrow: number;
+    right_arrow: number;
+    down_arrow: number;
+    insert: number;
+    delete: number;
+    '0': number;
+    '1': number;
+    '2': number;
+    '3': number;
+    '4': number;
+    '5': number;
+    '6': number;
+    '7': number;
+    '8': number;
+    '9': number;
+    a: number;
+    b: number;
+    c: number;
+    d: number;
+    e: number;
+    f: number;
+    g: number;
+    h: number;
+    i: number;
+    j: number;
+    k: number;
+    l: number;
+    m: number;
+    n: number;
+    o: number;
+    p: number;
+    q: number;
+    r: number;
+    s: number;
+    t: number;
+    u: number;
+    v: number;
+    w: number;
+    x: number;
+    y: number;
+    z: number;
+    'left_window key': number;
+    'right_window key': number;
+    select_key: number;
+    numpad_0: number;
+    numpad_1: number;
+    numpad_2: number;
+    numpad_3: number;
+    numpad_4: number;
+    numpad_5: number;
+    numpad_6: number;
+    numpad_7: number;
+    numpad_8: number;
+    numpad_9: number;
+    multiply: number;
+    add: number;
+    subtract: number;
+    decimal_point: number;
+    divide: number;
+    f1: number;
+    f2: number;
+    f3: number;
+    f4: number;
+    f5: number;
+    f6: number;
+    f7: number;
+    f8: number;
+    f9: number;
+    f10: number;
+    f11: number;
+    f12: number;
+    num_lock: number;
+    scroll_lock: number;
+    semi_colon: number;
+    equal_sign: number;
+    comma: number;
+    dash: number;
+    period: number;
+    forward_slash: number;
+    grave_accent: number;
+    open_bracket: number;
+    backslash: number;
+    close_bracket: number;
+    single_quote: number;
+    back_quote: number;
+};
+//# sourceMappingURL=KeyCodes.d.ts.map

package/src/engine/input/devices/KeyboardDevice.d.ts

@@ -24,12 +24,12 @@ declare class KeyboardDevice {
          * Fires when any key is pressed
          * @type {Signal<KeyboardEvent>}
          */
-        down: Signal<KeyboardEvent>;
+        down: any;
         /**
          * Fires when any key is released
          * @type {Signal<KeyboardEvent>}
          */
-        up: Signal<KeyboardEvent>;
+        up: any;
     };
     /**
      * See {@link KeyCodes} for valid IDs
@@ -57,5 +57,4 @@ declare class KeyboardDevice {
     stop(): void;
     #private;
 }
-import Signal from "../../../core/events/signal/Signal.js";
 //# sourceMappingURL=KeyboardDevice.d.ts.map

package/src/engine/input/devices/KeyboardDevice.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"KeyboardDevice.d.ts","sourceRoot":"","sources":["../../../../../src/engine/input/devices/KeyboardDevice.js"],"names":[],"mappings":";AAYA;;;;;;;;;;GAUG;AACH;IA4BI;;;OAGG;IACH,wBAHW,WAAW,GAAC,OAAO,EAgC7B;IA3DD;;OAEG;IACH;QACI;;;WAGG;cADO,OAAO,aAAa,CAAC;QAG/B;;;WAGG;YADO,OAAO,aAAa,CAAC;MAGjC;IAEF;;;;;;;OAOG;IACH,mBAAU;IAkBN;;;OAGG;IACH,YAFU,WAAW,CAEO;IA2HhC;;;OAGG;IACH,SAFa,IAAI,CAWhB;IAED;;;OAGG;IACH,QAFa,IAAI,CAUhB;;CAEJ;mBA/NkB,uCAAuC"}
+{"version":3,"file":"KeyboardDevice.d.ts","sourceRoot":"","sources":["../../../../../src/engine/input/devices/KeyboardDevice.js"],"names":[],"mappings":";AAYA;;;;;;;;;;GAUG;AACH;IA4BI;;;OAGG;IACH,wBAHW,WAAW,GAAC,OAAO,EAgC7B;IA3DD;;OAEG;IACH;QACI;;;WAGG;;QAEH;;;WAGG;;MAEL;IAEF;;;;;;;OAOG;IACH,mBAAU;IAkBN;;;OAGG;IACH,YAFU,WAAW,CAEO;IA2HhC;;;OAGG;IACH,SAFa,IAAI,CAWhB;IAED;;;OAGG;IACH,QAFa,IAAI,CAUhB;;CAEJ"}

package/src/engine/input/devices/PointerDevice.d.ts

@@ -1,31 +1,96 @@
-import Signal from "../../../core/events/signal/Signal";
-import Vector2 from "../../../core/geom/Vector2";
-import Vector3 from "../../../core/geom/Vector3";
-import {InputDeviceSwitch} from "./InputDeviceSwitch";
-
-export class PointerDevice {
-    constructor(element:EventTarget)
-
-    start(): void
-
-    stop(): void
-
-    readonly position: Vector2
-
-    readonly buttons: InputDeviceSwitch[]
-
-    readonly mouseButtonLeft: InputDeviceSwitch
-    readonly mouseButtonRight: InputDeviceSwitch
-    readonly mouseButtonMiddle: InputDeviceSwitch
-
-    readonly on: {
-        down: Signal<Vector2, MouseEvent | TouchEvent>,
-        up: Signal<Vector2, MouseEvent | TouchEvent>,
-        move: Signal<Vector2 /*position*/, MouseEvent | TouchEvent, Vector2 /*delta*/>,
-        tap: Signal<Vector2, MouseEvent | TouchEvent>,
-        drag: Signal<Vector2, Vector2, Vector2, MouseEvent | TouchEvent>,
-        dragStart: Signal<Vector2, MouseEvent | TouchEvent>,
-        dragEnd: Signal<Vector2>,
-        wheel: Signal<Vector3, Vector2, WheelEvent>,
-    }
-}
+/**
+ *
+ * @param {Vector2} result
+ * @param {MouseEvent|Touch} event
+ * @param {Element} source
+ */
+export function readPositionFromMouseEvent(result: Vector2, event: MouseEvent | Touch, source?: Element): void;
+/**
+ * Abstracts Mouse and Touch interfaces as single "pointer" device.
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+export class PointerDevice {
+    /**
+     *
+     * @param {EventTarget} domElement html element
+     * @constructor
+     */
+    constructor(domElement: EventTarget);
+    /**
+     * Current live position of the pointer
+     * @readonly
+     * @type {Vector2}
+     */
+    readonly position: Vector2;
+    /**
+     * @readonly
+     */
+    readonly on: {
+        down: Signal;
+        up: Signal;
+        move: Signal;
+        /**
+         * @type {Signal<Vector2, (MouseEvent|TouchEvent)>}
+         */
+        tap: any;
+        drag: Signal;
+        dragStart: Signal;
+        dragEnd: Signal;
+        wheel: Signal;
+        pinch: Signal;
+        pinchStart: Signal;
+        pinchEnd: Signal;
+    };
+    /**
+     * @private
+     * @type {boolean}
+     */
+    private isRunning;
+    /**
+     * The {@link MouseEvent.buttons} is a 32bit field, which means we can encode up to 32 buttons
+     * @readonly
+     * @type {InputDeviceSwitch[]}
+     */
+    readonly buttons: InputDeviceSwitch[];
+    /**
+     *
+     * @returns {InputDeviceSwitch}
+     */
+    get mouseButtonLeft(): InputDeviceSwitch;
+    /**
+     *
+     * @returns {InputDeviceSwitch}
+     */
+    get mouseButtonRight(): InputDeviceSwitch;
+    /**
+     *
+     * @returns {InputDeviceSwitch}
+     */
+    get mouseButtonMiddle(): InputDeviceSwitch;
+    /**
+     *
+     * @return {Element}
+     */
+    getTargetElement(): Element;
+    /**
+     *
+     * @param {Element} el
+     */
+    set domElement(arg: Element);
+    get domElement(): Element;
+    /**
+     *
+     * @param {Vector2} result
+     * @param {MouseEvent|Touch} event
+     */
+    readPointerPositionFromEvent(result: Vector2, event: MouseEvent | Touch): void;
+    start(): void;
+    stop(): void;
+    #private;
+}
+import Vector2 from "../../../core/geom/Vector2.js";
+import Signal from "../../../core/events/signal/Signal.js";
+import { InputDeviceSwitch } from "./InputDeviceSwitch.js";
+//# sourceMappingURL=PointerDevice.d.ts.map

package/src/engine/input/devices/PointerDevice.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"PointerDevice.d.ts","sourceRoot":"","sources":["../../../../../src/engine/input/devices/PointerDevice.js"],"names":[],"mappings":"AA6MA;;;;;GAKG;AACH,mDAJW,OAAO,SACP,UAAU,GAAC,KAAK,WAChB,OAAO,QAejB;AAED;;;;;GAKG;AACH;IAiFI;;;;OAIG;IACH,wBAHW,WAAW,EAsBrB;IAvGD;;;;OAIG;IACH,mBAFU,OAAO,CAEQ;IAIzB;;OAEG;IACH;;;;QAII;;WAEG;aADO,OAAO,OAAO,EAAE,CAAC,UAAU,GAAC,UAAU,CAAC,CAAC;;;;;;;;MAUpD;IAeF;;;OAGG;IACH,kBAAkB;IAElB;;;;OAIG;IACH,kBAFU,iBAAiB,EAAE,CAEL;IAExB;;;OAGG;IACH,yCAEC;IAED;;;OAGG;IACH,0CAEC;IAED;;;OAGG;IACH,2CAEC;IA2GD;;;OAGG;IACH,oBAFY,OAAO,CAIlB;IAED;;;OAGG;IACH,6BAsBC;IAED,0BAEC;IAED;;;;OAIG;IACH,qCAHW,OAAO,SACP,UAAU,GAAC,KAAK,QAI1B;IAED,cA6BC;IAED,aAsBC;;CACJ;oBAvgBmB,+BAA+B;mBADhC,uCAAuC;kCAOxB,wBAAwB"}
+{"version":3,"file":"PointerDevice.d.ts","sourceRoot":"","sources":["../../../../../src/engine/input/devices/PointerDevice.js"],"names":[],"mappings":"AA6MA;;;;;GAKG;AACH,mDAJW,OAAO,SACP,UAAU,GAAC,KAAK,WAChB,OAAO,QAejB;AAED;;;;;GAKG;AACH;IAiFI;;;;OAIG;IACH,wBAHW,WAAW,EAsBrB;IAvGD;;;;OAIG;IACH,mBAFU,OAAO,CAEQ;IAIzB;;OAEG;IACH;;;;QAII;;WAEG;;;;;;;;;MASL;IAeF;;;OAGG;IACH,kBAAkB;IAElB;;;;OAIG;IACH,kBAFU,iBAAiB,EAAE,CAEL;IAExB;;;OAGG;IACH,yCAEC;IAED;;;OAGG;IACH,0CAEC;IAED;;;OAGG;IACH,2CAEC;IA2GD;;;OAGG;IACH,oBAFY,OAAO,CAIlB;IAED;;;OAGG;IACH,6BAsBC;IAED,0BAEC;IAED;;;;OAIG;IACH,qCAHW,OAAO,SACP,UAAU,GAAC,KAAK,QAI1B;IAED,cA6BC;IAED,aAsBC;;CACJ;oBAvgBmB,+BAA+B;mBADhC,uCAAuC;kCAOxB,wBAAwB"}

package/src/engine/input/devices/events/KeyboardEvents.d.ts

@@ -1,4 +1,5 @@
-export enum KeyboardEvents {
-    KeyUp = 'keyup',
-    KeyDown = 'keydown'
-}
+export namespace KeyboardEvents {
+    let KeyUp: string;
+    let KeyDown: string;
+}
+//# sourceMappingURL=KeyboardEvents.d.ts.map

package/src/engine/input/devices/events/MouseEvents.d.ts

@@ -1,12 +1,18 @@
-export enum MouseEvents {
-    Down = "mousedown",
-    Up = "mouseup",
-    Move = "mousemove",
-    Enter = "mouseenter",
-    Leave = "mouseleave",
-    Out = "mouseout",
-    Over = "mouseover",
-    Wheel = "wheel",
-    Click = "click",
-    DoubleClick = "dblclick"
-}
+/**
+ * Event names for DOM {@link EventTarget } related to mouse.
+ * useful for .addEventListener and .removeEventListener
+ */
+export type MouseEvents = string;
+export namespace MouseEvents {
+    let Down: string;
+    let Up: string;
+    let Move: string;
+    let Enter: string;
+    let Leave: string;
+    let Out: string;
+    let Over: string;
+    let Wheel: string;
+    let Click: string;
+    let DoubleClick: string;
+}
+//# sourceMappingURL=MouseEvents.d.ts.map

package/src/engine/input/devices/events/TouchEvents.d.ts

@@ -1,6 +1,12 @@
-export enum TouchEvents {
-    Start = "touchstart",
-    End = "touchend",
-    Move = "touchmove",
-    Cancel = "touchcancel",
-}
+/**
+ * Event names for DOM {@link EventTarget } related to touch.
+ * useful for .addEventListener and .removeEventListener
+ */
+export type TouchEvents = string;
+export namespace TouchEvents {
+    let Start: string;
+    let End: string;
+    let Move: string;
+    let Cancel: string;
+}
+//# sourceMappingURL=TouchEvents.d.ts.map

package/src/engine/input/devices/gamepad/GamepadAxes.d.ts

@@ -2,7 +2,11 @@
  * Axis indices for the "standard" gamepad mapping
  * see https://w3c.github.io/gamepad/#remapping
  *
- * Negative values are left/up, positive values are right/down
+ * Hardware frame: +x is right, +y is down. Negative values are left/up.
+ *
+ * That frame is kept all the way through {@link GamepadStickvalue } and {@link gamepad_write_dpad_vector }.
+ * Converting it into a game frame depends on the camera, so it belongs in a controller - see
+ * {@link KeyboardCameraController } for the equivalent on the keyboard side.
  */
 export type GamepadAxes = number;
 export namespace GamepadAxes {

package/src/engine/input/devices/gamepad/GamepadAxes.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"GamepadAxes.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/input/devices/gamepad/GamepadAxes.js"],"names":[],"mappings":";;;;;;0BAOU,MAAM"}
+{"version":3,"file":"GamepadAxes.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/input/devices/gamepad/GamepadAxes.js"],"names":[],"mappings":";;;;;;;;;;0BAWU,MAAM"}

package/src/engine/input/devices/gamepad/GamepadAxes.js

@@ -2,7 +2,11 @@
  * Axis indices for the "standard" gamepad mapping
  * see https://w3c.github.io/gamepad/#remapping
  *
- * Negative values are left/up, positive values are right/down
+ * Hardware frame: +x is right, +y is down. Negative values are left/up.
+ *
+ * That frame is kept all the way through {@link GamepadStick#value} and {@link gamepad_write_dpad_vector}.
+ * Converting it into a game frame depends on the camera, so it belongs in a controller - see
+ * {@link KeyboardCameraController} for the equivalent on the keyboard side.
  *
  * @readonly
  * @enum {number}

package/src/engine/input/devices/gamepad/GamepadHandle.d.ts

@@ -1,29 +1,133 @@
-import Signal from "../../../../core/events/signal/Signal";
-import Vector2 from "../../../../core/geom/Vector2";
-import {InputDeviceSwitch} from "../InputDeviceSwitch";
-
+/**
+ * State of a single physical gamepad.
+ * Native {@link Gamepad} objects are immutable snapshots in most browsers, this class provides a stable, observable
+ * representation that is refreshed from those snapshots via {@link GamepadHandle#update}.
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
 export class GamepadHandle {
-    readonly index: number
-    readonly id: string
-    readonly mapping: string
-    readonly connected: boolean
-
-    readonly buttons: InputDeviceSwitch[]
-    readonly buttonValues: number[]
-    readonly axes: number[]
-
-    readonly stickLeft: Vector2
-    readonly stickRight: Vector2
-
-    getButton(index: number): InputDeviceSwitch
-
-    update(source: Gamepad, deadZone?: number): void
-
-    reset(): void
-
+    /**
+     * Index of the gamepad within {@link Navigator.getGamepads} list
+     * @type {number}
+     */
+    index: number;
+    /**
+     * Identification string of the hardware, contents are browser-specific
+     * @type {string}
+     */
+    id: string;
+    /**
+     * Button/axis layout, "standard" for the standard mapping
+     * see https://w3c.github.io/gamepad/#remapping
+     * @type {string}
+     */
+    mapping: string;
+    /**
+     * Whether the gamepad is currently connected
+     * Do not modify directly
+     * @type {boolean}
+     */
+    connected: boolean;
+    /**
+     * Order in which this pad was connected, used to pick a successor when the active pad is lost.
+     * Lower is older. Meaningless while {@link connected} is false.
+     * Do not modify directly
+     * @type {number}
+     */
+    connectionIndex: number;
+    /**
+     * @readonly
+     */
     readonly on: {
-        down: Signal<number /*buttonIndex*/>,
-        up: Signal<number /*buttonIndex*/>,
-        axis: Signal<number /*axisIndex*/, number /*value*/, number /*previousValue*/>
-    }
+        /**
+         * Fires when any button is pressed, dispatches button index
+         * @type {Signal<number>}
+         */
+        down: any;
+        /**
+         * Fires when any button is released, dispatches button index
+         * @type {Signal<number>}
+         */
+        up: any;
+        /**
+         * Fires when an axis value changes, dispatches (axisIndex, value, previousValue)
+         * @type {Signal<number, number, number>}
+         */
+        axis: any;
+    };
+    /**
+     * Individual button switches, indexed by button index.
+     * For the standard mapping, see {@link GamepadButtons} for valid indices.
+     *
+     * Every index of the standard mapping is materialized up front, so reads need no guard - a button the
+     * hardware does not have simply never goes down. Hardware exposing more than the standard button count
+     * grows the array during {@link GamepadHandle#update}.
+     *
+     * @readonly
+     * @type {InputDeviceSwitch[]}
+     *
+     * @example
+     *   const is_jumping = pad.buttons[GamepadButtons.a].is_down;
+     */
+    readonly buttons: InputDeviceSwitch[];
+    /**
+     * Analog values of the buttons in the range [0,1], indexed by button index.
+     * Useful for analog triggers.
+     * @readonly
+     * @type {number[]}
+     */
+    readonly buttonValues: number[];
+    /**
+     * Axis values in the range [-1,1], exactly as reported by the hardware.
+     * For the standard mapping, see {@link GamepadAxes} for valid indices.
+     *
+     * Uncorrected: a resting stick rarely reads 0 here. Read {@link stickLeft}/{@link stickRight} for values
+     * with the learned rest position removed.
+     *
+     * @readonly
+     * @type {number[]}
+     */
+    readonly axes: number[];
+    /**
+     * Left stick of the standard mapping, axes 0 and 1
+     * @readonly
+     * @type {GamepadStick}
+     */
+    readonly stickLeft: GamepadStick;
+    /**
+     * Right stick of the standard mapping, axes 2 and 3
+     * @readonly
+     * @type {GamepadStick}
+     */
+    readonly stickRight: GamepadStick;
+    /**
+     * Returns switch for a given button index, creating it if it doesn't exist yet
+     *
+     * @param {number} index
+     * @returns {InputDeviceSwitch}
+     */
+    getButton(index: number): InputDeviceSwitch;
+    /**
+     * Refresh state from a native {@link Gamepad} snapshot
+     *
+     * @param {Gamepad} source native gamepad object
+     */
+    update(source: Gamepad): void;
+    /**
+     * Release all buttons and reset axes to neutral.
+     * Used when the gamepad disconnects, to avoid inputs getting "stuck" in pressed state.
+     */
+    reset(): void;
+    /**
+     * Discard what has been learned about the sticks.
+     * Used when this handle starts representing different hardware, either because a pad was plugged into a
+     * slot another pad used to occupy, or because {@link GamepadDevice#main} moved to a different pad.
+     *
+     * @returns {void}
+     */
+    forgetCalibration(): void;
 }
+import { InputDeviceSwitch } from "../InputDeviceSwitch.js";
+import { GamepadStick } from "./GamepadStick.js";
+//# sourceMappingURL=GamepadHandle.d.ts.map

package/src/engine/input/devices/gamepad/GamepadHandle.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"GamepadHandle.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/input/devices/gamepad/GamepadHandle.js"],"names":[],"mappings":"AAIA;;;;;;;GAOG;AACH;IAEI;;;OAGG;IACH,OAFU,MAAM,CAEL;IAEX;;;OAGG;IACH,IAFU,MAAM,CAER;IAER;;;;OAIG;IACH,SAFU,MAAM,CAEH;IAEb;;;;OAIG;IACH,WAFU,OAAO,CAEC;IAElB;;OAEG;IACH;QACI;;;WAGG;cADO,OAAO,MAAM,CAAC;QAGxB;;;WAGG;YADO,OAAO,MAAM,CAAC;QAGxB;;;WAGG;cADO,OAAO,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC;MAG1C;IAEF;;;;;;;;;;OAUG;IACH,kBALU,iBAAiB,EAAE,CAKhB;IAEb;;;;;OAKG;IACH,uBAFU,MAAM,EAAE,CAEA;IAElB;;;;;OAKG;IACH,eAFU,MAAM,EAAE,CAER;IAEV;;;;OAIG;IACH,oBAFU,OAAO,CAES;IAE1B;;;;OAIG;IACH,qBAFU,OAAO,CAEU;IAE3B;;;;;OAKG;IACH,iBAHW,MAAM,GACJ,iBAAiB,CAa7B;IAED;;;;;OAKG;IACH,eAHW,OAAO,aACP,MAAM,QAkEhB;IAED;;;OAGG;IACH,cA+BE;CACL;mBAvOkB,0CAA0C;kCAE3B,yBAAyB;oBADvC,kCAAkC"}
+{"version":3,"file":"GamepadHandle.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/input/devices/gamepad/GamepadHandle.js"],"names":[],"mappings":"AAMA;;;;;;;GAOG;AACH;IAEI;;;OAGG;IACH,OAFU,MAAM,CAEL;IAEX;;;OAGG;IACH,IAFU,MAAM,CAER;IAER;;;;OAIG;IACH,SAFU,MAAM,CAEH;IAEb;;;;OAIG;IACH,WAFU,OAAO,CAEC;IAElB;;;;;OAKG;IACH,iBAFU,MAAM,CAEK;IAErB;;OAEG;IACH;QACI;;;WAGG;;QAEH;;;WAGG;;QAEH;;;WAGG;;MAEL;IAEF;;;;;;;;;;;;;OAaG;IACH,kBALU,iBAAiB,EAAE,CAKhB;IAEb;;;;;OAKG;IACH,uBAFU,MAAM,EAAE,CAEA;IAElB;;;;;;;;;OASG;IACH,eAFU,MAAM,EAAE,CAER;IAEV;;;;OAIG;IACH,oBAFU,YAAY,CAE2D;IAEjF;;;;OAIG;IACH,qBAFU,YAAY,CAE8D;IAapF;;;;;OAKG;IACH,iBAHW,MAAM,GACJ,iBAAiB,CAa7B;IAED;;;;OAIG;IACH,eAFW,OAAO,QAqDjB;IAED;;;OAGG;IACH,cA+BC;IAED;;;;;;OAMG;IACH,qBAFa,IAAI,CAKhB;CACJ;kCAhQiC,yBAAyB;6BAE9B,mBAAmB"}