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

package/dist/touch.d.ts

@@ -0,0 +1,572 @@
+import { Vector2, Vector3, IMobileVibrationProcessor, VibrationPattern } from '@utsp/types';
+export { InputDeviceType, TouchInput, Vector2, VibrationPattern } 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;
+}
+
+/**
+ * MobileInputs - Touch and mobile device input management
+ * Handles touch events with support for multi-touch, gestures, and orientation
+ */
+
+interface TouchPoint {
+    id: number;
+    nativeId: number;
+    position: Vector2;
+    startPosition: Vector2;
+    active: boolean;
+    justTouched: boolean;
+    justReleased: boolean;
+}
+interface MobileCallbacks {
+    onTouchStart?: (touches: TouchPoint[], event: TouchEvent) => void;
+    onTouchEnd?: (touches: TouchPoint[], event: TouchEvent) => void;
+    onTouchMove?: (touches: TouchPoint[], event: TouchEvent) => void;
+    onTouchCancel?: (touches: TouchPoint[], event: TouchEvent) => void;
+    onOrientationChange?: (orientation: number) => void;
+}
+interface MobileInputsConfig extends InputConfig {
+    /** Prevent default browser behavior (scroll, zoom) - Default: true */
+    preventDefault?: boolean;
+    /** Use passive event listeners for better performance - Default: false */
+    passive?: boolean;
+    /** Maximum number of simultaneous touches - Default: 10 */
+    maxTouches?: number;
+}
+declare class MobileInputs extends BaseInputs {
+    private touches;
+    private nativeToInternal;
+    private mobileCallbacks;
+    private mobileConfig;
+    private maxTouches;
+    private lastLogTime;
+    private boundHandlers;
+    constructor(targetElement?: HTMLElement | Window, config?: MobileInputsConfig);
+    start(): void;
+    stop(): void;
+    reset(): void;
+    resetDelta(): void;
+    /**
+     * Poll - Reset transient states (justTouched/justReleased)
+     * Should be called once per frame AFTER collecting input
+     */
+    poll(): void;
+    /**
+     * Check if a touch is active (touchId 0-9)
+     *
+     * @param touchId - Touch identifier (0-9)
+     * @returns True if touch is active, false otherwise
+     *
+     * @example
+     * ```typescript
+     * if (mobile.isTouchActive(0)) {
+     *   const pos = mobile.getTouchPosition(0);
+     *   console.log('First touch at', pos);
+     * }
+     * ```
+     */
+    isTouchActive(touchId: number): boolean;
+    /**
+     * Get the position of a touch (touchId 0-9)
+     *
+     * @param touchId - Touch identifier (0-9)
+     * @returns Vector2 with current position, or null if touch is not active
+     *
+     * @example
+     * ```typescript
+     * const pos = mobile.getTouchPosition(0);
+     * if (pos) {
+     *   player.moveTo(pos.x, pos.y);
+     * }
+     * ```
+     */
+    getTouchPosition(touchId: number): Vector2 | null;
+    /**
+     * Get the starting position of a touch (touchId 0-9)
+     *
+     * @param touchId - Touch identifier (0-9)
+     * @returns Vector2 with start position, or null if touch is not active
+     *
+     * @example
+     * ```typescript
+     * const start = mobile.getTouchStartPosition(0);
+     * const current = mobile.getTouchPosition(0);
+     * if (start && current) {
+     *   const swipeDistance = current.subtract(start).length();
+     *   if (swipeDistance > 100) {
+     *     console.log('Swipe detected!');
+     *   }
+     * }
+     * ```
+     */
+    getTouchStartPosition(touchId: number): Vector2 | null;
+    /**
+     * Get the delta since the beginning of the touch
+     *
+     * @param touchId - Touch identifier (0-9)
+     * @returns Vector2 with delta from start position, or null if touch is not active
+     *
+     * @example
+     * ```typescript
+     * const delta = mobile.getTouchDelta(0);
+     * if (delta && delta.x > 50) {
+     *   console.log('Swiped right!');
+     * }
+     * ```
+     */
+    getTouchDelta(touchId: number): Vector2 | null;
+    /**
+     * Get the number of active touches
+     *
+     * @returns Number of simultaneous touches (0-10)
+     *
+     * @example
+     * ```typescript
+     * const count = mobile.getTouchCount();
+     * if (count === 2) {
+     *   console.log('Pinch gesture possible');
+     * }
+     * ```
+     */
+    getTouchCount(): number;
+    /**
+     * Check if a touch just started this frame
+     *
+     * @param touchId - Touch identifier (0-9)
+     * @returns True if touch just started, false otherwise
+     *
+     * @example
+     * ```typescript
+     * if (mobile.isTouchJustStarted(0)) {
+     *   playSound('tap');
+     * }
+     * ```
+     */
+    isTouchJustStarted(touchId: number): boolean;
+    /**
+     * Check if a touch just ended this frame
+     *
+     * @param touchId - Touch identifier (0-9)
+     * @returns True if touch just ended, false otherwise
+     *
+     * @example
+     * ```typescript
+     * if (mobile.isTouchJustReleased(0)) {
+     *   releaseDragObject();
+     * }
+     * ```
+     */
+    isTouchJustReleased(touchId: number): boolean;
+    /**
+     * Check if any touch just started this frame
+     */
+    isAnyTouchJustStarted(): boolean;
+    /**
+     * Get all active touches
+     *
+     * @returns Array of all active TouchPoint objects
+     *
+     * @example
+     * ```typescript
+     * const touches = mobile.getAllTouches();
+     * touches.forEach(touch => {
+     *   console.log(`Touch ${touch.id} at`, touch.position);
+     * });
+     * ```
+     */
+    getAllTouches(): TouchPoint[];
+    /**
+     * Set mobile-specific callbacks
+     *
+     * @param callbacks - Object containing callback functions
+     *
+     * @example
+     * ```typescript
+     * mobile.setMobileCallbacks({
+     *   onTouchStart: (touches, event) => {
+     *     console.log(`${touches.length} touches started`);
+     *   },
+     *   onTouchMove: (touches, event) => {
+     *     touches.forEach(t => console.log(`Touch ${t.id}:`, t.position));
+     *   },
+     *   onOrientationChange: (orientation) => {
+     *     console.log('Orientation:', orientation);
+     *   },
+     * });
+     * ```
+     */
+    setMobileCallbacks(callbacks: MobileCallbacks): void;
+    clearMobileCallbacks(): void;
+    setCallbacks(callbacks: MobileCallbacks | unknown): void;
+    private isMobileCallbacks;
+    private handleTouchStart;
+    private handleTouchEnd;
+    private handleTouchMove;
+    private handleTouchCancel;
+    private handleOrientationChange;
+}
+/**
+ * React hook for mobile inputs
+ *
+ * ⚠️ IMPORTANT: This function is NOT a proper React hook!
+ * It creates a new MobileInputs instance on every render, causing memory leaks.
+ *
+ * To use correctly in React, wrap with useMemo and useEffect:
+ *
+ * @example
+ * ```typescript
+ * import { useMemo, useEffect } from 'react';
+ *
+ * const inputs = useMemo(() => new MobileInputs(canvasRef.current, config), [config]);
+ *
+ * useEffect(() => {
+ *   if (callbacks) inputs.setCallbacks(callbacks);
+ *   inputs.start();
+ *   return () => inputs.stop();
+ * }, [inputs, callbacks]);
+ * ```
+ *
+ * @deprecated Use the pattern above instead of this function
+ */
+declare function useMobileInputs(targetElement?: HTMLElement | Window, callbacks?: MobileCallbacks, config?: MobileInputsConfig): MobileInputs;
+
+/**
+ * MobileVibration - Vibration feedback for mobile devices
+ *
+ * Provides vibration feedback using the Navigator Vibration API.
+ * Requires user interaction before first use (browser security requirement).
+ *
+ * @example
+ * ```typescript
+ * const vibration = new MobileVibration();
+ *
+ * // Simple vibration
+ * vibration.vibrate(100); // 100ms vibration
+ *
+ * // Pattern vibration
+ * vibration.vibrate([100, 50, 100]); // vibrate 100ms, pause 50ms, vibrate 100ms
+ *
+ * // Predefined patterns
+ * vibration.tap();       // Light tap feedback
+ * vibration.success();   // Success confirmation
+ * vibration.error();     // Error notification
+ * vibration.warning();   // Warning notification
+ * ```
+ */
+
+/**
+ * Configuration options for MobileVibration
+ */
+interface MobileVibrationConfig {
+    /** Enable vibration (default: true) */
+    enabled?: boolean;
+    /** Enable debug logging (default: false) */
+    debug?: boolean;
+    /** Global intensity multiplier 0.0-1.0 (default: 1.0) */
+    intensity?: number;
+}
+/**
+ * Predefined vibration patterns for common use cases
+ */
+declare const VibrationPatterns: {
+    /** Light tap - single short pulse */
+    readonly tap: 10;
+    /** Medium tap - slightly longer pulse */
+    readonly mediumTap: 25;
+    /** Heavy tap - strong pulse */
+    readonly heavyTap: 50;
+    /** Success - two quick pulses */
+    readonly success: readonly [30, 50, 30];
+    /** Error - three rapid pulses */
+    readonly error: readonly [50, 30, 50, 30, 50];
+    /** Warning - one long pulse */
+    readonly warning: readonly [100];
+    /** Selection change - very light feedback */
+    readonly selection: 5;
+    /** Impact light */
+    readonly impactLight: 15;
+    /** Impact medium */
+    readonly impactMedium: 30;
+    /** Impact heavy */
+    readonly impactHeavy: 50;
+    /** Notification - attention-grabbing pattern */
+    readonly notification: readonly [100, 100, 100, 100, 100];
+    /** SOS pattern in Morse code */
+    readonly sos: readonly [100, 30, 100, 30, 100, 30, 200, 30, 200, 30, 200, 30, 100, 30, 100, 30, 100];
+};
+/**
+ * MobileVibration manager - implements IMobileVibrationProcessor
+ */
+declare class MobileVibration implements IMobileVibrationProcessor {
+    private config;
+    private supported;
+    private userActivated;
+    constructor(config?: MobileVibrationConfig);
+    /**
+     * Check if vibration is supported on this device
+     */
+    isSupported(): boolean;
+    /**
+     * Check if vibration is enabled
+     */
+    isEnabled(): boolean;
+    /**
+     * Enable or disable vibration
+     */
+    setEnabled(enabled: boolean): void;
+    /**
+     * Set global intensity multiplier (0.0 to 1.0)
+     * This scales the duration of all vibrations
+     */
+    setIntensity(intensity: number): void;
+    /**
+     * Get current intensity setting
+     */
+    getIntensity(): number;
+    /**
+     * Vibrate with a pattern or duration
+     *
+     * @param pattern - Duration in ms, or array of [vibrate, pause, vibrate, pause, ...]
+     * @returns true if vibration was triggered, false otherwise
+     *
+     * @example
+     * ```typescript
+     * vibration.vibrate(100);           // Vibrate for 100ms
+     * vibration.vibrate([100, 50, 100]); // Vibrate, pause, vibrate
+     * ```
+     */
+    vibrate(pattern: VibrationPattern): boolean;
+    /**
+     * Stop any ongoing vibration
+     */
+    cancel(): void;
+    /**
+     * Check if user has activated vibration (first successful vibration)
+     * This can be useful for UI feedback
+     */
+    hasUserActivation(): boolean;
+    /**
+     * Light tap feedback - for button presses, selections
+     */
+    tap(): boolean;
+    /**
+     * Medium tap feedback
+     */
+    mediumTap(): boolean;
+    /**
+     * Heavy tap feedback - for important actions
+     */
+    heavyTap(): boolean;
+    /**
+     * Success feedback - for completed actions
+     */
+    success(): boolean;
+    /**
+     * Error feedback - for failed actions
+     */
+    error(): boolean;
+    /**
+     * Warning feedback - for important notices
+     */
+    warning(): boolean;
+    /**
+     * Selection feedback - very light, for UI navigation
+     */
+    selection(): boolean;
+    /**
+     * Light impact feedback
+     */
+    impactLight(): boolean;
+    /**
+     * Medium impact feedback
+     */
+    impactMedium(): boolean;
+    /**
+     * Heavy impact feedback
+     */
+    impactHeavy(): boolean;
+    /**
+     * Notification feedback - attention-grabbing pattern
+     */
+    notification(): boolean;
+    /**
+     * Scale a vibration pattern by intensity
+     */
+    private scalePattern;
+}
+/**
+ * Get the default MobileVibration instance (singleton)
+ */
+declare function getMobileVibration(): MobileVibration;
+
+export { BaseInputs, InputEventType, MobileInputs, MobileVibration, VibrationPatterns, getMobileVibration, useMobileInputs };
+export type { ButtonState, IInputs, InputConfig, MobileCallbacks, MobileInputsConfig, MobileVibrationConfig, MotionData, TouchPoint };

package/dist/touch.mjs

@@ -0,0 +1 @@
+var M=Object.defineProperty;var w=(l,o,e)=>o in l?M(l,o,{enumerable:!0,configurable:!0,writable:!0,value:e}):l[o]=e;var h=(l,o)=>M(l,"name",{value:o,configurable:!0});var a=(l,o,e)=>(w(l,typeof o!="symbol"?o+"":o,e),e);import{Vector2 as W}from"@utsp/types";import{InputDeviceType as U,TouchInput as B}from"@utsp/types";var E=(c=>(c.KeyDown="keydown",c.KeyUp="keyup",c.MouseDown="mousedown",c.MouseUp="mouseup",c.MouseMove="mousemove",c.MouseWheel="mousewheel",c.TouchStart="touchstart",c.TouchEnd="touchend",c.TouchMove="touchmove",c.GamepadConnected="gamepadconnected",c.GamepadDisconnected="gamepaddisconnected",c.GamepadButton="gamepadbutton",c.GamepadAxis="gamepadaxis",c))(E||{}),v=class v{constructor(o=window,e={}){a(this,"isActive",!1);a(this,"targetElement");a(this,"config");a(this,"callbacks",{});this.targetElement=o,this.config={enabled:!0,preventDefault:!1,stopPropagation:!1,debug:!1,...e}}isListening(){return this.isActive}destroy(){this.stop(),this.clearCallbacks()}setCallbacks(o){typeof o=="object"&&o!==null&&Object.assign(this.callbacks,o)}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(o,...e){this.callbacks[o]&&this.callbacks[o].forEach(t=>{try{t(...e)}catch(n){this.config.debug&&console.error(`Error in ${o} callback:`,n)}})}log(...o){this.config.debug&&console.warn("[InputSystem]",...o)}};h(v,"BaseInputs");var b=v;import{Vector2 as y}from"@utsp/types";var m=class m extends b{constructor(e=window,t={}){super(e,t);a(this,"touches",new Map);a(this,"nativeToInternal",new Map);a(this,"mobileCallbacks",{});a(this,"mobileConfig");a(this,"maxTouches",10);a(this,"lastLogTime",0);a(this,"boundHandlers");this.mobileConfig={targetElement:e,preventDefault:t.preventDefault??!0,passive:t.passive??!1,maxTouches:t.maxTouches??10,enabled:t.enabled??!0,debug:t.debug??!1,stopPropagation:t.stopPropagation??!1},this.maxTouches=this.mobileConfig.maxTouches,this.mobileConfig.preventDefault&&this.mobileConfig.passive&&(console.warn("[MobileInputs] passive=true prevents preventDefault() from working! Setting passive=false."),this.mobileConfig.passive=!1),this.boundHandlers={touchStart:this.handleTouchStart.bind(this),touchEnd:this.handleTouchEnd.bind(this),touchMove:this.handleTouchMove.bind(this),touchCancel:this.handleTouchCancel.bind(this),orientationChange:this.handleOrientationChange.bind(this)}}start(){if(this.isActive)return;let e={passive:!this.mobileConfig.preventDefault&&this.mobileConfig.passive};this.targetElement.addEventListener("touchstart",this.boundHandlers.touchStart,e),this.targetElement.addEventListener("touchend",this.boundHandlers.touchEnd,e),this.targetElement.addEventListener("touchmove",this.boundHandlers.touchMove,e),this.targetElement.addEventListener("touchcancel",this.boundHandlers.touchCancel,e),window.addEventListener("orientationchange",this.boundHandlers.orientationChange),this.isActive=!0}stop(){this.isActive&&(this.targetElement.removeEventListener("touchstart",this.boundHandlers.touchStart),this.targetElement.removeEventListener("touchend",this.boundHandlers.touchEnd),this.targetElement.removeEventListener("touchmove",this.boundHandlers.touchMove),this.targetElement.removeEventListener("touchcancel",this.boundHandlers.touchCancel),window.removeEventListener("orientationchange",this.boundHandlers.orientationChange),this.isActive=!1)}reset(){this.touches.clear(),this.nativeToInternal.clear()}resetDelta(){}poll(){for(let e of this.touches.values())e.justTouched=!1,e.justReleased=!1}isTouchActive(e){return e<0||e>=this.maxTouches?!1:this.touches.has(e)}getTouchPosition(e){if(e<0||e>=this.maxTouches)return null;let t=this.touches.get(e);return t?t.position.clone():null}getTouchStartPosition(e){if(e<0||e>=this.maxTouches)return null;let t=this.touches.get(e);return t?t.startPosition.clone():null}getTouchDelta(e){if(e<0||e>=this.maxTouches)return null;let t=this.touches.get(e);return t?t.position.subtract(t.startPosition):null}getTouchCount(){return this.touches.size}isTouchJustStarted(e){if(e<0||e>=this.maxTouches)return!1;let t=this.touches.get(e);return t?t.justTouched:!1}isTouchJustReleased(e){if(e<0||e>=this.maxTouches)return!1;let t=this.touches.get(e);return t?t.justReleased:!1}isAnyTouchJustStarted(){for(let e of this.touches.values())if(e.justTouched)return!0;return!1}getAllTouches(){return Array.from(this.touches.values())}setMobileCallbacks(e){this.mobileCallbacks={...this.mobileCallbacks,...e}}clearMobileCallbacks(){this.mobileCallbacks={}}setCallbacks(e){this.isMobileCallbacks(e)&&this.setMobileCallbacks(e)}isMobileCallbacks(e){return typeof e=="object"&&e!==null&&("onTouchStart"in e||"onTouchEnd"in e||"onTouchMove"in e||"onTouchCancel"in e||"onOrientationChange"in e)}handleTouchStart(e){try{this.mobileConfig.preventDefault&&e.preventDefault();let t=Array.from(e.changedTouches),n=[];for(let s of t){if(this.touches.size>=this.maxTouches)break;let i=-1;for(let d=0;d<this.maxTouches;d++)if(!this.touches.has(d)){i=d;break}if(i===-1)continue;let r=new y(s.clientX,s.clientY),C={id:i,nativeId:s.identifier,position:r.clone(),startPosition:r.clone(),active:!0,justTouched:!0,justReleased:!1};this.touches.set(i,C),this.nativeToInternal.set(s.identifier,i),n.push(C),console.warn(`\u{1F446} Touch START - ID: ${i}`)}this.mobileCallbacks.onTouchStart?.(n,e)}catch(t){console.error("Error in touch start handler:",t)}}handleTouchEnd(e){try{this.mobileConfig.preventDefault&&e.preventDefault();let t=Array.from(e.changedTouches),n=[];for(let s of t){let i=this.nativeToInternal.get(s.identifier);if(i!==void 0){let r=this.touches.get(i);r&&(r.justReleased=!0,r.justTouched=!1,n.push({...r}))}}for(let s of t){let i=this.nativeToInternal.get(s.identifier);i!==void 0&&(this.touches.delete(i),this.nativeToInternal.delete(s.identifier),console.warn(`\u{1F447} Touch END - ID: ${i}`))}this.mobileCallbacks.onTouchEnd?.(n,e)}catch(t){console.error("Error in touch end handler:",t)}}handleTouchMove(e){try{let t=Array.from(e.changedTouches);this.mobileConfig.debug&&(!this.lastLogTime||Date.now()-this.lastLogTime>200)&&(console.warn(`\u{1F504} TouchMove event - ${t.length} touches changed`),this.lastLogTime=Date.now());for(let n of t){let s=this.nativeToInternal.get(n.identifier);if(s!==void 0){let i=this.touches.get(s);if(i){let r=i.position.clone();i.position=new y(n.clientX,n.clientY),this.mobileConfig.debug&&(!this.lastLogTime||Date.now()-this.lastLogTime>200)&&console.warn(`\u{1F504} Updated touch ${i.id} (native ${n.identifier}) - ${r.x.toFixed(1)},${r.y.toFixed(1)} \u2192 ${n.clientX.toFixed(1)},${n.clientY.toFixed(1)}`)}}else this.mobileConfig.debug&&console.warn(`\u26A0\uFE0F Touch move for unknown native ID ${n.identifier}`)}this.mobileCallbacks.onTouchMove?.(this.getAllTouches(),e)}catch(t){console.error("Error in touch move handler:",t)}}handleTouchCancel(e){try{this.mobileConfig.preventDefault&&e.preventDefault();let t=[],n=Array.from(e.changedTouches);for(let s of n){let i=this.nativeToInternal.get(s.identifier);if(i!==void 0){let r=this.touches.get(i);r&&(r.justReleased=!0,r.justTouched=!1,t.push({...r}))}}for(let s of n){let i=this.nativeToInternal.get(s.identifier);i!==void 0&&(this.touches.delete(i),this.nativeToInternal.delete(s.identifier),this.mobileConfig.debug&&console.warn(`\u274C Touch CANCEL - ID: ${i}, nativeId: ${s.identifier}`))}this.mobileCallbacks.onTouchCancel?.(t,e)}catch(t){console.error("Error in touch cancel handler:",t)}}handleOrientationChange(e){try{let t=(window.screen.orientation&&window.screen.orientation.angle)??window.orientation??0;this.mobileCallbacks.onOrientationChange?.(t)}catch(t){console.error("Error in orientation change handler:",t)}}};h(m,"MobileInputs");var p=m;function x(l,o,e){console.warn("[MobileInputs] useMobileInputs() is deprecated and causes memory leaks. Use useMemo + useEffect instead.");let t=new p(l,e);return o&&t.setCallbacks(o),t.start(),t}h(x,"useMobileInputs");var u={tap:10,mediumTap:25,heavyTap:50,success:[30,50,30],error:[50,30,50,30,50],warning:[100],selection:5,impactLight:15,impactMedium:30,impactHeavy:50,notification:[100,100,100,100,100],sos:[100,30,100,30,100,30,200,30,200,30,200,30,100,30,100,30,100]},T=class T{constructor(o={}){a(this,"config");a(this,"supported",!1);a(this,"userActivated",!1);this.config={enabled:o.enabled??!0,debug:o.debug??!1,intensity:Math.max(0,Math.min(1,o.intensity??1))},this.supported=typeof navigator<"u"&&"vibrate"in navigator,this.config.debug&&console.log(`[MobileVibration] Vibration API supported: ${this.supported}`)}isSupported(){return this.supported}isEnabled(){return this.config.enabled&&this.supported}setEnabled(o){this.config.enabled=o,this.config.debug&&console.log(`[MobileVibration] Enabled: ${o}`)}setIntensity(o){this.config.intensity=Math.max(0,Math.min(1,o)),this.config.debug&&console.log(`[MobileVibration] Intensity set to: ${this.config.intensity}`)}getIntensity(){return this.config.intensity}vibrate(o){if(!this.isEnabled())return!1;try{let e=this.scalePattern(o),t=typeof e=="number"?e:[...e],n=navigator.vibrate(t);return this.config.debug&&console.log(`[MobileVibration] Vibrate: ${JSON.stringify(e)} -> ${n}`),n&&(this.userActivated=!0),n}catch(e){return this.config.debug&&console.error("[MobileVibration] Vibration failed:",e),!1}}cancel(){this.supported&&(navigator.vibrate(0),this.config.debug&&console.log("[MobileVibration] Vibration cancelled"))}hasUserActivation(){return this.userActivated}tap(){return this.vibrate(u.tap)}mediumTap(){return this.vibrate(u.mediumTap)}heavyTap(){return this.vibrate(u.heavyTap)}success(){return this.vibrate(u.success)}error(){return this.vibrate(u.error)}warning(){return this.vibrate(u.warning)}selection(){return this.vibrate(u.selection)}impactLight(){return this.vibrate(u.impactLight)}impactMedium(){return this.vibrate(u.impactMedium)}impactHeavy(){return this.vibrate(u.impactHeavy)}notification(){return this.vibrate(u.notification)}scalePattern(o){return this.config.intensity===1?o:typeof o=="number"?Math.round(o*this.config.intensity):o.map((e,t)=>t%2===0?Math.round(e*this.config.intensity):e)}};h(T,"MobileVibration");var f=T,g=null;function k(){return g||(g=new f),g}h(k,"getMobileVibration");export{b as BaseInputs,U as InputDeviceType,E as InputEventType,p as MobileInputs,f as MobileVibration,B as TouchInput,W as Vector2,u as VibrationPatterns,k as getMobileVibration,x as useMobileInputs};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@utsp/input",
-  "version": "0.9.0",
+  "version": "0.10.0-nightly.20251213135145.115c488",
   "description": "Comprehensive input management system for UTSP - keyboard, mouse, gamepad, and touch support with unified routing",
   "author": "THP Software",
   "license": "MIT",
@@ -13,6 +13,58 @@
       "types": "./dist/index.d.ts",
       "import": "./dist/index.mjs",
       "require": "./dist/index.cjs"
+    },
+    "./core": {
+      "types": "./dist/core.d.ts",
+      "import": "./dist/core.mjs",
+      "require": "./dist/core.cjs"
+    },
+    "./keyboard": {
+      "types": "./dist/keyboard.d.ts",
+      "import": "./dist/keyboard.mjs",
+      "require": "./dist/keyboard.cjs"
+    },
+    "./mouse": {
+      "types": "./dist/mouse.d.ts",
+      "import": "./dist/mouse.mjs",
+      "require": "./dist/mouse.cjs"
+    },
+    "./touch": {
+      "types": "./dist/touch.d.ts",
+      "import": "./dist/touch.mjs",
+      "require": "./dist/touch.cjs"
+    },
+    "./gamepad": {
+      "types": "./dist/gamepad.d.ts",
+      "import": "./dist/gamepad.mjs",
+      "require": "./dist/gamepad.cjs"
+    },
+    "./desktop": {
+      "types": "./dist/desktop.d.ts",
+      "import": "./dist/desktop.mjs",
+      "require": "./dist/desktop.cjs"
+    }
+  },
+  "typesVersions": {
+    "*": {
+      "core": [
+        "./dist/core.d.ts"
+      ],
+      "keyboard": [
+        "./dist/keyboard.d.ts"
+      ],
+      "mouse": [
+        "./dist/mouse.d.ts"
+      ],
+      "touch": [
+        "./dist/touch.d.ts"
+      ],
+      "gamepad": [
+        "./dist/gamepad.d.ts"
+      ],
+      "desktop": [
+        "./dist/desktop.d.ts"
+      ]
     }
   },
   "keywords": [
@@ -52,7 +104,7 @@
     "access": "public"
   },
   "dependencies": {
-    "@utsp/types": "0.9.0"
+    "@utsp/types": "0.10.0-nightly.20251213135145.115c488"
   },
   "devDependencies": {
     "typescript": "^5.6.3"