@utsp/input 0.9.0 → 0.10.0-nightly.20251213135145.115c488

package/dist/gamepad.d.ts

@@ -0,0 +1,563 @@
+import { Vector2, Vector3, IGamepadVibrationProcessor, GamepadVibrationOptions } from '@utsp/types';
+export { GamepadInput, InputDeviceType, 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;
+}
+
+/**
+ * GamepadInputs - Gamepad/Controller input management
+ * Handles gamepad events with support for multiple controllers, buttons, axes, and vibration
+ */
+
+/**
+ * Gamepad button state with press detection
+ */
+interface GamepadButtonState {
+    pressed: boolean;
+    justPressed: boolean;
+    justReleased: boolean;
+    value: number;
+    touched: boolean;
+}
+/**
+ * Complete state of a single gamepad
+ */
+interface GamepadState {
+    id: string;
+    index: number;
+    connected: boolean;
+    buttons: GamepadButtonState[];
+    axes: number[];
+    timestamp: number;
+    mapping: GamepadMappingType;
+    hapticActuators?: GamepadHapticActuator[];
+}
+/**
+ * Callbacks for gamepad events
+ */
+interface GamepadCallbacks {
+    onGamepadConnected?: (gamepad: GamepadState) => void;
+    onGamepadDisconnected?: (index: number) => void;
+    onButtonDown?: (gamepadIndex: number, buttonIndex: number, value: number) => void;
+    onButtonUp?: (gamepadIndex: number, buttonIndex: number) => void;
+    onAxisMove?: (gamepadIndex: number, axisIndex: number, value: number) => void;
+}
+/**
+ * Configuration for GamepadInputs
+ */
+interface GamepadInputsConfig extends InputConfig {
+    /** Maximum number of gamepads to support (default: 4) */
+    maxGamepads?: number;
+    /** Deadzone for analog axes (default: 0.1) */
+    axisDeadzone?: number;
+    /** Polling interval in milliseconds (default: 16 ~= 60fps) */
+    pollingInterval?: number;
+    /** Enable automatic polling (default: true) */
+    autoPolling?: boolean;
+}
+declare class GamepadInputs extends BaseInputs implements IGamepadVibrationProcessor {
+    private gamepads;
+    private previousGamepads;
+    private gamepadCallbacks;
+    private gamepadConfig;
+    private pollingIntervalId;
+    private rafId;
+    private boundHandlers;
+    constructor(config?: GamepadInputsConfig);
+    start(): void;
+    stop(): void;
+    reset(): void;
+    resetDelta(): void;
+    /**
+     * Start automatic polling of gamepad state
+     */
+    startPolling(): void;
+    /**
+     * Stop automatic polling
+     */
+    stopPolling(): void;
+    /**
+     * Manually poll gamepad state (call this in your game loop if autoPolling is false)
+     *
+     * @example
+     * ```typescript
+     * const gamepad = new GamepadInputs({ autoPolling: false });
+     * gamepad.start();
+     *
+     * function gameLoop() {
+     *   gamepad.poll(); // Manual polling
+     *   // Check inputs...
+     *   requestAnimationFrame(gameLoop);
+     * }
+     * ```
+     */
+    poll(): void;
+    /**
+     * Get the number of connected gamepads
+     *
+     * @returns Number of gamepads currently connected (0-4)
+     *
+     * @example
+     * ```typescript
+     * const count = gamepad.getConnectedGamepadCount();
+     * console.log(`${count} gamepads connected`);
+     * ```
+     */
+    getConnectedGamepadCount(): number;
+    /**
+     * Check if a gamepad is connected at the given index
+     *
+     * @param index - Gamepad index (0-3)
+     * @returns True if gamepad is connected, false otherwise
+     *
+     * @example
+     * ```typescript
+     * if (gamepad.isGamepadConnected(0)) {
+     *   console.log('Player 1 controller ready!');
+     * }
+     * ```
+     */
+    isGamepadConnected(index: number): boolean;
+    /**
+     * Get the state of a specific gamepad
+     */
+    getGamepadState(index: number): GamepadState | null;
+    /**
+     * Get all connected gamepads
+     */
+    getAllGamepads(): GamepadState[];
+    /**
+     * Check if a button is currently pressed
+     *
+     * @param gamepadIndex - Gamepad index (0-3)
+     * @param buttonIndex - Button index (0-16, standard mapping)
+     * @returns True if button is pressed, false otherwise
+     * @throws {Error} If gamepadIndex or buttonIndex is invalid
+     *
+     * @example
+     * ```typescript
+     * // Check A button (Xbox) / Cross (PlayStation)
+     * if (gamepad.isButtonPressed(0, 0)) {
+     *   console.log('Action button pressed!');
+     * }
+     * ```
+     */
+    isButtonPressed(gamepadIndex: number, buttonIndex: number): boolean;
+    /**
+     * Check if a button was just pressed this frame
+     */
+    isButtonJustPressed(gamepadIndex: number, buttonIndex: number): boolean;
+    /**
+     * Check if a button was just released this frame
+     */
+    isButtonJustReleased(gamepadIndex: number, buttonIndex: number): boolean;
+    /**
+     * Get the analog value of a button (0.0 to 1.0)
+     */
+    getButtonValue(gamepadIndex: number, buttonIndex: number): number;
+    /**
+     * Get the value of an axis (-1.0 to 1.0, with deadzone applied)
+     *
+     * @param gamepadIndex - Gamepad index (0-3)
+     * @param axisIndex - Axis index (0: left X, 1: left Y, 2: right X, 3: right Y)
+     * @returns Axis value from -1.0 (left/up) to 1.0 (right/down)
+     * @throws {Error} If gamepadIndex or axisIndex is invalid
+     *
+     * @example
+     * ```typescript
+     * const leftStickX = gamepad.getAxis(0, 0);
+     * const leftStickY = gamepad.getAxis(0, 1);
+     *
+     * playerX += leftStickX * speed;
+     * playerY += leftStickY * speed;
+     * ```
+     */
+    getAxis(gamepadIndex: number, axisIndex: number): number;
+    /**
+     * Get the raw axis value without deadzone
+     */
+    getAxisRaw(gamepadIndex: number, axisIndex: number): number;
+    /**
+     * Get left stick as a 2D vector (x: axis 0, y: axis 1)
+     *
+     * @param gamepadIndex - Gamepad index (0-3)
+     * @returns Object with x and y properties (-1.0 to 1.0)
+     *
+     * @example
+     * ```typescript
+     * const leftStick = gamepad.getLeftStick(0);
+     *
+     * if (Math.abs(leftStick.x) > 0.5) {
+     *   console.log('Strong horizontal input');
+     * }
+     *
+     * // Calculate magnitude for movement
+     * const magnitude = Math.sqrt(leftStick.x ** 2 + leftStick.y ** 2);
+     * ```
+     */
+    getLeftStick(gamepadIndex: number): {
+        x: number;
+        y: number;
+    };
+    /**
+     * Get right stick as a 2D vector (x: axis 2, y: axis 3)
+     */
+    getRightStick(gamepadIndex: number): {
+        x: number;
+        y: number;
+    };
+    /**
+     * Check if a gamepad supports vibration
+     *
+     * @param gamepadIndex - Gamepad index (0-3)
+     * @returns True if gamepad supports vibration
+     *
+     * @example
+     * ```typescript
+     * if (gamepad.supportsVibration(0)) {
+     *   gamepad.vibrate(0, { duration: 200, strongMagnitude: 1.0 });
+     * }
+     * ```
+     */
+    supportsVibration(gamepadIndex: number): boolean;
+    /**
+     * Vibrate a gamepad with dual-motor control
+     *
+     * Modern gamepads have two motors:
+     * - Strong motor (low frequency) - heavy rumble
+     * - Weak motor (high frequency) - light vibration
+     *
+     * @param gamepadIndex - Gamepad index (0-3)
+     * @param options - Vibration options
+     * @returns Promise that resolves when vibration completes or fails
+     *
+     * @example
+     * ```typescript
+     * // Strong rumble for 500ms
+     * await gamepad.vibrate(0, {
+     *   duration: 500,
+     *   strongMagnitude: 1.0,
+     *   weakMagnitude: 0.0,
+     * });
+     *
+     * // Light vibration
+     * await gamepad.vibrate(0, {
+     *   duration: 200,
+     *   strongMagnitude: 0.0,
+     *   weakMagnitude: 0.5,
+     * });
+     *
+     * // Balanced rumble
+     * await gamepad.vibrate(0, {
+     *   duration: 300,
+     *   strongMagnitude: 0.5,
+     *   weakMagnitude: 0.5,
+     * });
+     * ```
+     */
+    vibrate(gamepadIndex: number, options: GamepadVibrationOptions): Promise<boolean>;
+    /**
+     * Stop vibration on a gamepad
+     *
+     * @param gamepadIndex - Gamepad index (0-3)
+     * @returns Promise that resolves when vibration is stopped
+     */
+    stopVibration(gamepadIndex: number): Promise<boolean>;
+    /**
+     * Stop vibration on all connected gamepads
+     */
+    stopAllVibrations(): Promise<void>;
+    /**
+     * Vibrate all connected gamepads
+     *
+     * @param options - Vibration options (same as vibrate())
+     */
+    vibrateAll(options: {
+        duration: number;
+        strongMagnitude?: number;
+        weakMagnitude?: number;
+        startDelay?: number;
+    }): Promise<void>;
+    /**
+     * Preset vibration patterns for common use cases
+     */
+    readonly vibrationPresets: {
+        /** Light tap feedback */
+        tap: {
+            duration: number;
+            strongMagnitude: number;
+            weakMagnitude: number;
+        };
+        /** Medium impact */
+        impact: {
+            duration: number;
+            strongMagnitude: number;
+            weakMagnitude: number;
+        };
+        /** Heavy rumble */
+        heavy: {
+            duration: number;
+            strongMagnitude: number;
+            weakMagnitude: number;
+        };
+        /** Success feedback */
+        success: {
+            duration: number;
+            strongMagnitude: number;
+            weakMagnitude: number;
+        };
+        /** Error/failure feedback */
+        error: {
+            duration: number;
+            strongMagnitude: number;
+            weakMagnitude: number;
+        };
+        /** Explosion effect */
+        explosion: {
+            duration: number;
+            strongMagnitude: number;
+            weakMagnitude: number;
+        };
+        /** Engine/continuous rumble */
+        engine: {
+            duration: number;
+            strongMagnitude: number;
+            weakMagnitude: number;
+        };
+        /** Heartbeat (use twice with delay) */
+        heartbeat: {
+            duration: number;
+            strongMagnitude: number;
+            weakMagnitude: number;
+        };
+    };
+    /**
+     * Play a preset vibration pattern
+     *
+     * @param gamepadIndex - Gamepad index (0-3)
+     * @param preset - Preset name
+     *
+     * @example
+     * ```typescript
+     * // On hit
+     * gamepad.vibratePreset(0, 'impact');
+     *
+     * // On explosion
+     * gamepad.vibratePreset(0, 'explosion');
+     * ```
+     */
+    vibratePreset(gamepadIndex: number, preset: keyof typeof this.vibrationPresets): Promise<boolean>;
+    /**
+     * Get the native Gamepad object (for advanced usage)
+     */
+    private getNativeGamepad;
+    /**
+     * Set gamepad-specific callbacks
+     *
+     * @param callbacks - Object containing callback functions
+     *
+     * @example
+     * ```typescript
+     * gamepad.setGamepadCallbacks({
+     *   onGamepadConnected: (state) => {
+     *     console.log(`Gamepad connected: ${state.id}`);
+     *   },
+     *   onButtonDown: (gamepadIndex, buttonIndex, value) => {
+     *     console.log(`Button ${buttonIndex} pressed with value ${value}`);
+     *   },
+     *   onAxisMove: (gamepadIndex, axisIndex, value) => {
+     *     console.log(`Axis ${axisIndex} moved to ${value}`);
+     *   },
+     * });
+     * ```
+     */
+    setGamepadCallbacks(callbacks: GamepadCallbacks): void;
+    /**
+     * Clear all gamepad callbacks
+     */
+    clearGamepadCallbacks(): void;
+    setCallbacks(callbacks: GamepadCallbacks | unknown): void;
+    private isGamepadCallbacks;
+    private updateGamepadState;
+    private triggerCallbacks;
+    private handleGamepadConnected;
+    private handleGamepadDisconnected;
+    private applyDeadzone;
+    private cloneGamepadState;
+}
+/**
+ * React hook for gamepad inputs
+ */
+declare function useGamepadInputs(callbacks?: GamepadCallbacks, config?: GamepadInputsConfig): GamepadInputs;
+
+export { BaseInputs, GamepadInputs, InputEventType, useGamepadInputs };
+export type { ButtonState, GamepadButtonState, GamepadCallbacks, GamepadInputsConfig, GamepadState, IInputs, InputConfig };

package/dist/gamepad.mjs

@@ -0,0 +1 @@
+var G=Object.defineProperty;var M=(o,n,e)=>n in o?G(o,n,{enumerable:!0,configurable:!0,writable:!0,value:e}):o[n]=e;var m=(o,n)=>G(o,"name",{value:n,configurable:!0});var s=(o,n,e)=>(M(o,typeof n!="symbol"?n+"":n,e),e);import{Vector2 as V}from"@utsp/types";import{InputDeviceType as B,GamepadInput as N}from"@utsp/types";var w=(r=>(r.KeyDown="keydown",r.KeyUp="keyup",r.MouseDown="mousedown",r.MouseUp="mouseup",r.MouseMove="mousemove",r.MouseWheel="mousewheel",r.TouchStart="touchstart",r.TouchEnd="touchend",r.TouchMove="touchmove",r.GamepadConnected="gamepadconnected",r.GamepadDisconnected="gamepaddisconnected",r.GamepadButton="gamepadbutton",r.GamepadAxis="gamepadaxis",r))(w||{}),f=class f{constructor(n=window,e={}){s(this,"isActive",!1);s(this,"targetElement");s(this,"config");s(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(f,"BaseInputs");var b=f;var k=.01,v=class v extends b{constructor(e={}){super(window,e);s(this,"gamepads",new Map);s(this,"previousGamepads",new Map);s(this,"gamepadCallbacks",{});s(this,"gamepadConfig");s(this,"pollingIntervalId",null);s(this,"rafId",null);s(this,"boundHandlers");s(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 i=a.axes[t];return this.applyDeadzone(i)}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 i=t.hapticActuators;return!!(i&&i.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:i,strongMagnitude:u=1,weakMagnitude:d=.5,startDelay:g=0}=t;try{let l=a.vibrationActuator;if(l&&typeof l.playEffect=="function"){let c=await l.playEffect("dual-rumble",{startDelay:g,duration:i,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,i),!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,g)=>{let l=t?.buttons[g],p=d.pressed,c=l?.pressed??!1;return{pressed:p,justPressed:p&&!c,justReleased:!p&&c,value:d.value,touched:d.touched??!1}}),i=Array.from(e.axes),u={id:e.id,index:e.index,connected:e.connected,buttons:a,axes:i,timestamp:e.timestamp,mapping:e.mapping};this.gamepads.set(e.index,u),this.triggerCallbacks(u,t)}triggerCallbacks(e,t){try{e.buttons.forEach((a,i)=>{a.justPressed&&this.gamepadCallbacks.onButtonDown?.(e.index,i,a.value),a.justReleased&&this.gamepadCallbacks.onButtonUp?.(e.index,i)}),e.axes.forEach((a,i)=>{let u=t?.axes[i]??0,d=this.applyDeadzone(a),g=this.applyDeadzone(u);Math.abs(d-g)>k&&this.gamepadCallbacks.onAxisMove?.(e.index,i,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(v,"GamepadInputs");var h=v;function y(o,n){let e=new h(n);return o&&e.setGamepadCallbacks(o),e.start(),e}m(y,"useGamepadInputs");export{b as BaseInputs,N as GamepadInput,h as GamepadInputs,B as InputDeviceType,w as InputEventType,V as Vector2,y as useGamepadInputs};