@utsp/input 0.10.0-nightly.20251211194839.e68c16e → 0.10.0

package/dist/desktop.d.ts

@@ -0,0 +1,540 @@
+import { Vector2, Vector3 } from '@utsp/types';
+export { InputDeviceType, KeyboardInput, MouseInput, Vector2 } from '@utsp/types';
+
+/**
+ * Base interface for all input management systems
+ * This provides a common API for keyboard, mouse, gamepad, and touch inputs
+ */
+interface IInputs {
+    /**
+     * Start listening to input events
+     */
+    start(): void;
+    /**
+     * Stop listening to input events and cleanup
+     */
+    stop(): void;
+    /**
+     * Reset all input states to default
+     */
+    reset(): void;
+    /**
+     * Check if the input system is currently active/listening
+     */
+    isListening(): boolean;
+    /**
+     * Cleanup and destroy the instance, removing all event listeners
+     */
+    destroy(): void;
+    /**
+     * Reset delta values (call at the end of each frame/update)
+     */
+    resetDelta(): void;
+    /**
+     * Set or update event callbacks
+     */
+    setCallbacks(callbacks: unknown): void;
+    /**
+     * Remove all event callbacks
+     */
+    clearCallbacks(): void;
+    /**
+     * Check if a key is currently pressed (Keyboard)
+     */
+    isKeyPressed?(key: string): boolean;
+    /**
+     * Check if left mouse button is pressed (Mouse)
+     */
+    isLeftMousePressed?(): boolean;
+    /**
+     * Get mouse position (Mouse)
+     */
+    getMousePosition?(): Vector2 | null;
+    /**
+     * Get mouse movement delta (Mouse)
+     */
+    getMouseDelta?(): Vector2 | null;
+    /**
+     * Get wheel delta (Mouse)
+     */
+    getWheelDelta?(): Vector2 | null;
+    /**
+     * Check if a button is pressed (Gamepad, TVRemote)
+     */
+    isButtonPressed?(button: string | number): boolean;
+    /**
+     * Get axis value (Gamepad, TVRemote)
+     */
+    getAxis?(axis: number): number | null;
+    /**
+     * Get motion/gyroscope data (TVRemote, Mobile)
+     */
+    getMotionData?(): MotionData | null;
+}
+/**
+ * Motion/Gyroscope data interface
+ */
+interface MotionData extends Vector3 {
+    timestamp?: number;
+}
+/**
+ * Common button state interface
+ */
+interface ButtonState {
+    pressed: boolean;
+    justPressed: boolean;
+    justReleased: boolean;
+    timestamp?: number;
+}
+/**
+ * Input event types enumeration
+ */
+declare enum InputEventType {
+    KeyDown = "keydown",
+    KeyUp = "keyup",
+    MouseDown = "mousedown",
+    MouseUp = "mouseup",
+    MouseMove = "mousemove",
+    MouseWheel = "mousewheel",
+    TouchStart = "touchstart",
+    TouchEnd = "touchend",
+    TouchMove = "touchmove",
+    GamepadConnected = "gamepadconnected",
+    GamepadDisconnected = "gamepaddisconnected",
+    GamepadButton = "gamepadbutton",
+    GamepadAxis = "gamepadaxis"
+}
+/**
+ * Configuration options for input systems
+ */
+interface InputConfig {
+    /**
+     * Target element to attach listeners to (default: window)
+     */
+    targetElement?: HTMLElement | Window;
+    /**
+     * Enable/disable specific input types
+     */
+    enabled?: boolean;
+    /**
+     * Prevent default browser behaviors
+     */
+    preventDefault?: boolean;
+    /**
+     * Stop event propagation
+     */
+    stopPropagation?: boolean;
+    /**
+     * Enable debug logging
+     */
+    debug?: boolean;
+}
+/**
+ * Abstract base class for input systems
+ * All input classes should extend this to maintain consistency
+ */
+declare abstract class BaseInputs implements IInputs {
+    protected isActive: boolean;
+    protected targetElement: HTMLElement | Window;
+    protected config: InputConfig;
+    protected callbacks: Record<string, ((...args: any[]) => void)[]>;
+    constructor(targetElement?: HTMLElement | Window, config?: InputConfig);
+    abstract start(): void;
+    abstract stop(): void;
+    abstract reset(): void;
+    abstract resetDelta(): void;
+    isListening(): boolean;
+    destroy(): void;
+    setCallbacks(callbacks: unknown): void;
+    clearCallbacks(): void;
+    /**
+     * Get the target element
+     */
+    getTargetElement(): HTMLElement | Window;
+    /**
+     * Enable the input system
+     */
+    enable(): void;
+    /**
+     * Disable the input system
+     */
+    disable(): void;
+    /**
+     * Check if the input system is enabled
+     */
+    isEnabled(): boolean;
+    /**
+     * Emit an event to all registered callbacks
+     */
+    protected emit(eventType: string, ...args: unknown[]): void;
+    /**
+     * Log debug messages if debug mode is enabled
+     */
+    protected log(...args: unknown[]): void;
+}
+
+/**
+ * KeyboardInputs - Keyboard input management
+ * Handles keyboard events with support for vanilla JS, React, and other frameworks
+ */
+
+/**
+ * Keyboard button state with press/release detection
+ */
+interface KeyButtonState {
+    pressed: boolean;
+    justPressed: boolean;
+    justReleased: boolean;
+}
+interface KeyState {
+    [key: string]: KeyButtonState;
+}
+interface KeyboardCallbacks {
+    onKeyDown?: (key: string, event: KeyboardEvent) => void;
+    onKeyUp?: (key: string, event: KeyboardEvent) => void;
+}
+declare class KeyboardInputs extends BaseInputs {
+    private keys;
+    private keyboardCallbacks;
+    private textInputsThisFrame;
+    private boundHandlers;
+    constructor(targetElement?: HTMLElement | Window, config?: InputConfig);
+    start(): void;
+    stop(): void;
+    reset(): void;
+    resetDelta(): void;
+    /**
+     * Poll - Reset transient states (justPressed/justReleased)
+     * Should be called once per frame AFTER collecting input
+     */
+    poll(): void;
+    /**
+     * Get text inputs captured this frame
+     * Returns actual characters typed (handles keyboard layout, modifiers, etc.)
+     *
+     * @returns Array of character strings typed this frame
+     *
+     * @example
+     * ```typescript
+     * const textInputs = keyboard.getTextInputs();
+     * textInputs.forEach(char => chatBox.append(char));
+     * ```
+     */
+    getTextInputs(): string[];
+    /**
+     * Check if a key is currently pressed
+     *
+     * @param key - Key code (e.g., 'Space', 'KeyA', 'ArrowUp')
+     * @returns True if key is pressed, false otherwise
+     *
+     * @example
+     * ```typescript
+     * if (keyboard.isKeyPressed('Space')) {
+     *   player.jump();
+     * }
+     *
+     * if (keyboard.isKeyPressed('KeyW')) {
+     *   player.moveForward();
+     * }
+     * ```
+     */
+    isKeyPressed(key: string): boolean;
+    /**
+     * Check if a key was just pressed this frame
+     *
+     * @param key - Key code (e.g., 'Space', 'KeyA', 'ArrowUp')
+     * @returns True if key was just pressed (transition false→true), false otherwise
+     *
+     * @example
+     * ```typescript
+     * if (keyboard.isKeyJustPressed('Space')) {
+     *   player.jump(); // Jump once per press
+     * }
+     * ```
+     */
+    isKeyJustPressed(key: string): boolean;
+    /**
+     * Check if a key was just released this frame
+     *
+     * @param key - Key code (e.g., 'Space', 'KeyA', 'ArrowUp')
+     * @returns True if key was just released (transition true→false), false otherwise
+     *
+     * @example
+     * ```typescript
+     * if (keyboard.isKeyJustReleased('Space')) {
+     *   releaseChargedShot();
+     * }
+     * ```
+     */
+    isKeyJustReleased(key: string): boolean;
+    /**
+     * Get all currently pressed keys
+     *
+     * @returns Array of key codes currently pressed
+     *
+     * @example
+     * ```typescript
+     * const keys = keyboard.getKeysPressed();
+     * console.log('Pressed keys:', keys); // ['KeyW', 'Space']
+     * ```
+     */
+    getKeysPressed(): string[];
+    /**
+     * Get all keys that were just pressed this frame
+     */
+    getKeysJustPressed(): string[];
+    /**
+     * Get all keys that were just released this frame
+     */
+    getKeysJustReleased(): string[];
+    /**
+     * Check if any key is currently pressed
+     *
+     * @returns True if at least one key is pressed, false otherwise
+     *
+     * @example
+     * ```typescript
+     * if (keyboard.isAnyKeyPressed()) {
+     *   console.log('Player is active');
+     * }
+     * ```
+     */
+    isAnyKeyPressed(): boolean;
+    /**
+     * Set keyboard-specific callbacks
+     *
+     * @param callbacks - Object containing callback functions
+     *
+     * @example
+     * ```typescript
+     * keyboard.setKeyboardCallbacks({
+     *   onKeyDown: (key, event) => {
+     *     console.log(`Key pressed: ${key}`);
+     *   },
+     *   onKeyUp: (key, event) => {
+     *     console.log(`Key released: ${key}`);
+     *   },
+     * });
+     * ```
+     */
+    setKeyboardCallbacks(callbacks: KeyboardCallbacks): void;
+    clearKeyboardCallbacks(): void;
+    setCallbacks(callbacks: KeyboardCallbacks | unknown): void;
+    private isKeyboardCallbacks;
+    /**
+     * Check if browser default behavior should be allowed for this keyboard event
+     *
+     * Returns true for:
+     * - Function keys (F1-F12)
+     * - Browser shortcuts (Ctrl+T, Ctrl+W, Ctrl+R, Ctrl+N, Ctrl+Tab)
+     */
+    private shouldAllowDefault;
+    private handleKeyDown;
+    private handleKeyUp;
+}
+/**
+ * React hook for keyboard inputs
+ */
+declare function useKeyboardInputs(targetElement?: HTMLElement | Window, callbacks?: KeyboardCallbacks): KeyboardInputs;
+
+/**
+ * MouseInputs - Mouse input management
+ * Handles mouse events with support for vanilla JS, React, and other frameworks
+ */
+
+/**
+ * Mouse button state with press/release detection
+ */
+interface MouseButtonState {
+    pressed: boolean;
+    justPressed: boolean;
+    justReleased: boolean;
+}
+interface MouseButtons {
+    left: MouseButtonState;
+    middle: MouseButtonState;
+    right: MouseButtonState;
+}
+interface MouseCallbacks {
+    onMouseDown?: (button: string, position: Vector2, event: MouseEvent) => void;
+    onMouseUp?: (button: string, position: Vector2, event: MouseEvent) => void;
+    onMouseMove?: (position: Vector2, delta: Vector2, event: MouseEvent) => void;
+    onMouseWheel?: (delta: number, event: WheelEvent) => void;
+    onMouseEnter?: (event: MouseEvent) => void;
+    onMouseLeave?: (event: MouseEvent) => void;
+}
+declare class MouseInputs extends BaseInputs {
+    private mouseButtons;
+    private mousePosition;
+    private mouseDelta;
+    private wheelDelta;
+    private mouseCallbacks;
+    private boundHandlers;
+    constructor(targetElement?: HTMLElement | Window, config?: InputConfig);
+    start(): void;
+    stop(): void;
+    reset(): void;
+    /**
+     * Poll - Reset transient states (justPressed/justReleased)
+     * Should be called once per frame AFTER collecting input
+     */
+    poll(): void;
+    resetDelta(): void;
+    /**
+     * Check if left mouse button is pressed
+     *
+     * @returns True if left button is pressed, false otherwise
+     *
+     * @example
+     * ```typescript
+     * if (mouse.isLeftMousePressed()) {
+     *   console.log('Left click detected');
+     * }
+     * ```
+     */
+    isLeftMousePressed(): boolean;
+    /**
+     * Check if left mouse button was just pressed this frame
+     *
+     * @returns True if button was just pressed (transition false→true), false otherwise
+     *
+     * @example
+     * ```typescript
+     * if (mouse.isLeftMouseJustPressed()) {
+     *   fireWeapon(); // Fires once per click
+     * }
+     * ```
+     */
+    isLeftMouseJustPressed(): boolean;
+    /**
+     * Check if left mouse button was just released this frame
+     *
+     * @returns True if button was just released (transition true→false), false otherwise
+     *
+     * @example
+     * ```typescript
+     * if (mouse.isLeftMouseJustReleased()) {
+     *   releaseChargedAttack();
+     * }
+     * ```
+     */
+    isLeftMouseJustReleased(): boolean;
+    /**
+     * Check if right mouse button is pressed
+     *
+     * @returns True if right button is pressed, false otherwise
+     *
+     * @example
+     * ```typescript
+     * if (mouse.isRightMousePressed()) {
+     *   showContextMenu();
+     * }
+     * ```
+     */
+    isRightMousePressed(): boolean;
+    /**
+     * Check if right mouse button was just pressed this frame
+     */
+    isRightMouseJustPressed(): boolean;
+    /**
+     * Check if right mouse button was just released this frame
+     */
+    isRightMouseJustReleased(): boolean;
+    /**
+     * Check if middle mouse button is pressed
+     *
+     * @returns True if middle button is pressed, false otherwise
+     */
+    isMiddleMousePressed(): boolean;
+    /**
+     * Check if middle mouse button was just pressed this frame
+     */
+    isMiddleMouseJustPressed(): boolean;
+    /**
+     * Check if middle mouse button was just released this frame
+     */
+    isMiddleMouseJustReleased(): boolean;
+    /**
+     * Get current mouse position
+     *
+     * @returns Vector2 with x and y coordinates in pixels
+     *
+     * @example
+     * ```typescript
+     * const pos = mouse.getMousePosition();
+     * console.log(`Mouse at (${pos.x}, ${pos.y})`);
+     * ```
+     */
+    getMousePosition(): Vector2;
+    /**
+     * Get mouse movement delta since last frame
+     *
+     * @returns Vector2 with dx and dy in pixels
+     *
+     * @example
+     * ```typescript
+     * const delta = mouse.getMouseDelta();
+     * camera.rotate(delta.x * sensitivity, delta.y * sensitivity);
+     * ```
+     */
+    getMouseDelta(): Vector2;
+    /**
+     * Get mouse wheel scroll delta
+     *
+     * @returns Wheel delta (positive = scroll down, negative = scroll up)
+     *
+     * @example
+     * ```typescript
+     * const wheel = mouse.getWheelDelta();
+     * if (wheel !== 0) {
+     *   camera.zoom(wheel > 0 ? -1 : 1);
+     * }
+     * ```
+     */
+    getWheelDelta(): number;
+    /**
+     * Set mouse-specific callbacks
+     *
+     * @param callbacks - Object containing callback functions
+     *
+     * @example
+     * ```typescript
+     * mouse.setMouseCallbacks({
+     *   onMouseDown: (button, position, event) => {
+     *     console.log(`${button} button pressed at`, position);
+     *   },
+     *   onMouseMove: (position, delta, event) => {
+     *     console.log('Mouse moved by', delta);
+     *   },
+     *   onMouseWheel: (delta, event) => {
+     *     console.log('Wheel scrolled:', delta);
+     *   },
+     * });
+     * ```
+     */
+    setMouseCallbacks(callbacks: MouseCallbacks): void;
+    clearMouseCallbacks(): void;
+    setCallbacks(callbacks: MouseCallbacks | unknown): void;
+    private isMouseCallbacks;
+    /** Button index to name mapping */
+    private static readonly BUTTON_NAMES;
+    /**
+     * Get button state by event.button index
+     * @returns Button state and name, or null for unknown buttons
+     */
+    private getButtonByIndex;
+    private handleMouseDown;
+    private handleMouseUp;
+    private handleMouseMove;
+    private handleWheel;
+    private handleMouseEnter;
+    private handleMouseLeave;
+    private handleContextMenu;
+}
+/**
+ * React hook for mouse inputs
+ */
+declare function useMouseInputs(targetElement?: HTMLElement | Window, callbacks?: MouseCallbacks): MouseInputs;
+
+export { BaseInputs, InputEventType, KeyboardInputs, MouseInputs, useKeyboardInputs, useMouseInputs };
+export type { ButtonState, IInputs, InputConfig, KeyButtonState, KeyState, KeyboardCallbacks, MouseButtonState, MouseButtons, MouseCallbacks };

package/dist/desktop.mjs

@@ -0,0 +1 @@
+var v=Object.defineProperty;var y=(i,s,e)=>s in i?v(i,s,{enumerable:!0,configurable:!0,writable:!0,value:e}):i[s]=e;var a=(i,s)=>v(i,"name",{value:s,configurable:!0});var o=(i,s,e)=>(y(i,typeof s!="symbol"?s+"":s,e),e);import{Vector2 as H}from"@utsp/types";import{InputDeviceType as U,KeyboardInput as A,MouseInput as W}from"@utsp/types";var f=(n=>(n.KeyDown="keydown",n.KeyUp="keyup",n.MouseDown="mousedown",n.MouseUp="mouseup",n.MouseMove="mousemove",n.MouseWheel="mousewheel",n.TouchStart="touchstart",n.TouchEnd="touchend",n.TouchMove="touchmove",n.GamepadConnected="gamepadconnected",n.GamepadDisconnected="gamepaddisconnected",n.GamepadButton="gamepadbutton",n.GamepadAxis="gamepadaxis",n))(f||{}),b=class b{constructor(s=window,e={}){o(this,"isActive",!1);o(this,"targetElement");o(this,"config");o(this,"callbacks",{});this.targetElement=s,this.config={enabled:!0,preventDefault:!1,stopPropagation:!1,debug:!1,...e}}isListening(){return this.isActive}destroy(){this.stop(),this.clearCallbacks()}setCallbacks(s){typeof s=="object"&&s!==null&&Object.assign(this.callbacks,s)}clearCallbacks(){this.callbacks={}}getTargetElement(){return this.targetElement}enable(){this.config.enabled=!0,this.isActive||this.start()}disable(){this.config.enabled=!1,this.isActive&&this.stop()}isEnabled(){return this.config.enabled??!0}emit(s,...e){this.callbacks[s]&&this.callbacks[s].forEach(t=>{try{t(...e)}catch(r){this.config.debug&&console.error(`Error in ${s} callback:`,r)}})}log(...s){this.config.debug&&console.warn("[InputSystem]",...s)}};a(b,"BaseInputs");var l=b;var m=class m extends l{constructor(e=window,t={}){super(e,t);o(this,"keys",{});o(this,"keyboardCallbacks",{});o(this,"textInputsThisFrame",[]);o(this,"boundHandlers");this.boundHandlers={keyDown:this.handleKeyDown.bind(this),keyUp:this.handleKeyUp.bind(this)}}start(){this.isActive||(this.targetElement.addEventListener("keydown",this.boundHandlers.keyDown),this.targetElement.addEventListener("keyup",this.boundHandlers.keyUp),this.isActive=!0)}stop(){this.isActive&&(this.targetElement.removeEventListener("keydown",this.boundHandlers.keyDown),this.targetElement.removeEventListener("keyup",this.boundHandlers.keyUp),this.isActive=!1)}reset(){this.keys={}}resetDelta(){}poll(){for(let e in this.keys)this.keys[e].justPressed=!1,this.keys[e].justReleased=!1;this.textInputsThisFrame=[]}getTextInputs(){return this.textInputsThisFrame}isKeyPressed(e){return this.keys[e]?.pressed||!1}isKeyJustPressed(e){return this.keys[e]?.justPressed||!1}isKeyJustReleased(e){return this.keys[e]?.justReleased||!1}getKeysPressed(){return Object.keys(this.keys).filter(e=>this.keys[e].pressed)}getKeysJustPressed(){return Object.keys(this.keys).filter(e=>this.keys[e].justPressed)}getKeysJustReleased(){return Object.keys(this.keys).filter(e=>this.keys[e].justReleased)}isAnyKeyPressed(){return Object.values(this.keys).some(e=>e.pressed)}setKeyboardCallbacks(e){this.keyboardCallbacks={...this.keyboardCallbacks,...e}}clearKeyboardCallbacks(){this.keyboardCallbacks={}}setCallbacks(e){this.isKeyboardCallbacks(e)&&this.setKeyboardCallbacks(e)}isKeyboardCallbacks(e){return typeof e=="object"&&e!==null&&("onKeyDown"in e||"onKeyUp"in e)}shouldAllowDefault(e,t){let r=/^F([1-9]|1[0-2])$/.test(e),c=(t.ctrlKey||t.metaKey)&&(e==="KeyT"||e==="KeyW"||e==="KeyR"||e==="KeyN"||e==="Tab");return r||c}handleKeyDown(e){try{let t=e.code,r=this.shouldAllowDefault(t,e);this.config.preventDefault&&!r&&e.preventDefault(),this.config.stopPropagation&&!r&&e.stopPropagation(),this.keys[t]||(this.keys[t]={pressed:!1,justPressed:!1,justReleased:!1}),this.keys[t].pressed||(this.keys[t].justPressed=!0,this.keyboardCallbacks.onKeyDown?.(t,e)),this.keys[t].pressed=!0,this.keys[t].justReleased=!1;let c=e.key;c.length===1&&!e.ctrlKey&&!e.metaKey&&this.textInputsThisFrame.push(c)}catch(t){console.error("Error in keyboard keydown handler:",t)}}handleKeyUp(e){try{let t=e.code,r=this.shouldAllowDefault(t,e);this.config.preventDefault&&!r&&e.preventDefault(),this.config.stopPropagation&&!r&&e.stopPropagation(),this.keys[t]||(this.keys[t]={pressed:!1,justPressed:!1,justReleased:!1}),this.keys[t].pressed&&(this.keys[t].justReleased=!0,this.keyboardCallbacks.onKeyUp?.(t,e)),this.keys[t].pressed=!1,this.keys[t].justPressed=!1}catch(t){console.error("Error in keyboard keyup handler:",t)}}};a(m,"KeyboardInputs");var h=m;function g(i,s){let e=new h(i);return s&&e.setCallbacks(s),e.start(),e}a(g,"useKeyboardInputs");import{Vector2 as u}from"@utsp/types";var d=class d extends l{constructor(e=window,t={}){super(e,t);o(this,"mouseButtons",{left:{pressed:!1,justPressed:!1,justReleased:!1},middle:{pressed:!1,justPressed:!1,justReleased:!1},right:{pressed:!1,justPressed:!1,justReleased:!1}});o(this,"mousePosition",u.zero());o(this,"mouseDelta",u.zero());o(this,"wheelDelta",0);o(this,"mouseCallbacks",{});o(this,"boundHandlers");this.boundHandlers={mouseDown:this.handleMouseDown.bind(this),mouseUp:this.handleMouseUp.bind(this),mouseMove:this.handleMouseMove.bind(this),wheel:this.handleWheel.bind(this),mouseEnter:this.handleMouseEnter.bind(this),mouseLeave:this.handleMouseLeave.bind(this),contextMenu:this.handleContextMenu.bind(this)}}start(){this.isActive||(this.targetElement.addEventListener("mousedown",this.boundHandlers.mouseDown),this.targetElement.addEventListener("mouseup",this.boundHandlers.mouseUp),this.targetElement.addEventListener("mousemove",this.boundHandlers.mouseMove),this.targetElement.addEventListener("wheel",this.boundHandlers.wheel),this.targetElement.addEventListener("mouseenter",this.boundHandlers.mouseEnter),this.targetElement.addEventListener("mouseleave",this.boundHandlers.mouseLeave),this.targetElement.addEventListener("contextmenu",this.boundHandlers.contextMenu),this.isActive=!0)}stop(){this.isActive&&(this.targetElement.removeEventListener("mousedown",this.boundHandlers.mouseDown),this.targetElement.removeEventListener("mouseup",this.boundHandlers.mouseUp),this.targetElement.removeEventListener("mousemove",this.boundHandlers.mouseMove),this.targetElement.removeEventListener("wheel",this.boundHandlers.wheel),this.targetElement.removeEventListener("mouseenter",this.boundHandlers.mouseEnter),this.targetElement.removeEventListener("mouseleave",this.boundHandlers.mouseLeave),this.targetElement.removeEventListener("contextmenu",this.boundHandlers.contextMenu),this.isActive=!1)}reset(){this.mouseButtons={left:{pressed:!1,justPressed:!1,justReleased:!1},middle:{pressed:!1,justPressed:!1,justReleased:!1},right:{pressed:!1,justPressed:!1,justReleased:!1}},this.mousePosition=u.zero(),this.mouseDelta=u.zero(),this.wheelDelta=0}poll(){this.mouseButtons.left.justPressed=!1,this.mouseButtons.left.justReleased=!1,this.mouseButtons.middle.justPressed=!1,this.mouseButtons.middle.justReleased=!1,this.mouseButtons.right.justPressed=!1,this.mouseButtons.right.justReleased=!1,this.resetDelta()}resetDelta(){this.mouseDelta=u.zero(),this.wheelDelta=0}isLeftMousePressed(){return this.mouseButtons.left.pressed}isLeftMouseJustPressed(){return this.mouseButtons.left.justPressed}isLeftMouseJustReleased(){return this.mouseButtons.left.justReleased}isRightMousePressed(){return this.mouseButtons.right.pressed}isRightMouseJustPressed(){return this.mouseButtons.right.justPressed}isRightMouseJustReleased(){return this.mouseButtons.right.justReleased}isMiddleMousePressed(){return this.mouseButtons.middle.pressed}isMiddleMouseJustPressed(){return this.mouseButtons.middle.justPressed}isMiddleMouseJustReleased(){return this.mouseButtons.middle.justReleased}getMousePosition(){return this.mousePosition.clone()}getMouseDelta(){return this.mouseDelta.clone()}getWheelDelta(){return this.wheelDelta}setMouseCallbacks(e){this.mouseCallbacks={...this.mouseCallbacks,...e}}clearMouseCallbacks(){this.mouseCallbacks={}}setCallbacks(e){this.isMouseCallbacks(e)&&this.setMouseCallbacks(e)}isMouseCallbacks(e){return typeof e=="object"&&e!==null&&("onMouseDown"in e||"onMouseUp"in e||"onMouseMove"in e||"onMouseWheel"in e||"onMouseEnter"in e||"onMouseLeave"in e)}getButtonByIndex(e){let t=d.BUTTON_NAMES[e];return t?{state:this.mouseButtons[t],name:t}:null}handleMouseDown(e){try{this.config.preventDefault&&e.preventDefault(),this.config.stopPropagation&&e.stopPropagation();let t=this.getButtonByIndex(e.button);t&&(t.state.pressed||(t.state.justPressed=!0),t.state.pressed=!0,t.state.justReleased=!1,this.mouseCallbacks.onMouseDown?.(t.name,this.mousePosition,e))}catch(t){console.error("Error in mouse down handler:",t)}}handleMouseUp(e){try{this.config.preventDefault&&e.preventDefault(),this.config.stopPropagation&&e.stopPropagation();let t=this.getButtonByIndex(e.button);t&&(t.state.pressed&&(t.state.justReleased=!0),t.state.pressed=!1,t.state.justPressed=!1,this.mouseCallbacks.onMouseUp?.(t.name,this.mousePosition,e))}catch(t){console.error("Error in mouse up handler:",t)}}handleMouseMove(e){try{this.config.preventDefault&&e.preventDefault(),this.config.stopPropagation&&e.stopPropagation();let t=new u(e.clientX,e.clientY);this.mouseDelta=t.subtract(this.mousePosition),this.mousePosition=t,this.mouseCallbacks.onMouseMove?.(this.mousePosition,this.mouseDelta,e)}catch(t){console.error("Error in mouse move handler:",t)}}handleWheel(e){try{this.config.preventDefault&&e.preventDefault(),this.config.stopPropagation&&e.stopPropagation(),this.wheelDelta=e.deltaY,this.mouseCallbacks.onMouseWheel?.(this.wheelDelta,e)}catch(t){console.error("Error in mouse wheel handler:",t)}}handleMouseEnter(e){try{this.mouseCallbacks.onMouseEnter?.(e)}catch(t){console.error("Error in mouse enter handler:",t)}}handleMouseLeave(e){try{this.mouseCallbacks.onMouseLeave?.(e)}catch(t){console.error("Error in mouse leave handler:",t)}}handleContextMenu(e){try{e.preventDefault(),this.config.stopPropagation&&e.stopPropagation()}catch(t){console.error("Error in context menu handler:",t)}}};a(d,"MouseInputs"),o(d,"BUTTON_NAMES",["left","middle","right"]);var p=d;function M(i,s){let e=new p(i);return s&&e.setCallbacks(s),e.start(),e}a(M,"useMouseInputs");export{l as BaseInputs,U as InputDeviceType,f as InputEventType,A as KeyboardInput,h as KeyboardInputs,W as MouseInput,p as MouseInputs,H as Vector2,g as useKeyboardInputs,M as useMouseInputs};

package/dist/gamepad.cjs

@@ -0,0 +1 @@
+"use strict";var h=Object.defineProperty;var C=Object.getOwnPropertyDescriptor;var x=Object.getOwnPropertyNames;var A=Object.prototype.hasOwnProperty;var P=(i,n,e)=>n in i?h(i,n,{enumerable:!0,configurable:!0,writable:!0,value:e}):i[n]=e;var m=(i,n)=>h(i,"name",{value:n,configurable:!0});var I=(i,n)=>{for(var e in n)h(i,e,{get:n[e],enumerable:!0})},E=(i,n,e,t)=>{if(n&&typeof n=="object"||typeof n=="function")for(let a of x(n))!A.call(i,a)&&a!==e&&h(i,a,{get:()=>n[a],enumerable:!(t=C(n,a))||t.enumerable});return i};var D=i=>E(h({},"__esModule",{value:!0}),i);var r=(i,n,e)=>(P(i,typeof n!="symbol"?n+"":n,e),e);var V={};I(V,{BaseInputs:()=>g,GamepadInput:()=>v.GamepadInput,GamepadInputs:()=>f,InputDeviceType:()=>v.InputDeviceType,InputEventType:()=>G,Vector2:()=>y.Vector2,useGamepadInputs:()=>k});module.exports=D(V);var y=require("@utsp/types"),v=require("@utsp/types");var G=(o=>(o.KeyDown="keydown",o.KeyUp="keyup",o.MouseDown="mousedown",o.MouseUp="mouseup",o.MouseMove="mousemove",o.MouseWheel="mousewheel",o.TouchStart="touchstart",o.TouchEnd="touchend",o.TouchMove="touchmove",o.GamepadConnected="gamepadconnected",o.GamepadDisconnected="gamepaddisconnected",o.GamepadButton="gamepadbutton",o.GamepadAxis="gamepadaxis",o))(G||{}),w=class w{constructor(n=window,e={}){r(this,"isActive",!1);r(this,"targetElement");r(this,"config");r(this,"callbacks",{});this.targetElement=n,this.config={enabled:!0,preventDefault:!1,stopPropagation:!1,debug:!1,...e}}isListening(){return this.isActive}destroy(){this.stop(),this.clearCallbacks()}setCallbacks(n){typeof n=="object"&&n!==null&&Object.assign(this.callbacks,n)}clearCallbacks(){this.callbacks={}}getTargetElement(){return this.targetElement}enable(){this.config.enabled=!0,this.isActive||this.start()}disable(){this.config.enabled=!1,this.isActive&&this.stop()}isEnabled(){return this.config.enabled??!0}emit(n,...e){this.callbacks[n]&&this.callbacks[n].forEach(t=>{try{t(...e)}catch(a){this.config.debug&&console.error(`Error in ${n} callback:`,a)}})}log(...n){this.config.debug&&console.warn("[InputSystem]",...n)}};m(w,"BaseInputs");var g=w;var S=.01,M=class M extends g{constructor(e={}){super(window,e);r(this,"gamepads",new Map);r(this,"previousGamepads",new Map);r(this,"gamepadCallbacks",{});r(this,"gamepadConfig");r(this,"pollingIntervalId",null);r(this,"rafId",null);r(this,"boundHandlers");r(this,"vibrationPresets",{tap:{duration:50,strongMagnitude:.3,weakMagnitude:.5},impact:{duration:100,strongMagnitude:.7,weakMagnitude:.3},heavy:{duration:200,strongMagnitude:1,weakMagnitude:.2},success:{duration:150,strongMagnitude:.4,weakMagnitude:.6},error:{duration:300,strongMagnitude:.8,weakMagnitude:.4},explosion:{duration:400,strongMagnitude:1,weakMagnitude:.8},engine:{duration:1e3,strongMagnitude:.5,weakMagnitude:.2},heartbeat:{duration:100,strongMagnitude:.6,weakMagnitude:.1}});this.gamepadConfig={targetElement:window,maxGamepads:e.maxGamepads??4,axisDeadzone:e.axisDeadzone??.1,pollingInterval:e.pollingInterval??16,autoPolling:e.autoPolling??!0,enabled:e.enabled??!0,debug:e.debug??!1,preventDefault:e.preventDefault??!1,stopPropagation:e.stopPropagation??!1},this.boundHandlers={connected:this.handleGamepadConnected.bind(this),disconnected:this.handleGamepadDisconnected.bind(this)}}start(){this.isActive||(window.addEventListener("gamepadconnected",this.boundHandlers.connected),window.addEventListener("gamepaddisconnected",this.boundHandlers.disconnected),this.gamepadConfig.autoPolling&&this.startPolling(),this.isActive=!0,this.log("GamepadInputs started"))}stop(){this.isActive&&(window.removeEventListener("gamepadconnected",this.boundHandlers.connected),window.removeEventListener("gamepaddisconnected",this.boundHandlers.disconnected),this.stopPolling(),this.isActive=!1,this.log("GamepadInputs stopped"))}reset(){this.gamepads.clear(),this.previousGamepads.clear()}resetDelta(){this.previousGamepads.clear(),this.gamepads.forEach((e,t)=>{this.previousGamepads.set(t,this.cloneGamepadState(e))})}startPolling(){if(this.pollingIntervalId!==null||this.rafId!==null)return;let e=m(()=>{this.poll(),this.rafId=requestAnimationFrame(e)},"poll");this.rafId=requestAnimationFrame(e),this.log("Polling started")}stopPolling(){this.rafId!==null&&(cancelAnimationFrame(this.rafId),this.rafId=null),this.pollingIntervalId!==null&&(clearInterval(this.pollingIntervalId),this.pollingIntervalId=null),this.log("Polling stopped")}poll(){let e=navigator.getGamepads?navigator.getGamepads():[];for(let t=0;t<e.length&&t<this.gamepadConfig.maxGamepads;t++){let a=e[t];a&&this.updateGamepadState(a)}}getConnectedGamepadCount(){return this.gamepads.size}isGamepadConnected(e){return this.gamepads.has(e)&&this.gamepads.get(e).connected}getGamepadState(e){return this.gamepads.get(e)||null}getAllGamepads(){return Array.from(this.gamepads.values()).filter(e=>e.connected)}isButtonPressed(e,t){if(!Number.isInteger(e)||e<0)throw new Error(`Invalid gamepadIndex: ${e}. Must be a non-negative integer.`);if(!Number.isInteger(t)||t<0)throw new Error(`Invalid buttonIndex: ${t}. Must be a non-negative integer.`);let a=this.gamepads.get(e);return!a||!a.connected||t>=a.buttons.length?!1:a.buttons[t].pressed}isButtonJustPressed(e,t){if(!Number.isInteger(e)||e<0)throw new Error(`Invalid gamepadIndex: ${e}. Must be a non-negative integer.`);if(!Number.isInteger(t)||t<0)throw new Error(`Invalid buttonIndex: ${t}. Must be a non-negative integer.`);let a=this.gamepads.get(e);return!a||!a.connected||t>=a.buttons.length?!1:a.buttons[t].justPressed}isButtonJustReleased(e,t){if(!Number.isInteger(e)||e<0)throw new Error(`Invalid gamepadIndex: ${e}. Must be a non-negative integer.`);if(!Number.isInteger(t)||t<0)throw new Error(`Invalid buttonIndex: ${t}. Must be a non-negative integer.`);let a=this.gamepads.get(e);return!a||!a.connected||t>=a.buttons.length?!1:a.buttons[t].justReleased}getButtonValue(e,t){if(!Number.isInteger(e)||e<0)throw new Error(`Invalid gamepadIndex: ${e}. Must be a non-negative integer.`);if(!Number.isInteger(t)||t<0)throw new Error(`Invalid buttonIndex: ${t}. Must be a non-negative integer.`);let a=this.gamepads.get(e);return!a||!a.connected||t>=a.buttons.length?0:a.buttons[t].value}getAxis(e,t){if(!Number.isInteger(e)||e<0)throw new Error(`Invalid gamepadIndex: ${e}. Must be a non-negative integer.`);if(!Number.isInteger(t)||t<0)throw new Error(`Invalid axisIndex: ${t}. Must be a non-negative integer.`);let a=this.gamepads.get(e);if(!a||!a.connected||t>=a.axes.length)return 0;let s=a.axes[t];return this.applyDeadzone(s)}getAxisRaw(e,t){if(!Number.isInteger(e)||e<0)throw new Error(`Invalid gamepadIndex: ${e}. Must be a non-negative integer.`);if(!Number.isInteger(t)||t<0)throw new Error(`Invalid axisIndex: ${t}. Must be a non-negative integer.`);let a=this.gamepads.get(e);return!a||!a.connected||t>=a.axes.length?0:a.axes[t]}getLeftStick(e){return{x:this.getAxis(e,0),y:this.getAxis(e,1)}}getRightStick(e){return{x:this.getAxis(e,2),y:this.getAxis(e,3)}}supportsVibration(e){let t=this.getNativeGamepad(e);if(!t)return!1;let a=t.vibrationActuator;if(a&&typeof a.playEffect=="function")return!0;let s=t.hapticActuators;return!!(s&&s.length>0)}async vibrate(e,t){let a=this.getNativeGamepad(e);if(!a)return this.log(`Vibrate failed: gamepad ${e} not found`),!1;let{duration:s,strongMagnitude:u=1,weakMagnitude:d=.5,startDelay:b=0}=t;try{let l=a.vibrationActuator;if(l&&typeof l.playEffect=="function"){let c=await l.playEffect("dual-rumble",{startDelay:b,duration:s,strongMagnitude:Math.min(1,Math.max(0,u)),weakMagnitude:Math.min(1,Math.max(0,d))});return this.log(`Vibration effect result: ${c}`),c==="complete"}let p=a.hapticActuators;if(p&&p.length>0){let c=Math.max(u,d);return await p[0].pulse(c,s),!0}return this.log(`Vibrate failed: gamepad ${e} does not support vibration`),!1}catch(l){return this.log("Vibrate error:",l),!1}}async stopVibration(e){let t=this.getNativeGamepad(e);if(!t)return!1;try{let a=t.vibrationActuator;return a&&typeof a.reset=="function"?(await a.reset(),!0):a&&typeof a.playEffect=="function"?(await a.playEffect("dual-rumble",{duration:0,strongMagnitude:0,weakMagnitude:0}),!0):!1}catch(a){return this.log("Stop vibration error:",a),!1}}async stopAllVibrations(){let e=[];for(let[t]of this.gamepads)e.push(this.stopVibration(t));await Promise.all(e)}async vibrateAll(e){let t=[];for(let[a]of this.gamepads)t.push(this.vibrate(a,e));await Promise.all(t)}async vibratePreset(e,t){let a=this.vibrationPresets[t];return a?this.vibrate(e,a):(this.log(`Unknown vibration preset: ${t}`),!1)}getNativeGamepad(e){return(navigator.getGamepads?navigator.getGamepads():[])[e]||null}setGamepadCallbacks(e){this.gamepadCallbacks={...this.gamepadCallbacks,...e}}clearGamepadCallbacks(){this.gamepadCallbacks={}}setCallbacks(e){this.isGamepadCallbacks(e)&&this.setGamepadCallbacks(e)}isGamepadCallbacks(e){return typeof e=="object"&&e!==null&&("onGamepadConnected"in e||"onGamepadDisconnected"in e||"onButtonDown"in e||"onButtonUp"in e||"onAxisMove"in e)}updateGamepadState(e){let t=this.gamepads.get(e.index),a=Array.from(e.buttons).map((d,b)=>{let l=t?.buttons[b],p=d.pressed,c=l?.pressed??!1;return{pressed:p,justPressed:p&&!c,justReleased:!p&&c,value:d.value,touched:d.touched??!1}}),s=Array.from(e.axes),u={id:e.id,index:e.index,connected:e.connected,buttons:a,axes:s,timestamp:e.timestamp,mapping:e.mapping};this.gamepads.set(e.index,u),this.triggerCallbacks(u,t)}triggerCallbacks(e,t){try{e.buttons.forEach((a,s)=>{a.justPressed&&this.gamepadCallbacks.onButtonDown?.(e.index,s,a.value),a.justReleased&&this.gamepadCallbacks.onButtonUp?.(e.index,s)}),e.axes.forEach((a,s)=>{let u=t?.axes[s]??0,d=this.applyDeadzone(a),b=this.applyDeadzone(u);Math.abs(d-b)>S&&this.gamepadCallbacks.onAxisMove?.(e.index,s,d)})}catch(a){this.log("Error in gamepad callbacks:",a)}}handleGamepadConnected(e){try{this.log(`Gamepad connected: ${e.gamepad.id} at index ${e.gamepad.index}`);let t={id:e.gamepad.id,index:e.gamepad.index,connected:!0,buttons:Array.from(e.gamepad.buttons).map(a=>({pressed:a.pressed,justPressed:!1,justReleased:!1,value:a.value,touched:a.touched??!1})),axes:Array.from(e.gamepad.axes),timestamp:e.gamepad.timestamp,mapping:e.gamepad.mapping};this.gamepads.set(e.gamepad.index,t),this.gamepadCallbacks.onGamepadConnected?.(t)}catch(t){this.log("Error handling gamepad connected:",t)}}handleGamepadDisconnected(e){try{this.log(`Gamepad disconnected at index ${e.gamepad.index}`),this.gamepads.delete(e.gamepad.index),this.previousGamepads.delete(e.gamepad.index),this.gamepadCallbacks.onGamepadDisconnected?.(e.gamepad.index)}catch(t){this.log("Error handling gamepad disconnected:",t)}}applyDeadzone(e){let t=this.gamepadConfig.axisDeadzone;return Math.abs(e)<t?0:(e>0?1:-1)*((Math.abs(e)-t)/(1-t))}cloneGamepadState(e){return{...e,buttons:e.buttons.map(t=>({...t})),axes:[...e.axes]}}};m(M,"GamepadInputs");var f=M;function k(i,n){let e=new f(n);return i&&e.setGamepadCallbacks(i),e.start(),e}m(k,"useGamepadInputs");