@codexo/exojs 0.6.11 → 0.7.11

package/dist/esm/input/InteractionEvent.d.ts

@@ -0,0 +1,18 @@
+import type { Pointer } from './Pointer';
+import type { RenderNode } from '@/rendering/RenderNode';
+export type InteractionEventType = 'pointerdown' | 'pointerup' | 'pointermove' | 'pointerover' | 'pointerout' | 'pointertap' | 'dragstart' | 'drag' | 'dragend';
+export declare class InteractionEvent {
+    readonly type: InteractionEventType;
+    /** The node that was originally hit (deepest interactive). Stable across bubble. */
+    target: RenderNode;
+    /** The node currently dispatching this event during bubbling. Changes per bubble step. */
+    currentTarget: RenderNode;
+    readonly pointer: Pointer;
+    /** Canvas-space coordinates (same space as Pointer.x/y). */
+    readonly worldX: number;
+    readonly worldY: number;
+    private _stopped;
+    constructor(type: InteractionEventType, target: RenderNode, pointer: Pointer, worldX: number, worldY: number);
+    get propagationStopped(): boolean;
+    stopPropagation(): void;
+}

package/dist/esm/input/InteractionEvent.js

@@ -0,0 +1,29 @@
+class InteractionEvent {
+    type;
+    /** The node that was originally hit (deepest interactive). Stable across bubble. */
+    target;
+    /** The node currently dispatching this event during bubbling. Changes per bubble step. */
+    currentTarget;
+    pointer;
+    /** Canvas-space coordinates (same space as Pointer.x/y). */
+    worldX;
+    worldY;
+    _stopped = false;
+    constructor(type, target, pointer, worldX, worldY) {
+        this.type = type;
+        this.target = target;
+        this.currentTarget = target;
+        this.pointer = pointer;
+        this.worldX = worldX;
+        this.worldY = worldY;
+    }
+    get propagationStopped() {
+        return this._stopped;
+    }
+    stopPropagation() {
+        this._stopped = true;
+    }
+}
+
+export { InteractionEvent };
+//# sourceMappingURL=InteractionEvent.js.map

package/dist/esm/input/InteractionEvent.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"InteractionEvent.js","sources":["../../../../src/input/InteractionEvent.ts"],"sourcesContent":[null],"names":[],"mappings":"MAca,gBAAgB,CAAA;AACT,IAAA,IAAI;;AAEb,IAAA,MAAM;;AAEN,IAAA,aAAa;AACJ,IAAA,OAAO;;AAEP,IAAA,MAAM;AACN,IAAA,MAAM;IACd,QAAQ,GAAY,KAAK;IAEjC,WAAA,CACI,IAA0B,EAC1B,MAAkB,EAClB,OAAgB,EAChB,MAAc,EACd,MAAc,EAAA;AAEd,QAAA,IAAI,CAAC,IAAI,GAAG,IAAI;AAChB,QAAA,IAAI,CAAC,MAAM,GAAG,MAAM;AACpB,QAAA,IAAI,CAAC,aAAa,GAAG,MAAM;AAC3B,QAAA,IAAI,CAAC,OAAO,GAAG,OAAO;AACtB,QAAA,IAAI,CAAC,MAAM,GAAG,MAAM;AACpB,QAAA,IAAI,CAAC,MAAM,GAAG,MAAM;IACxB;AAEA,IAAA,IAAW,kBAAkB,GAAA;QACzB,OAAO,IAAI,CAAC,QAAQ;IACxB;IAEO,eAAe,GAAA;AAClB,QAAA,IAAI,CAAC,QAAQ,GAAG,IAAI;IACxB;AACH;;;;"}

package/dist/esm/input/InteractionManager.d.ts

@@ -0,0 +1,134 @@
+import { Quadtree } from '@/math/Quadtree';
+import type { RenderNode } from '@/rendering/RenderNode';
+import type { Application } from '@/core/Application';
+export declare class InteractionManager {
+    private readonly _app;
+    private _quadtree;
+    private _interactiveNodes;
+    private _staleNodes;
+    private _quadtreeItems;
+    private _quadtreeOrderCounter;
+    private readonly _quadtreeQueryBuffer;
+    /** Maps pointerId → the deepest interactive RenderNode that pointer is currently over. */
+    private readonly _lastHit;
+    /** Pending per-pointer event queues, filled by signal handlers each frame. */
+    private readonly _pending;
+    /** Active pointer captures set up by drag-start. Maps pointerId → the captured node. */
+    private readonly _capturedPointers;
+    /** Active drag states. Maps pointerId → drag metadata. */
+    private readonly _drags;
+    /** Whether any pointer enqueued events since the last update(). */
+    private _dirty;
+    private readonly _onPointerDownHandler;
+    private readonly _onPointerMoveHandler;
+    private readonly _onPointerUpHandler;
+    private readonly _onPointerTapHandler;
+    private readonly _onPointerCancelHandler;
+    private readonly _onPointerLeaveHandler;
+    constructor(app: Application);
+    /**
+     * Returns the RenderNode currently hovered by the given pointer, or null.
+     * If pointerId is omitted, returns the hovered node for the first pointer
+     * in iteration order (typically the primary mouse pointer).
+     */
+    getHoveredNode(pointerId?: number): RenderNode | null;
+    /**
+     * Returns all currently captured RenderNodes (nodes that have an active
+     * drag / pointer-capture in progress). Used by debug layers.
+     */
+    getCapturedNodes(): ReadonlyArray<RenderNode>;
+    /**
+     * Returns the internal quadtree used for spatial hit-testing, or null when
+     * no interactive nodes are present. The quadtree is automatically created
+     * when the first interactive node is registered and disposed when the last
+     * interactive node is removed. Prefixed with underscore to signal
+     * "internal-but-public" (debug use only).
+     */
+    _getDebugQuadtree(): Quadtree<{
+        node: RenderNode;
+        order: number;
+    }> | null;
+    destroy(): void;
+    /**
+     * Process all pending pointer events accumulated since the last frame.
+     * Must be called once per frame from {@link Application.update}, after
+     * `inputManager.update()` has run (so signals are already dispatched and
+     * queued here) and before game-state updates so that user listeners on
+     * `onPointerDown` etc. fire before per-frame logic mutates state.
+     *
+     * The dirty flag ensures this is a no-op on frames with no pointer
+     * activity; every signal handler that enqueues an event sets `_dirty =
+     * true`, and `update()` clears it at the top before draining the queue.
+     */
+    update(): void;
+    /**
+     * Called when a subtree rooted at `node` has been added to the scene.
+     * Walks the subtree and registers any interactive nodes found.
+     *
+     * @internal
+     */
+    _notifyNodeAdded(node: RenderNode): void;
+    /**
+     * Called when a subtree rooted at `node` is about to be removed from the
+     * scene. Walks the subtree and unregisters any interactive nodes found.
+     *
+     * @internal
+     */
+    _notifyNodeRemoved(node: RenderNode): void;
+    /**
+     * Called when a node's `interactive` property changes.
+     *
+     * @internal
+     */
+    _notifyInteractiveChanged(node: RenderNode, becameInteractive: boolean): void;
+    /**
+     * Called when a node's world transform / bounds are invalidated. If the
+     * node is currently tracked as interactive, mark it stale so its quadtree
+     * entry is refreshed on the next query.
+     *
+     * @internal
+     */
+    _notifyBoundsInvalidated(node: RenderNode): void;
+    private _handlePointerDown;
+    private _handlePointerMove;
+    private _handlePointerUp;
+    private _handlePointerTap;
+    private _handlePointerCancel;
+    private _handlePointerLeave;
+    private _enqueue;
+    private _processQueue;
+    private _endDrag;
+    private _hitTest;
+    private _hitTestIndexed;
+    private _hitTestNode;
+    /**
+     * Register an interactive node: add it to the tracking set, create the
+     * quadtree if this is the first interactive node, and insert the node.
+     */
+    private _registerNode;
+    /**
+     * Unregister an interactive node: remove from the quadtree and tracking
+     * set. Dispose the quadtree when it becomes empty.
+     */
+    private _unregisterNode;
+    /**
+     * Insert a single node into the quadtree (or mark it stale to be inserted
+     * at next flush if the quadtree is not yet ready).
+     */
+    private _insertNode;
+    /**
+     * Flush stale entries: remove each stale node's old quadtree entry and
+     * re-insert it with fresh bounds. Called at the start of update().
+     */
+    private _flushStaleEntries;
+    /** Build a fresh Quadtree sized to encompass the canvas + current scene root. */
+    private _createQuadtree;
+    /** Walk a subtree, calling `callback` for every RenderNode (including root). */
+    private _walkSubtree;
+    private _dispatchBubble;
+    /** Dispatch an event directly on a single node without bubbling. */
+    private _dispatchDirect;
+    private _signalFor;
+    private _setLastHit;
+    private _updateCursor;
+}