@omnipad/core 0.1.1-alpha.0 → 0.2.0-alpha.2

package/dist/index.d.mts

@@ -569,7 +569,7 @@ interface BaseConfig {
  * Configuration for a virtual keyboard button.
  */
 interface KeyboardButtonConfig extends BaseConfig {
-    type: typeof TYPES.KEYBOARD_BUTTON;
+    type: typeof CMP_TYPES.KEYBOARD_BUTTON;
     /** Visual text displayed on the button. */
     label: string;
     /** Keyboard event metadata to be emitted when triggered. */
@@ -579,12 +579,41 @@ interface KeyboardButtonConfig extends BaseConfig {
      */
     targetStageId?: string;
 }
+/**
+ * Mouse Button Configuration
+ */
+interface MouseButtonConfig extends BaseConfig {
+    type: typeof CMP_TYPES.MOUSE_BUTTON;
+    /** Label displayed on the button */
+    label: string;
+    /**
+     * 0: Left (Main), 1: Middle, 2: Right (Context)
+     * @default 0
+     */
+    button: 0 | 1 | 2;
+    /** CID of the target Stage to receive clicks */
+    targetStageId?: string;
+    /**
+     * Fixed coordinate to click on (0-100 percentage).
+     * If provided, the click always hits this spot regardless of cursor position.
+     */
+    fixedPoint?: Vec2;
+}
+interface TrackpadConfig extends BaseConfig {
+    type: typeof CMP_TYPES.TRACKPAD;
+    /** Label displayed on the trackpad */
+    label: string;
+    /** Simulation sensitivity, e.g. 0.5 - 2.0 */
+    sensitivity: number;
+    /** CID of the target Stage to receive clicks */
+    targetStageId?: string;
+}
 /**
  * Configuration for an Input Zone.
  * Input Zones act as containers and can handle dynamic (floating) widgets.
  */
 interface InputZoneConfig extends BaseConfig {
-    type: typeof TYPES.INPUT_ZONE;
+    type: typeof CMP_TYPES.INPUT_ZONE;
     /** If true, attempts to regain focus for the target stage when touched. */
     preventFocusLoss?: boolean;
     /**
@@ -597,7 +626,7 @@ interface InputZoneConfig extends BaseConfig {
  * Acts as the bridge between virtual signals and the actual game/app DOM.
  */
 interface TargetZoneConfig extends BaseConfig {
-    type: typeof TYPES.TARGET_ZONE;
+    type: typeof CMP_TYPES.TARGET_ZONE;
     /** Whether to render a visual virtual cursor. */
     cursorEnabled?: boolean;
     /** Time in milliseconds before the cursor auto-hides after inactivity. 0 to disable. */
@@ -651,81 +680,6 @@ interface ConfigTreeNode {
     children?: ConfigTreeNode[];
 }
 
-/**
- * Metadata for basic pointer interaction.
- * Shared by all interactable entities to track physical touch/mouse state.
- */
-interface InteractionState {
-    /** Indicates if the component is currently being touched or clicked. */
-    isActive: boolean;
-    /** The unique ID of the pointer being tracked, used for Pointer Capture. */
-    pointerId: number | null;
-}
-/**
- * Logic-level state for button-type widgets.
- * Handles the processed output after debouncing or toggle logic.
- */
-interface ButtonLogicState {
-    /** The final logical state of the button (true = pressed). */
-    isPressed: boolean;
-    /** Numerical value representing pressure or analog depth, ranging from 0.0 to 1.0. */
-    value: number;
-}
-/**
- * Logic-level state for joystick-type widgets.
- * Provides directional data calculated from the stick movement.
- */
-interface JoystickLogicState {
-    /** Normalized direction vector where x and y range from -1.0 to 1.0. */
-    vector: {
-        x: number;
-        y: number;
-    };
-    /** The current angle of the stick in radians. */
-    angle: number;
-}
-/**
- * Runtime state for the Virtual Cursor within a TargetZone.
- */
-interface CursorState {
-    /** Current position of the cursor as a percentage (0-100) relative to the stage. */
-    position: Vec2;
-    /** Visibility toggle based on movement or configuration. */
-    isVisible: boolean;
-    /** Indicates if a logical "Mouse Down" is currently active. */
-    isPointerDown: boolean;
-    /** A temporary flag used to trigger focus-reclaim visual feedback. */
-    isFocusReturning: boolean;
-}
-/**
- * State for managing dynamic/floating widgets within an InputZone.
- */
-interface InputZoneState {
-    /** Indicates if a dynamic widget (e.g., a floating stick) is currently spawned. */
-    isDynamicActive: boolean;
-    /** The ID (UID) of the pointer that triggered the dynamic widget. */
-    dynamicPointerId: number | null;
-    /** The initial spawn coordinates of the dynamic widget (percentage 0-100). */
-    dynamicPosition: Vec2;
-}
-/**
- * Basic state for Managed Layers.
- */
-interface LayerState {
-    /** Visual hint for layout debugging or active selection. */
-    isHighlighted: boolean;
-}
-/**
- * Combined state for Keyboard Button components.
- */
-interface KeyboardButtonState extends InteractionState, ButtonLogicState {
-}
-/**
- * Combined state for Analog Stick components.
- */
-interface JoystickState extends InteractionState, JoystickLogicState {
-}
-
 /**
  * Trait: Provides identity with a unique ID and specific entity type.
  */
@@ -753,10 +707,9 @@ interface ICoreEntity extends IIdentifiable, ILifecycle {
  */
 interface ISpatial {
     /**
-     * Updates the physical boundary rect, usually called by a ResizeObserver in the adapter layer.
-     * @param rect - The new DOMRect of the element.
+     * Dynamically obtain dimensions and position to ensure the most precise real-time screen coordinates are obtained during each interaction.
      */
-    updateRect(rect: DOMRect): void;
+    bindRectProvider(provider: () => DOMRect): void;
 }
 /**
  * Trait: Provides configuration management.
@@ -816,6 +769,152 @@ interface ISignalReceiver {
     handleSignal(signal: InputActionSignal): void;
 }
 
+/**
+ * Interface for the global Registry singleton.
+ */
+interface IRegistry {
+    /**
+     * Registers an entity into the system.
+     * Usually called during a component's constructor or onMounted lifecycle.
+     *
+     * @param entity - The logic entity instance to register.
+     */
+    register(entity: ICoreEntity): void;
+    /**
+     * Unregisters an entity from the system.
+     * Usually called during a component's destroy or onUnmounted lifecycle.
+     *
+     * @param uid - The unique identifier of the entity.
+     */
+    unregister(uid: string): void;
+    /**
+     * Queries an entity by its UID.
+     * Supports generics for easy type casting to specific logic types (e.g., ISignalReceiver).
+     *
+     * @example
+     * // usually global ID like "$main-stage"
+     * const stage = Registry.getInstance().getEntity<TargetZoneCore>('$main-stage');
+     *
+     * @param uid - The unique identifier of the target entity.
+     * @returns The entity instance, or undefined if not found.
+     */
+    getEntity<T extends ICoreEntity = ICoreEntity>(uid: string): T | undefined;
+    /**
+     * Returns a flat array of all currently registered entities.
+     * Useful for global operations or full-profile backups.
+     */
+    getAllEntities(): ICoreEntity[];
+    /**
+     * Retrieves an entity and all its recursive descendants based on parentId relationships.
+     *
+     * @param rootUid - The UID of the entity to start the search from.
+     * @returns An array of entities belonging to the specified subtree (including the root).
+     */
+    getEntitiesByRoot(rootUid: string): ICoreEntity[];
+    /**
+     * Recursively destroys an entity and all its descendants.
+     * Ensures all signals are cut off and instances are removed from the registry.
+     *
+     * @param rootUid - The Entity ID of the root node to be destroyed.
+     */
+    destroyByRoot(rootUid: string): void;
+    /**
+     * Triggers the reset() method on all compatible entities.
+     * Essential for cutting off active input signals (e.g., stuck keys) during profile reloads.
+     */
+    resetAll(): void;
+    /**
+     * Clears all registered entities.
+     * Used for system resets or full application unmounts.
+     */
+    clear(): void;
+}
+
+/**
+ * Metadata for basic pointer interaction.
+ * Shared by all interactable entities to track physical touch/mouse state.
+ */
+interface InteractionState {
+    /** Indicates if the component is currently being touched or clicked. */
+    isActive: boolean;
+    /** The unique ID of the pointer being tracked, used for Pointer Capture. */
+    pointerId: number | null;
+}
+/**
+ * Logic-level state for button-type widgets.
+ * Handles the processed output after debouncing or toggle logic.
+ */
+interface ButtonLogicState {
+    /** The final logical state of the button (true = pressed). */
+    isPressed: boolean;
+    /** Numerical value representing pressure or analog depth, ranging from 0.0 to 1.0. */
+    value: number;
+}
+/**
+ * Logic-level state for joystick-type widgets.
+ * Provides directional data calculated from the stick movement.
+ */
+interface JoystickLogicState {
+    /** Normalized direction vector where x and y range from -1.0 to 1.0. */
+    vector: {
+        x: number;
+        y: number;
+    };
+    /** The current angle of the stick in radians. */
+    angle: number;
+}
+/**
+ * Runtime state for the Virtual Cursor within a TargetZone.
+ */
+interface CursorState {
+    /** Current position of the cursor as a percentage (0-100) relative to the stage. */
+    position: Vec2;
+    /** Visibility toggle based on movement or configuration. */
+    isVisible: boolean;
+    /** Indicates if a logical "Mouse Down" is currently active. */
+    isPointerDown: boolean;
+    /** A temporary flag used to trigger focus-reclaim visual feedback. */
+    isFocusReturning: boolean;
+}
+/**
+ * State for managing dynamic/floating widgets within an InputZone.
+ */
+interface InputZoneState {
+    /** Indicates if a dynamic widget (e.g., a floating stick) is currently spawned. */
+    isDynamicActive: boolean;
+    /** The ID (UID) of the pointer that triggered the dynamic widget. */
+    dynamicPointerId: number | null;
+    /** The initial spawn coordinates of the dynamic widget (percentage 0-100). */
+    dynamicPosition: Vec2;
+}
+/**
+ * Basic state for Managed Layers.
+ */
+interface LayerState {
+    /** Visual hint for layout debugging or active selection. */
+    isHighlighted: boolean;
+}
+/**
+ * Combined state for Keyboard Button components.
+ */
+interface KeyboardButtonState extends InteractionState, ButtonLogicState {
+}
+/**
+ * Combined state for Mouse Button components.
+ */
+interface MouseButtonState extends InteractionState, ButtonLogicState {
+}
+/**
+ * Combined state for Trackpad components.
+ */
+interface TrackpadState extends InteractionState, ButtonLogicState {
+}
+/**
+ * Combined state for Analog Stick components.
+ */
+interface JoystickState extends InteractionState, JoystickLogicState {
+}
+
 /**
  * =================================================================
  * 1. Constants Definition
@@ -825,7 +924,7 @@ interface ISignalReceiver {
 /**
  * Core entity types supported by the library.
  */
-declare const TYPES: {
+declare const CMP_TYPES: {
     /** Area responsible for capturing touches and spawning dynamic widgets */
     readonly INPUT_ZONE: "input-zone";
     /** Area responsible for receiving signals and simulating DOM events */
@@ -881,11 +980,11 @@ type WidgetId = string;
 /** Unique identifier for a Zone container (InputZone) */
 type ZoneId = string;
 /** Union type of all built-in entity values */
-type AnyEntityType = (typeof TYPES)[keyof typeof TYPES];
+type AnyEntityType = (typeof CMP_TYPES)[keyof typeof CMP_TYPES];
 /** Supported Widget type strings, allowing for custom string extensions */
-type WidgetType = typeof TYPES.KEYBOARD_BUTTON | typeof TYPES.MOUSE_BUTTON | typeof TYPES.ANALOG_STICK | typeof TYPES.D_PAD | typeof TYPES.TRACKPAD | (string & {});
+type WidgetType = typeof CMP_TYPES.KEYBOARD_BUTTON | typeof CMP_TYPES.MOUSE_BUTTON | typeof CMP_TYPES.ANALOG_STICK | typeof CMP_TYPES.D_PAD | typeof CMP_TYPES.TRACKPAD | (string & {});
 /** Supported Zone type strings, allowing for custom string extensions */
-type ZoneType = typeof TYPES.INPUT_ZONE | typeof TYPES.TARGET_ZONE | (string & {});
+type ZoneType = typeof CMP_TYPES.INPUT_ZONE | typeof CMP_TYPES.TARGET_ZONE | (string & {});
 /** General node type identifier for ConfigTreeNode or Registry lookups */
 type EntityType = AnyEntityType | (string & {});
 /** Built-in input action identifiers */
@@ -927,6 +1026,8 @@ interface InputActionSignal {
         keyCode?: number;
         /** Coordinate point in percentage (0-100) */
         point?: Vec2;
+        /** Relative displacement in percentage (0-100) */
+        delta?: Vec2;
         /** Mouse button index (0: Left, 1: Middle, 2: Right) */
         button?: 0 | 1 | 2;
         /** Input pressure or force (0.0 to 1.0) */
@@ -1055,9 +1156,10 @@ declare const applyAxialDeadzone: (v: Vec2, threshold: number, max: number) => V
  *
  * @param x - Viewport X coordinate (px)
  * @param y - Viewport Y coordinate (px)
+ * @param ignoreClass - Style class of DOM elements to be ignored
  * @returns The deepmost Element or null if none found at the position.
  */
-declare const getDeepElement: (x: number, y: number) => Element | null;
+declare const getDeepElement: (x: number, y: number, ignoreClass?: string) => Element | null;
 /**
  * Recursively finds the truly focused element by traversing Shadow DOM boundaries.
  *
@@ -1222,21 +1324,26 @@ declare class SimpleEmitter<T> {
 declare class InputManager {
     /** Internal flag to prevent multiple event registrations */
     private _isListening;
+    /** A throttled version of the reset logic */
+    private throttledReset;
     private constructor();
     /**
      * Retrieves the global instance of the InputManager.
      * Ensures uniqueness across multiple bundles or modules.
      */
     static getInstance(): InputManager;
+    /**
+     * Manually triggers a system-wide input reset via Registry.
+     */
+    private handleGlobalReset;
+    private handleResizeReset;
+    private handleBlurReset;
+    private handleVisibilityChangeReset;
     /**
      * Initializes global safety listeners.
      * Should be called once at the root component lifecycle (e.g., VirtualLayer).
      */
     init(): void;
-    /**
-     * Manually triggers a system-wide input reset via Registry.
-     */
-    private handleGlobalReset;
     /**
      * Toggle full-screen state of the page.
      * @param element Target HTMLElement
@@ -1252,67 +1359,6 @@ declare class InputManager {
     destroy(): void;
 }
 
-/**
- * Interface for the global Registry singleton.
- */
-interface IRegistry {
-    /**
-     * Registers an entity into the system.
-     * Usually called during a component's constructor or onMounted lifecycle.
-     *
-     * @param entity - The logic entity instance to register.
-     */
-    register(entity: ICoreEntity): void;
-    /**
-     * Unregisters an entity from the system.
-     * Usually called during a component's destroy or onUnmounted lifecycle.
-     *
-     * @param uid - The unique identifier of the entity.
-     */
-    unregister(uid: string): void;
-    /**
-     * Queries an entity by its UID.
-     * Supports generics for easy type casting to specific logic types (e.g., ISignalReceiver).
-     *
-     * @example
-     * // usually global ID like "$main-stage"
-     * const stage = Registry.getInstance().getEntity<TargetZoneCore>('$main-stage');
-     *
-     * @param uid - The unique identifier of the target entity.
-     * @returns The entity instance, or undefined if not found.
-     */
-    getEntity<T extends ICoreEntity = ICoreEntity>(uid: string): T | undefined;
-    /**
-     * Returns a flat array of all currently registered entities.
-     * Useful for global operations or full-profile backups.
-     */
-    getAllEntities(): ICoreEntity[];
-    /**
-     * Retrieves an entity and all its recursive descendants based on parentId relationships.
-     *
-     * @param rootUid - The UID of the entity to start the search from.
-     * @returns An array of entities belonging to the specified subtree (including the root).
-     */
-    getEntitiesByRoot(rootUid: string): ICoreEntity[];
-    /**
-     * Recursively destroys an entity and all its descendants.
-     * Ensures all signals are cut off and instances are removed from the registry.
-     *
-     * @param rootUid - The Entity ID of the root node to be destroyed.
-     */
-    destroyByRoot(rootUid: string): void;
-    /**
-     * Triggers the reset() method on all compatible entities.
-     * Essential for cutting off active input signals (e.g., stuck keys) during profile reloads.
-     */
-    resetAll(): void;
-    /**
-     * Clears all registered entities.
-     * Used for system resets or full application unmounts.
-     */
-    clear(): void;
-}
-
 /**
  * Global Registry Singleton.
  *
@@ -1352,7 +1398,7 @@ declare abstract class BaseEntity<TConfig, TState> implements ICoreEntity, ISpat
     readonly type: EntityType;
     protected config: TConfig;
     protected state: TState;
-    protected rect: DOMRect | null;
+    protected rectProvider: (() => DOMRect) | null;
     protected stateEmitter: SimpleEmitter<TState>;
     constructor(uid: string, type: EntityType, initialConfig: TConfig, initialState: TState);
     subscribe(cb: (state: TState) => void): () => void;
@@ -1364,7 +1410,11 @@ declare abstract class BaseEntity<TConfig, TState> implements ICoreEntity, ISpat
     protected setState(partialState: Partial<TState>): void;
     destroy(): void;
     abstract reset(): void;
-    updateRect(rect: DOMRect): void;
+    bindRectProvider(provider: () => DOMRect): void;
+    /**
+     * Called when triggering interactions, this subclass fetches the latest boundaries in real time.
+     */
+    protected getRect(): DOMRect | null;
     updateConfig(newConfig: Partial<TConfig>): void;
     getState(): Readonly<TState>;
     getConfig(): Readonly<TConfig>;
@@ -1428,6 +1478,32 @@ declare class KeyboardButtonCore extends BaseEntity<KeyboardButtonConfig, Keyboa
     reset(): void;
 }
 
+/**
+ * Core logic implementation for a mouse button widget.
+ * Handles pointer interactions and translates them into mouse signals (down, up, click) for a target stage.
+ */
+declare class MouseButtonCore extends BaseEntity<MouseButtonConfig, MouseButtonState> implements IPointerHandler {
+    constructor(uid: string, config: MouseButtonConfig);
+    onPointerDown(e: PointerEvent): void;
+    onPointerUp(e: PointerEvent): void;
+    onPointerCancel(e: PointerEvent): void;
+    onPointerMove(e: PointerEvent): void;
+    /**
+     * Handles the release of the button.
+     *
+     * @param e - The pointer event.
+     * @param isNormalRelease - If true, a 'click' event will also be dispatched.
+     */
+    private handleRelease;
+    /**
+     * Dispatches input signals to the registered target stage.
+     *
+     * @param type - The action type (mousedown, mouseup, or click).
+     */
+    private sendInputSignal;
+    reset(): void;
+}
+
 /**
  * Core logic for the Root/Managed Layer.
  *
@@ -1445,10 +1521,19 @@ declare class RootLayerCore extends BaseEntity<BaseConfig, LayerState> {
  * It acts as a receiver that translates abstract input signals into native browser events,
  * while maintaining virtual cursor positioning and ensuring the game maintains focus.
  */
-declare class TargetZoneCore extends BaseEntity<TargetZoneConfig, CursorState> implements ISignalReceiver {
+declare class TargetZoneCore extends BaseEntity<TargetZoneConfig, CursorState> implements IPointerHandler, ISignalReceiver {
     private hideTimer;
     private focusFeedbackTimer;
+    private throttledPointerMove;
     constructor(uid: string, config: TargetZoneConfig);
+    onPointerDown(e: PointerEvent): void;
+    onPointerMove(e: PointerEvent): void;
+    onPointerUp(e: PointerEvent): void;
+    onPointerCancel(e: PointerEvent): void;
+    /**
+     * Convert physical DOM events into internal signals
+     */
+    private processPhysicalEvent;
     handleSignal(signal: InputActionSignal): void;
     /**
      * Calculates pixel coordinates and dispatches simulated pointer events to the deepest element.
@@ -1469,6 +1554,10 @@ declare class TargetZoneCore extends BaseEntity<TargetZoneConfig, CursorState> i
      * Updates the internal virtual cursor coordinates.
      */
     private updateCursorPosition;
+    /**
+     * Updates the internal virtual cursor coordinates by delta.
+     */
+    private updateCursorPositionByDelta;
     /**
      * Makes the virtual cursor visible and sets a timeout for auto-hiding.
      */
@@ -1476,7 +1565,64 @@ declare class TargetZoneCore extends BaseEntity<TargetZoneConfig, CursorState> i
     reset(): void;
 }
 
+/**
+ * Core logic implementation for a trackpad widget.
+ * Translates pointer gestures into relative mouse movements and click actions.
+ * Supports tap-to-click and double-tap-to-drag scenarios.
+ */
+declare class TrackpadCore extends BaseEntity<TrackpadConfig, TrackpadState> implements IPointerHandler {
+    private lastPointerPos;
+    private startTime;
+    private startPos;
+    private lastClickTime;
+    private isDragMode;
+    private throttledPointerMove;
+    /**
+     * Creates an instance of TrackpadCore.
+     *
+     * @param uid - Unique entity ID.
+     * @param config - Configuration for the trackpad.
+     */
+    constructor(uid: string, config: TrackpadConfig);
+    onPointerDown(e: PointerEvent): void;
+    onPointerMove(e: PointerEvent): void;
+    /**
+     * Internal logic for processing pointer movement.
+     * Calculates displacement and emits relative move signals.
+     *
+     * @param e - The pointer event.
+     */
+    private processPointerMove;
+    onPointerUp(e: PointerEvent): void;
+    onPointerCancel(e: PointerEvent): void;
+    reset(): void;
+    /**
+     * Clean up pointer capture and reset interaction state.
+     */
+    private handleRelease;
+    /**
+     * Helper to send signals to the target stage via Registry.
+     *
+     * @param type - Signal action type.
+     * @param extraPayload - Additional data like delta or point.
+     */
+    private sendSignal;
+}
+
 declare const OmniPad: {
+    ActionTypes: {
+        readonly KEYDOWN: "keydown";
+        readonly KEYUP: "keyup";
+        readonly POINTER: "pointer";
+        readonly POINTERMOVE: "pointermove";
+        readonly POINTERDOWN: "pointerdown";
+        readonly POINTERUP: "pointerup";
+        readonly MOUSE: "mouse";
+        readonly MOUSEMOVE: "mousemove";
+        readonly MOUSEDOWN: "mousedown";
+        readonly MOUSEUP: "mouseup";
+        readonly CLICK: "click";
+    };
     Context: {
         readonly PARENT_ID_KEY: "omnipad-parent-id-link";
     };
@@ -1990,4 +2136,4 @@ declare const OmniPad: {
     };
 };
 
-export { ACTION_TYPES, type AnchorPoint, type AnyConfig, type AnyEntityType, type BaseConfig, BaseEntity, type BuiltInActionType, type ButtonLogicState, CONTEXT, type ConfigTreeNode, type CursorState, type EntityType, type FlatConfigItem, type FlexibleLength, type GamepadProfile, type IConfigurable, type ICoreEntity, type IIdentifiable, type ILifecycle, type IObservable, type IPointerHandler, type IResettable, type ISignalReceiver, type ISpatial, type InputActionSignal, type InputActionType, InputManager, type InputZoneConfig, InputZoneCore, type InputZoneState, type InteractionState, type JoystickLogicState, type JoystickState, KEYS, type KeyMapping, type KeyboardButtonConfig, KeyboardButtonCore, type KeyboardButtonState, type LayerState, type LayoutBox, type Listener, OmniPad, Registry, RootLayerCore, SimpleEmitter, type StageId, TYPES, type TargetZoneConfig, TargetZoneCore, type Unit, type Vec2, type WidgetId, type WidgetType, type ZoneId, type ZoneType, addVec, applyAxialDeadzone, applyRadialDeadzone, clamp, clampVector, degToRad, dispatchKeyboardEvent, dispatchPointerEventAtPos, exportProfile, focusElement, generateUID, getAnchorPosition, getAngle, getDeadzoneScalar, getDeepActiveElement, getDeepElement, getDistance, isGlobalID, isVec2Equal, lerp, lockTo4Directions, lockTo8Directions, normalizeVec, parseProfileJson, parseProfileTree, percentToPx, pxToPercent, radToDeg, radToVec, remap, resolveLayoutStyle, roundTo, scaleVec, subVec };
+export { ACTION_TYPES, type AnchorPoint, type AnyConfig, type AnyEntityType, type BaseConfig, BaseEntity, type BuiltInActionType, type ButtonLogicState, CMP_TYPES, CONTEXT, type ConfigTreeNode, type CursorState, type EntityType, type FlatConfigItem, type FlexibleLength, type GamepadProfile, type IConfigurable, type ICoreEntity, type IIdentifiable, type ILifecycle, type IObservable, type IPointerHandler, type IRegistry, type IResettable, type ISignalReceiver, type ISpatial, type InputActionSignal, type InputActionType, InputManager, type InputZoneConfig, InputZoneCore, type InputZoneState, type InteractionState, type JoystickLogicState, type JoystickState, KEYS, type KeyMapping, type KeyboardButtonConfig, KeyboardButtonCore, type KeyboardButtonState, type LayerState, type LayoutBox, type Listener, type MouseButtonConfig, MouseButtonCore, type MouseButtonState, OmniPad, Registry, RootLayerCore, SimpleEmitter, type StageId, type TargetZoneConfig, TargetZoneCore, type TrackpadConfig, TrackpadCore, type TrackpadState, type Unit, type Vec2, type WidgetId, type WidgetType, type ZoneId, type ZoneType, addVec, applyAxialDeadzone, applyRadialDeadzone, clamp, clampVector, degToRad, dispatchKeyboardEvent, dispatchPointerEventAtPos, exportProfile, focusElement, generateUID, getAnchorPosition, getAngle, getDeadzoneScalar, getDeepActiveElement, getDeepElement, getDistance, isGlobalID, isVec2Equal, lerp, lockTo4Directions, lockTo8Directions, normalizeVec, parseProfileJson, parseProfileTree, percentToPx, pxToPercent, radToDeg, radToVec, remap, resolveLayoutStyle, roundTo, scaleVec, subVec };