@omnipad/core 0.4.5 → 0.5.0

package/dist/dom/index.d.ts

@@ -0,0 +1,306 @@
+import { e as IPointerHandler } from '../traits-dAndzyWS.js';
+import { S as StickyProvider } from '../sticky-CLBq1EPa.js';
+import { G as GamepadMappingConfig } from '../index-DVegtw8s.js';
+
+/**
+ * Forcefully focuses an element.
+ * Automatically handles the 'tabindex' attribute to ensure non-focusable elements (like Canvas)
+ * can receive focus.
+ *
+ * @param el - The target HTMLElement to focus.
+ */
+declare const focusElement: (el: HTMLElement) => void;
+/**
+ * Dispatches a synthetic KeyboardEvent to the window object.
+ *
+ * @param type - The event type, e.g., 'keydown' or 'keyup'.
+ * @param payload - Key mapping data including key, code, and legacy keyCode.
+ */
+declare const dispatchKeyboardEvent: (type: string, payload: {
+    key: string;
+    code: string;
+    keyCode: number;
+}) => void;
+/**
+ * Dispatches a high-fidelity sequence of Pointer and Mouse events at specific pixel coordinates.
+ * Finds the target element dynamically at the moment of dispatch.
+ *
+ * @param type - The event type (should start with 'pointer' for best compatibility).
+ * @param x - Viewport X coordinate (px).
+ * @param y - Viewport Y coordinate (px).
+ * @param opts - Additional PointerEvent options (button, pressure, etc.).
+ */
+declare const dispatchPointerEventAtPos: (type: string, x: number, y: number, opts: {
+    button: number;
+    buttons: number;
+    pressure: number;
+}) => void;
+/**
+ * Reclaims browser focus for the element located at the specified viewport coordinates.
+ *
+ * This utility identifies the deepest element (penetrating Shadow DOM) at the given position
+ * and ensures it becomes the active element. It is essential for ensuring that
+ * game engines (like Ruffle) receive keyboard events immediately after a virtual interaction.
+ *
+ * @param x - The horizontal coordinate relative to the viewport.
+ * @param y - The vertical coordinate relative to the viewport.
+ * @returns True if the focus was successfully moved to the target; false if it was already focused or no target found.
+ */
+declare const reclaimFocusAtPos: (x: number, y: number, callback: () => void) => void;
+
+/**
+ * Creates a standardized bridge between native DOM PointerEvents and Core abstract handlers.
+ * Handles event prevention, stop propagation, pointer capture, and multi-touch filtering.
+ *
+ * @param coreHandler - The logic core instance that implements IPointerHandler.
+ * @param getElement - A getter function to retrieve the DOM element for pointer capture.
+ * @returns An object containing mapped event handlers for Vue/React template binding.
+ */
+declare function createPointerBridge(coreHandler: IPointerHandler & {
+    activePointerId?: number | null;
+}, options?: {
+    /** Respond only to direct clicks (without responding to events bubbled up from child elements) */
+    requireDirectHit?: boolean;
+}): {
+    /**
+     * Entry point for a pointer interaction.
+     * Establishes capture and initializes core logic.
+     */
+    onPointerDown(e: PointerEvent): void;
+    /**
+     * Continuous movement handling.
+     * Throttling should be handled within the core implementation.
+     */
+    onPointerMove(e: PointerEvent): void;
+    /**
+     * Successful interaction completion.
+     * Filters by pointerId to ensure only the capturing finger triggers release.
+     */
+    onPointerUp(e: PointerEvent): void;
+    /**
+     * System-level interaction cancellation (e.g., alert popups, browser gestures).
+     */
+    onPointerCancel(e: PointerEvent): void;
+};
+
+/**
+ * Safely sets pointer capture on an element.
+ *
+ * @param el - The target element to capture the pointer.
+ * @param pointerId - The unique ID of the pointer (from PointerEvent).
+ */
+declare const safeSetCapture: (el: EventTarget | null, pointerId: number) => void;
+/**
+ * Safely releases pointer capture from an element.
+ * Checks for current capture state and wraps in try-catch to prevent crashes.
+ *
+ * @param el - The target element.
+ * @param pointerId - The unique ID of the pointer to release.
+ */
+declare const safeReleaseCapture: (el: EventTarget | null, pointerId: number) => void;
+
+declare const supportsContainerQueries: () => boolean;
+
+/**
+ * Recursively penetrates Shadow DOM boundaries to find the deepest element at the
+ * specified viewport coordinates.
+ *
+ * @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, ignoreClass?: string) => Element | null;
+/**
+ * Recursively finds the truly focused element by traversing Shadow DOM boundaries.
+ *
+ * @returns The deepmost active Element in focus or null.
+ */
+declare const getDeepActiveElement: () => Element | null;
+/**
+ * A robust wrapper for selecting a single DOM element.
+ *
+ *
+ * @param selector - A string containing one or more selectors to match.
+ * @returns The first {@link Element} that matches the specified selector, or `null` if no matches are found or the selector is invalid.
+ *
+ * @example
+ * // Handles special characters in IDs gracefully
+ * smartQuerySelector('#my.id$with:special-chars');
+ * // Falls back to standard CSS selectors
+ * smartQuerySelector('.container > div:first-child');
+ */
+declare const smartQuerySelector: (selector: string) => Element | null;
+
+/**
+ * Creates a StickyProvider pre-configured for the Web environment.
+ */
+declare const createWebStickyProvider: (selector: string) => StickyProvider;
+
+/**
+ * A centralized observation pool for DOM elements.
+ *
+ * This class provides a high-performance wrapper around `ResizeObserver` (RO) and
+ * `IntersectionObserver` (IO). By pooling all element observations into single
+ * native observer instances and utilizing `requestAnimationFrame` (rAF) throttling,
+ * it significantly reduces memory footprint and prevents layout thrashing.
+ *
+ * It supports deterministic unregistration via UIDs, making it ideal for
+ * framework adapters (like Vue or React) where DOM references may become unstable
+ * during unmounting.
+ */
+declare class ElementObserver {
+    private _ro;
+    private _roRegistry;
+    private _elToRoCb;
+    private _io;
+    private _ioRegistry;
+    private _elToIoCb;
+    private constructor();
+    static getInstance(): ElementObserver;
+    /**
+     * Starts observing size changes for a specific element.
+     *
+     * @param uid - The unique entity ID associated with the observation.
+     * @param el - The target DOM element to observe.
+     * @param cb - Callback triggered when the element's size changes.
+     */
+    observeResize(uid: string, el: Element, cb: () => void): void;
+    /**
+     * Stops observing size changes for the entity identified by the UID.
+     *
+     * @param uid - The unique entity ID to unregister.
+     */
+    unobserveResize(uid: string): void;
+    /**
+     * Starts observing visibility (intersection) changes for a specific element.
+     *
+     * @param uid - The unique entity ID associated with the observation.
+     * @param el - The target DOM element to observe.
+     * @param cb - Callback triggered when visibility enters or exits the viewport.
+     */
+    observeIntersect(uid: string, el: Element, cb: (isIntersecting: boolean) => void): void;
+    /**
+     * Stops observing intersection changes for the entity identified by the UID.
+     *
+     * @param uid - The unique entity ID to unregister.
+     */
+    unobserveIntersect(uid: string): void;
+    /**
+     * Disconnects all observers (RO and IO) associated with a specific UID.
+     * Usually called during component destruction for thorough cleanup.
+     *
+     * @param uid - The unique entity ID to fully disconnect.
+     */
+    disconnect(uid: string): void;
+}
+
+/**
+ * GamepadManager
+ *
+ * A singleton service that polls the browser Gamepad API via requestAnimationFrame.
+ * It translates physical hardware inputs into programmatic signals sent to
+ * virtual entities registered in the system.
+ *
+ * Handles:
+ * 1. Button edge detection (Down/Up).
+ * 2. D-Pad to vector conversion.
+ * 3. Analog stick deadzone processing.
+ */
+declare class GamepadManager {
+    private isRunning;
+    private config;
+    private lastButtonStates;
+    private constructor();
+    /**
+     * Retrieves the global singleton instance of the GamepadManager.
+     */
+    static getInstance(): GamepadManager;
+    /**
+     * Updates the current gamepad mapping configuration.
+     *
+     * @param config - The mapping of physical inputs to virtual component IDs (UID).
+     */
+    setConfig(config: GamepadMappingConfig[]): void;
+    /** Return the current gamepad mapping configuration. */
+    getConfig(): Readonly<GamepadMappingConfig[] | null>;
+    /**
+     * Starts the polling loop and listens for gamepad connection events.
+     */
+    start(): void;
+    /**
+     * Stops the polling loop.
+     */
+    stop(): void;
+    /**
+     * The core polling loop executing at the browser's refresh rate.
+     */
+    private loop;
+    /**
+     * Process binary button inputs with edge detection.
+     */
+    private processButtons;
+    /**
+     * Translates physical D-Pad buttons into a normalized vector.
+     */
+    private processDPad;
+    /**
+     * Process analog stick movements with deadzone logic.
+     */
+    private processAxes;
+    /**
+     * Locates a virtual entity and triggers its programmatic interface.
+     *
+     * @param uid - The Entity ID (UID) of the target.
+     * @param action - The type of trigger ('down', 'up', or 'vector').
+     * @param payload - Optional data for vector movements.
+     */
+    private triggerVirtualEntity;
+}
+
+/**
+ * Global Input Manager Singleton.
+ *
+ * Responsible for monitoring global browser events (resize, blur, visibility)
+ * and coordinating system-wide resets to prevent stuck inputs.
+ */
+declare class WindowManager {
+    /** 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 WindowManager.
+     * Ensures uniqueness across multiple bundles or modules.
+     */
+    static getInstance(): WindowManager;
+    /**
+     * Manually triggers a system-wide input reset via Registry.
+     */
+    private handleGlobalReset;
+    private handleResizeReset;
+    private handleBlurReset;
+    private handleScrollReset;
+    private handleVisibilityChangeReset;
+    /**
+     * Initializes global safety listeners.
+     * Should be called once at the root component lifecycle (e.g., VirtualLayer).
+     */
+    init(): void;
+    /**
+     * Toggle full-screen state of the page.
+     * @param element Target HTMLElement
+     */
+    toggleFullscreen(element?: HTMLElement): Promise<void>;
+    /**
+     * Full-screen status query provided to the UI layer.
+     */
+    isFullscreen(): boolean;
+    /**
+     * Detaches all global listeners.
+     */
+    destroy(): void;
+}
+
+export { ElementObserver, GamepadManager, WindowManager, createPointerBridge, createWebStickyProvider, dispatchKeyboardEvent, dispatchPointerEventAtPos, focusElement, getDeepActiveElement, getDeepElement, reclaimFocusAtPos, safeReleaseCapture, safeSetCapture, smartQuerySelector, supportsContainerQueries };

package/dist/dom/index.mjs

@@ -0,0 +1 @@
+import {a as a$1}from'../chunk-ZM2LX5IW.mjs';import {k}from'../chunk-MKVX5ALC.mjs';import {a,h as h$1}from'../chunk-PACTGVBB.mjs';var m=(n,t,e="omnipad-prevent")=>{let i=document.elementsFromPoint(n,t).find(s=>!s.classList.contains(e));if(!i)return null;for(;i&&i.shadowRoot;){let a=i.shadowRoot.elementsFromPoint(n,t).find(l=>!l.classList.contains(e));if(!a||a===i)break;i=a;}return i},g=()=>{let n=document.activeElement;for(;n&&n.shadowRoot&&n.shadowRoot.activeElement;)n=n.shadowRoot.activeElement;return n},R=n=>{if(!n)return null;if(n.startsWith("#")){let t=n.slice(1),e=document.getElementById(t);if(e)return e}try{return document.querySelector(n)}catch{return null}};var x=n=>{g()!==n&&(n.hasAttribute("tabindex")||n.setAttribute("tabindex","-1"),n.focus());},M=(n,t)=>{let e=new KeyboardEvent(n,{...t,which:t.keyCode,bubbles:true,cancelable:true,view:window});window.dispatchEvent(e);},D=(n,t,e,r)=>{let i=m(t,e);if(!i)return;let s={bubbles:true,cancelable:true,composed:true,clientX:t,clientY:e,view:window,...r};if(n.startsWith("pointer")){i.dispatchEvent(new PointerEvent(n,{isPrimary:true,pointerId:9999,pointerType:"mouse",...s}));let a=n.replace("pointer","mouse");i.dispatchEvent(new MouseEvent(a,s));}else i.dispatchEvent(new MouseEvent(n,s));},L=(n,t,e)=>{let r=m(n,t);if(!r)return;g()!==r&&(x(r),e());};var w=(n,t)=>{if(n instanceof Element)try{n.setPointerCapture(t);}catch(e){import.meta.env?.DEV&&console.warn("[OmniPad-DOM] Failed to set pointer capture:",e);}},f=(n,t)=>{if(n instanceof Element&&n.hasPointerCapture(t))try{n.releasePointerCapture(t);}catch{}};function O(n,t={}){return {onPointerDown(e){if(!e.isTrusted||t?.requireDirectHit&&e.target!==e.currentTarget||n.activePointerId!=null)return;e.cancelable&&e.preventDefault(),e.stopPropagation();let r=e.currentTarget;r&&w(r,e.pointerId),n.onPointerDown(e);},onPointerMove(e){e.isTrusted&&(n.activePointerId!=null&&n.activePointerId!==e.pointerId||(e.cancelable&&e.preventDefault(),n.onPointerMove(e)));},onPointerUp(e){if(!e.isTrusted||n.activePointerId!=null&&n.activePointerId!==e.pointerId)return;e.cancelable&&e.preventDefault();let r=e.currentTarget;r&&f(r,e.pointerId),n.onPointerUp(e);},onPointerCancel(e){if(!e.isTrusted||n.activePointerId!=null&&n.activePointerId!==e.pointerId)return;let r=e.currentTarget;r&&f(r,e.pointerId),n.onPointerCancel(e);}}}var p,z=()=>(p!==void 0||(p=typeof window<"u"&&!!window.CSS?.supports?.("width: 1cqw")),p);var U=n=>new k(n,t=>R(t),t=>t.getBoundingClientRect(),t=>document.contains(t));var h=Symbol.for("omnipad.element_observer.instance"),y=class n{constructor(){a(this,"_ro");a(this,"_roRegistry",new Map);a(this,"_elToRoCb",new WeakMap);a(this,"_io");a(this,"_ioRegistry",new Map);a(this,"_elToIoCb",new WeakMap);let t=a$1(e=>{for(let r of e)this._elToRoCb.get(r.target)?.();});this._ro=new ResizeObserver(e=>{t(e);}),this._io=new IntersectionObserver(e=>{for(let r of e)this._elToIoCb.get(r.target)?.(r.isIntersecting);},{threshold:0});}static getInstance(){let t=globalThis;return t[h]||(t[h]=new n),t[h]}observeResize(t,e,r){this.unobserveResize(t),this._roRegistry.set(t,e),this._elToRoCb.set(e,r),this._ro.observe(e);}unobserveResize(t){let e=this._roRegistry.get(t);e&&(this._ro.unobserve(e),this._elToRoCb.delete(e),this._roRegistry.delete(t));}observeIntersect(t,e,r){this.unobserveIntersect(t),this._ioRegistry.set(t,e),this._elToIoCb.set(e,r),this._io.observe(e);}unobserveIntersect(t){let e=this._ioRegistry.get(t);e&&(this._io.unobserve(e),this._elToIoCb.delete(e),this._ioRegistry.delete(t));}disconnect(t){this.unobserveResize(t),this.unobserveIntersect(t);}};var v=Symbol.for("omnipad.gamepad_manager.instance"),_={A:0,B:1,X:2,Y:3,LB:4,RB:5,LT:6,RT:7,Select:8,Start:9,L3:10,R3:11,Up:12,Down:13,Left:14,Right:15},P=class n{constructor(){a(this,"isRunning",false);a(this,"config",null);a(this,"lastButtonStates",[]);a(this,"loop",()=>{if(!this.isRunning)return;let t=navigator.getGamepads();this.config?.forEach((e,r)=>{let i=t[r];i&&i.connected&&e&&(this.lastButtonStates[r]||(this.lastButtonStates[r]=[]),this.processButtons(i,e,r),this.processDPad(i,e),this.processAxes(i,e));}),requestAnimationFrame(this.loop);});}static getInstance(){let t=globalThis;return t[v]||(t[v]=new n),t[v]}setConfig(t){this.config=t;}getConfig(){return this.config}start(){this.isRunning||(this.isRunning=true,window.addEventListener("gamepadconnected",t=>{import.meta.env?.DEV&&console.log("[OmniPad-DOM] Gamepad Connected:",t.gamepad.id);}),window.addEventListener("gamepaddisconnected",()=>{import.meta.env?.DEV&&console.log("[OmniPad-DOM] Gamepad disconnected.");}),this.loop());}stop(){this.isRunning=false;}processButtons(t,e,r){e.buttons&&Object.entries(e.buttons).forEach(([i,s])=>{let a=_[i];if(a===void 0||!t.buttons[a])return;let l=t.buttons[a].pressed,u=this.lastButtonStates[r][a]||false;l&&!u?this.triggerVirtualEntity(s,"down"):!l&&u&&this.triggerVirtualEntity(s,"up"),this.lastButtonStates[r][a]=l;});}processDPad(t,e){let r=e?.dpad;if(!r)return;let i=t.buttons[12]?.pressed?-1:0,s=t.buttons[13]?.pressed?1:0,a=t.buttons[14]?.pressed?-1:0,l=t.buttons[15]?.pressed?1:0,u=a+l,C=i+s;this.triggerVirtualEntity(r,"vector",{x:u,y:C});}processAxes(t,e){let r=e?.deadzone??.1;if(e?.leftStick){let i=Math.abs(t.axes[0])>r?t.axes[0]:0,s=Math.abs(t.axes[1])>r?t.axes[1]:0;this.triggerVirtualEntity(e.leftStick,"vector",{x:i,y:s});}if(e?.rightStick){let i=Math.abs(t.axes[2])>r?t.axes[2]:0,s=Math.abs(t.axes[3])>r?t.axes[3]:0;this.triggerVirtualEntity(e.rightStick,"vector",{x:i,y:s});}}triggerVirtualEntity(t,e,r){let i=h$1.getInstance().getEntity(t);!i||i.activePointerId!=null||(e==="down"&&typeof i.triggerDown=="function"&&i.triggerDown(),e==="up"&&typeof i.triggerUp=="function"&&i.triggerUp(),e==="vector"&&typeof i.triggerVector=="function"&&r&&i.triggerVector(r.x,r.y));}};var b=Symbol.for("omnipad.window_manager.instance"),I=class n{constructor(){a(this,"_isListening",false);a(this,"throttledReset");a(this,"handleGlobalReset",()=>{import.meta.env?.DEV&&console.debug("[OmniPad-Core] Safety reset triggered by environment change."),h$1.getInstance().resetAll(),h$1.getInstance().markAllRectDirty();});a(this,"handleResizeReset",()=>{this.throttledReset(null);});a(this,"handleBlurReset",()=>{this.handleGlobalReset();});a(this,"handleScrollReset",()=>{this.throttledReset(null);});a(this,"handleVisibilityChangeReset",()=>{document.visibilityState==="hidden"&&this.handleGlobalReset();});this.throttledReset=a$1(()=>{this.handleGlobalReset();});}static getInstance(){let t=globalThis;return t[b]||(t[b]=new n),t[b]}init(){this._isListening||(window.addEventListener("resize",this.handleResizeReset),window.addEventListener("blur",this.handleBlurReset),window.addEventListener("scroll",this.handleScrollReset,{capture:true,passive:true}),document.addEventListener("visibilitychange",this.handleVisibilityChangeReset),this._isListening=true,import.meta.env?.DEV&&console.log("[OmniPad-Core] Global WindowManager monitoring started."));}async toggleFullscreen(t){let e=t||document.documentElement;try{document.fullscreenElement?(this.handleGlobalReset(),await document.exitFullscreen()):(this.handleGlobalReset(),await e.requestFullscreen());}catch(r){console.error("[OmniPad-Core] Fullscreen toggle failed:",r);}}isFullscreen(){return !!document.fullscreenElement}destroy(){window.removeEventListener("resize",this.handleResizeReset),window.removeEventListener("blur",this.handleBlurReset),window.removeEventListener("scroll",this.handleScrollReset,{capture:true}),window.removeEventListener("visibilitychange",this.handleVisibilityChangeReset),this._isListening=false;}};export{y as ElementObserver,P as GamepadManager,I as WindowManager,O as createPointerBridge,U as createWebStickyProvider,M as dispatchKeyboardEvent,D as dispatchPointerEventAtPos,x as focusElement,g as getDeepActiveElement,m as getDeepElement,L as reclaimFocusAtPos,f as safeReleaseCapture,w as safeSetCapture,R as smartQuerySelector,z as supportsContainerQueries};

package/dist/{index-CT1fDlB9.d.cts → index-DVegtw8s.d.cts}

@@ -590,9 +590,13 @@ interface LayoutBox {
      * @example 'center' will center the component on its position.
      */
     anchor?: AnchorPoint;
-    /** Rotation angle in degrees. */
     /** Z-index for layering control. */
     zIndex?: number;
+    /**
+     * CSS selector for the target element (e.g., "#game-canvas").
+     * If provided, the component switches to "Sticky" mode and positions itself relative to this element.
+     */
+    stickySelector?: string;
 }
 /**
  * Base configuration interface for all components.
@@ -600,6 +604,7 @@ interface LayoutBox {
 interface BaseConfig {
     /**
      * Config ID (CID) used in persistent storage.
+     *
      * If omitted, a random UID will be generated during parsing.
      * If starts with '$', it points to a global static entity. (UID = CID)
      */
@@ -612,9 +617,10 @@ interface BaseConfig {
     layout: LayoutBox;
     /**
      * Custom CSS class names or style tags.
-     * For visual decoration only; must not include layout attributes such as top/left/width/height.
+     *
+     * For visual decoration only; must not include layout attributes such as top/left/width/height while the same properties are set in `layout: LayoutBox`.
      */
-    cssClasses?: string | string[];
+    cssClass?: string;
 }
 /**
  * Configuration for a virtual keyboard/mouse button.
@@ -724,9 +730,9 @@ interface FlatConfigItem {
     config?: Record<string, any>;
 }
 /**
- * The root structure of a Gamepad configuration file.
+ * The root structure of a OmniPad configuration file.
  */
-interface GamepadProfile {
+interface OmniPadProfile {
     /** Metadata about the profile creator and version. */
     meta: {
         name: string;
@@ -757,155 +763,6 @@ interface ConfigTreeNode {
     children?: ConfigTreeNode[];
 }
 
-/**
- * Trait: Provides identity with a unique ID and specific entity type.
- */
-interface IIdentifiable {
-    readonly uid: string;
-    readonly type: EntityType;
-}
-/**
- * Trait: Provides lifecycle management hooks.
- */
-interface ILifecycle {
-    /**
-     * Performs cleanup, unregisters the entity, and releases resources.
-     */
-    destroy(): void;
-}
-/**
- * The core contract for any object that can be managed by the Registry.
- * Only objects implementing this interface are eligible for registration.
- */
-interface ICoreEntity extends IIdentifiable, ILifecycle {
-}
-/**
- * Trait: Enables spatial awareness for DOM/UI-related components.
- */
-interface ISpatial {
-    readonly rect: AbstractRect | null;
-    /**
-     * Dynamically obtain dimensions and position to ensure the most precise real-time screen coordinates are obtained during each interaction.
-     */
-    bindRectProvider(provider: () => AbstractRect, onMarkDirty?: () => void): void;
-    /**
-     * Trigger a cache invalidation.
-     */
-    markRectDirty(): void;
-}
-/**
- * Trait: Provides configuration management.
- */
-interface IConfigurable<TConfig> {
-    /**
-     * Retrieves a snapshot of the current configuration.
-     */
-    getConfig(): TConfig;
-    /**
-     * Subscribes to config changes.
-     * @param cb - Callback function triggered on config updates.
-     * @returns An unsubscribe function.
-     */
-    subscribeConfig(cb: (config: TConfig) => void): () => void;
-    /**
-     * Updates the internal config and notifies all subscribers.
-     * @param config - Partial configuration object to merge.
-     */
-    updateConfig(config: Partial<TConfig>): void;
-}
-/**
- * Trait: Provides state management.
- */
-interface IStateful<TState> {
-    /**
-     * Retrieves the current state snapshot.
-     */
-    getState(): TState;
-    /**
-     * Subscribes to state changes.
-     * @param cb - Callback function triggered on state updates.
-     * @returns An unsubscribe function.
-     */
-    subscribeState(cb: (state: TState) => void): () => void;
-    /**
-     * Updates the internal state and notifies all subscribers.
-     * @param state - Partial object containing updated state values.
-     */
-    setState(state: Partial<TState>): void;
-}
-/**
- * Trait: Allows resetting the entity to its idle/safe state.
- */
-interface IResettable {
-    /**
-     * Forcefully clears active states and cuts off outgoing signals.
-     */
-    reset(): void;
-}
-/**
- * Trait: Handles raw pointer input (Touch/Mouse).
- */
-interface IPointerHandler {
-    readonly activePointerId: number | null;
-    onPointerDown(e: AbstractPointerEvent): void;
-    onPointerMove(e: AbstractPointerEvent): void;
-    onPointerUp(e: AbstractPointerEvent): void;
-    onPointerCancel(e: AbstractPointerEvent): void;
-}
-/**
- * Trait: Receives and processes input signals (e.g., TargetZone).
- */
-interface ISignalReceiver {
-    /**
-     * Handles incoming signals from widgets.
-     * @param signal - The signal data containing action type and payload.
-     */
-    handleSignal(signal: InputActionSignal): void;
-}
-/**
- * Capability for an entity to receive and store external functional dependencies.
- *
- * This enables Runtime Dependency Injection (DI), allowing core logic to invoke
- * host-specific methods (such as DOM event dispatchers or custom triggers)
- * without being tightly coupled to the environment.
- */
-interface IDependencyBindable {
-    /**
-     * Binds a functional delegate by a specific identifier key.
-     *
-     * @param key - The unique lookup identifier for the dependency (e.g., 'domDispatcher').
-     * @param delegate - The function implementation provided by the adapter layer.
-     */
-    bindDelegate(key: string, delegate: AnyFunction): void;
-}
-/**
- * Contract for widgets that support programmatic control.
- *
- * This interface allows external systems—such as a Physical Gamepad Manager or
- * automation scripts—to directly drive the state and behavior of a widget,
- * bypassing native DOM pointer events.
- */
-interface IProgrammatic {
-    /**
-     * Manually triggers the 'down' (pressed) state of the widget.
-     * Primarily used for Button-type components to simulate a physical press.
-     */
-    triggerDown?(): void;
-    /**
-     * Manually triggers the 'up' (released) state of the widget.
-     * Primarily used for Button-type components to simulate a physical release.
-     */
-    triggerUp?(): void;
-    /**
-     * Manually updates the directional input vector of the widget.
-     * Primarily used for Joystick or D-Pad components.
-     *
-     * @param x - The horizontal component, normalized between -1.0 and 1.0.
-     * @param y - The vertical component, normalized between -1.0 and 1.0.
-     */
-    triggerVector?(x: number, y: number): void;
-}
-
 /**
  * =================================================================
  * 1. Constants Definition
@@ -962,7 +819,9 @@ declare const ACTION_TYPES: {
  */
 interface AbstractRect {
     left: number;
+    right: number;
     top: number;
+    bottom: number;
     width: number;
     height: number;
 }
@@ -1073,4 +932,4 @@ declare const CONTEXT: {
  */
 type AnyFunction = (...args: any[]) => void;
 
-export { type AbstractRect as A, type ButtonConfig as B, CMP_TYPES as C, type DPadConfig as D, type EntityType as E, type FlatConfigItem as F, type GamepadMappingConfig as G, type ILifecycle as H, type ICoreEntity as I, type JoystickConfig as J, type InputActionType as K, KEYS as L, type KeyMapping as M, type LayoutBox as N, type StandardButton as O, type ParsedLength as P, VALID_UNITS as Q, type WidgetType as R, type StageId as S, type TargetZoneConfig as T, type ZoneType as U, type Vec2 as V, type WidgetId as W, type ZoneId as Z, type InputActionSignal as a, type ISpatial as b, type IResettable as c, type IConfigurable as d, type IStateful as e, type IPointerHandler as f, type IProgrammatic as g, type AbstractPointerEvent as h, type InputZoneConfig as i, type IDependencyBindable as j, type AnyFunction as k, type BaseConfig as l, type ISignalReceiver as m, type TrackpadConfig as n, ACTION_TYPES as o, type ActionMapping as p, type AnchorPoint as q, type AnyConfig as r, type AnyEntityType as s, type BuiltInActionType as t, CONTEXT as u, type ConfigTreeNode as v, type CssUnit as w, type FlexibleLength as x, type GamepadProfile as y, type IIdentifiable as z };
+export { type AbstractRect as A, type ButtonConfig as B, CMP_TYPES as C, type DPadConfig as D, type EntityType as E, type FlatConfigItem as F, type GamepadMappingConfig as G, type InputActionSignal as I, type JoystickConfig as J, KEYS as K, type LayoutBox as L, type OmniPadProfile as O, type ParsedLength as P, type StageId as S, type TargetZoneConfig as T, type Vec2 as V, type WidgetId as W, type ZoneId as Z, type AbstractPointerEvent as a, type InputZoneConfig as b, type AnyFunction as c, type BaseConfig as d, type TrackpadConfig as e, ACTION_TYPES as f, type ActionMapping as g, type AnchorPoint as h, type AnyConfig as i, type AnyEntityType as j, type BuiltInActionType as k, CONTEXT as l, type ConfigTreeNode as m, type CssUnit as n, type FlexibleLength as o, type InputActionType as p, type KeyMapping as q, type StandardButton as r, VALID_UNITS as s, type WidgetType as t, type ZoneType as u };