canvasengine 2.0.0-beta.4 → 2.0.0-beta.40

package/dist/directives/ControlsBase.d.ts

@@ -0,0 +1,198 @@
+export interface ControlOptions {
+    repeat?: boolean;
+    bind: string | string[];
+    keyUp?: Function;
+    keyDown?: Function;
+    delay?: number | {
+        duration: number;
+        otherControls?: (string)[];
+    };
+}
+export interface Controls {
+    [controlName: string]: ControlOptions;
+}
+export type BoundKey = {
+    actionName: string;
+    options: ControlOptions;
+    parameters?: any;
+};
+/**
+ * Abstract base class for control systems (keyboard, gamepad, etc.)
+ *
+ * This class provides common functionality shared across all control implementations:
+ * - Input binding and management
+ * - Control configuration
+ * - Input state management
+ * - Common methods for querying and triggering controls
+ *
+ * @example
+ * ```ts
+ * class MyControls extends ControlsBase {
+ *   protected setupListeners() {
+ *     // Setup specific input listeners
+ *   }
+ *
+ *   protected cleanup() {
+ *     // Cleanup specific resources
+ *   }
+ *
+ *   protected preStep() {
+ *     // Process inputs each frame
+ *   }
+ * }
+ * ```
+ */
+export declare abstract class ControlsBase {
+    protected boundKeys: {
+        [keyName: string]: BoundKey;
+    };
+    protected stop: boolean;
+    protected _controlsOptions: Controls;
+    protected interval: any;
+    protected serverFps: number;
+    /**
+     * Setup input listeners specific to this control implementation
+     * Must be implemented by subclasses
+     */
+    protected abstract setupListeners(): void;
+    /**
+     * Cleanup resources specific to this control implementation
+     * Must be implemented by subclasses
+     */
+    protected abstract cleanup(): void;
+    /**
+     * Process inputs each step/frame
+     * Must be implemented by subclasses
+     */
+    protected abstract preStep(): void;
+    /**
+     * Start the control processing loop
+     * Initializes listeners and starts the interval
+     */
+    start(): void;
+    /**
+     * Stop the control processing and cleanup resources
+     */
+    destroy(): void;
+    /**
+     * Bind a key/input to a control action
+     *
+     * @param keys - Single key or array of keys to bind
+     * @param actionName - Name of the control action
+     * @param options - Control options (repeat, keyDown, keyUp, etc.)
+     * @param parameters - Optional parameters to pass to the control callbacks
+     */
+    protected bindKey(keys: string | string[], actionName: string, options: ControlOptions, parameters?: object): void;
+    /**
+     * Apply an input action for a bound key
+     * Can be overridden by subclasses for custom behavior
+     *
+     * @param keyName - Name of the key/input to process
+     */
+    protected applyInput(keyName: string): void;
+    /**
+     * Get a control by input name
+     *
+     * @param inputName - Name of the input/key
+     * @returns BoundKey if found, undefined otherwise
+     * @example
+     * ```ts
+     * const control = controls.getControl('up');
+     * if (control) {
+     *   console.log(control.actionName); // 'up'
+     * }
+     * ```
+     */
+    getControl(inputName: string): BoundKey | undefined;
+    /**
+     * Get all bound controls
+     *
+     * @returns Object mapping input names to BoundKey objects
+     * @example
+     * ```ts
+     * const allControls = controls.getControls();
+     * console.log(Object.keys(allControls)); // ['up', 'down', 'left', 'right', ...]
+     * ```
+     */
+    getControls(): {
+        [key: string]: BoundKey;
+    };
+    /**
+     * Apply a control action programmatically
+     *
+     * Must be implemented by subclasses to provide input-specific behavior
+     *
+     * @param controlName - Name or identifier of the control
+     * @param isDown - Whether the control is pressed down (true) or released (false)
+     * @returns Promise that resolves when the control action is complete
+     * @example
+     * ```ts
+     * // Press a control
+     * await controls.applyControl('action', true);
+     *
+     * // Release a control
+     * await controls.applyControl('action', false);
+     *
+     * // Press and release (default)
+     * await controls.applyControl('action');
+     * ```
+     */
+    abstract applyControl(controlName: string | number, isDown?: boolean): Promise<void>;
+    /**
+     * Stop listening to inputs
+     * Input events will be ignored until listenInputs() is called
+     *
+     * @example
+     * ```ts
+     * controls.stopInputs();
+     * // ... later
+     * controls.listenInputs();
+     * ```
+     */
+    stopInputs(): void;
+    /**
+     * Resume listening to inputs after stopInputs() was called
+     *
+     * @example
+     * ```ts
+     * controls.stopInputs();
+     * // ... later
+     * controls.listenInputs();
+     * ```
+     */
+    listenInputs(): void;
+    /**
+     * Configure controls with input mappings
+     *
+     * This method sets up the binding between input keys/buttons and control actions.
+     * It clears existing bindings and creates new ones based on the provided configuration.
+     *
+     * @param inputs - Control configuration object
+     * @example
+     * ```ts
+     * controls.setInputs({
+     *   up: {
+     *     repeat: true,
+     *     bind: 'up',
+     *     keyDown() {
+     *       console.log('Up pressed');
+     *     }
+     *   },
+     *   action: {
+     *     bind: ['space', 'enter'],
+     *     keyDown() {
+     *       console.log('Action triggered');
+     *     }
+     *   }
+     * });
+     * ```
+     */
+    setInputs(inputs: Controls): void;
+    /**
+     * Get the current controls configuration
+     *
+     * @returns The controls options object
+     */
+    get options(): Controls;
+}
+//# sourceMappingURL=ControlsBase.d.ts.map

package/dist/directives/ControlsBase.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ControlsBase.d.ts","sourceRoot":"","sources":["../../src/directives/ControlsBase.ts"],"names":[],"mappings":"AAEA,MAAM,WAAW,cAAc;IAC3B,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,IAAI,EAAE,MAAM,GAAG,MAAM,EAAE,CAAC;IACxB,KAAK,CAAC,EAAE,QAAQ,CAAC;IACjB,OAAO,CAAC,EAAE,QAAQ,CAAC;IACnB,KAAK,CAAC,EAAE,MAAM,GAAG;QACb,QAAQ,EAAE,MAAM,CAAC;QACjB,aAAa,CAAC,EAAE,CAAC,MAAM,CAAC,EAAE,CAAC;KAC9B,CAAC;CACL;AAED,MAAM,WAAW,QAAQ;IACrB,CAAC,WAAW,EAAE,MAAM,GAAG,cAAc,CAAC;CACzC;AAED,MAAM,MAAM,QAAQ,GAAG;IAAE,UAAU,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,cAAc,CAAC;IAAC,UAAU,CAAC,EAAE,GAAG,CAAA;CAAE,CAAC;AAEzF;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,8BAAsB,YAAY;IAC9B,SAAS,CAAC,SAAS,EAAE;QACjB,CAAC,OAAO,EAAE,MAAM,GAAG,QAAQ,CAAA;KAC9B,CAAK;IACN,SAAS,CAAC,IAAI,EAAE,OAAO,CAAQ;IAC/B,SAAS,CAAC,gBAAgB,EAAE,QAAQ,CAAK;IACzC,SAAS,CAAC,QAAQ,EAAE,GAAG,CAAA;IACvB,SAAS,CAAC,SAAS,EAAE,MAAM,CAAK;IAEhC;;;OAGG;IACH,SAAS,CAAC,QAAQ,CAAC,cAAc,IAAI,IAAI;IAEzC;;;OAGG;IACH,SAAS,CAAC,QAAQ,CAAC,OAAO,IAAI,IAAI;IAElC;;;OAGG;IACH,SAAS,CAAC,QAAQ,CAAC,OAAO,IAAI,IAAI;IAElC;;;OAGG;IACH,KAAK;IAOL;;OAEG;IACH,OAAO;IAOP;;;;;;;OAOG;IACH,SAAS,CAAC,OAAO,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,EAAE,EAAE,UAAU,EAAE,MAAM,EAAE,OAAO,EAAE,cAAc,EAAE,UAAU,CAAC,EAAE,MAAM;IAU3G;;;;;OAKG;IACH,SAAS,CAAC,UAAU,CAAC,OAAO,EAAE,MAAM;IAepC;;;;;;;;;;;;OAYG;IACH,UAAU,CAAC,SAAS,EAAE,MAAM,GAAG,QAAQ,GAAG,SAAS;IAInD;;;;;;;;;OASG;IACH,WAAW,IAAI;QAAE,CAAC,GAAG,EAAE,MAAM,GAAG,QAAQ,CAAA;KAAE;IAI1C;;;;;;;;;;;;;;;;;;;OAmBG;IACH,QAAQ,CAAC,YAAY,CAAC,WAAW,EAAE,MAAM,GAAG,MAAM,EAAE,MAAM,CAAC,EAAE,OAAO,GAAG,OAAO,CAAC,IAAI,CAAC;IAEpF;;;;;;;;;;OAUG;IACH,UAAU;IAIV;;;;;;;;;OASG;IACH,YAAY;IAIZ;;;;;;;;;;;;;;;;;;;;;;;;;OAyBG;IACH,SAAS,CAAC,MAAM,EAAE,QAAQ;IAiB1B;;;;OAIG;IACH,IAAI,OAAO,IAAI,QAAQ,CAEtB;CACJ"}

package/dist/directives/Drag.d.ts

@@ -0,0 +1,70 @@
+import { Container, FederatedPointerEvent } from 'pixi.js';
+import { Directive } from '../engine/directive';
+import { Element } from '../engine/reactive';
+import { SignalOrPrimitive } from '../components/types';
+
+export type DragProps = {
+    move?: (event: FederatedPointerEvent) => void;
+    start?: () => void;
+    end?: () => void;
+    snap?: SignalOrPrimitive<number>;
+    direction?: SignalOrPrimitive<'x' | 'y' | 'all'>;
+    keyToPress?: SignalOrPrimitive<string[]>;
+    viewport?: {
+        edgeThreshold?: SignalOrPrimitive<number>;
+        maxSpeed?: SignalOrPrimitive<number>;
+    };
+};
+export declare class Drop extends Directive {
+    private elementRef;
+    onInit(element: Element<Container>): void;
+    onMount(element: Element<Container>): void;
+    onUpdate(): void;
+    onDestroy(): void;
+}
+export declare class Drag extends Directive {
+    private elementRef;
+    private stageRef;
+    private offsetInParent;
+    private isDragging;
+    private viewport;
+    private animationFrameId;
+    private lastPointerPosition;
+    private pressedKeys;
+    private pointerIsDown;
+    private onDragMoveHandler;
+    private onDragEndHandler;
+    private onDragStartHandler;
+    private onKeyDownHandler;
+    private onKeyUpHandler;
+    private subscriptions;
+    onInit(element: Element<Container>): void;
+    onMount(element: Element<Container>): void;
+    get dragProps(): any;
+    get axis(): {
+        x: boolean;
+        y: boolean;
+    };
+    /**
+     * Updates element position when dragging and starts continuous viewport movement
+     * @param event The pointer event that triggered the drag move
+     */
+    private onDragMove;
+    /**
+     * Moves the viewport if the dragged element is near screen edges
+     * @param globalPosition The global pointer position
+     */
+    private updateViewportPosition;
+    /**
+     * Handles drag end event and stops viewport movement
+     */
+    private onDragEnd;
+    onKeyDown(event: KeyboardEvent): void;
+    onKeyUp(event: KeyboardEvent): void;
+    private areRequiredKeysPressed;
+    private onPointerDown;
+    private startDrag;
+    onUpdate(props: any): void;
+    onDestroy(): void;
+}
+//# sourceMappingURL=Drag.d.ts.map

package/dist/directives/Drag.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Drag.d.ts","sourceRoot":"","sources":["../../src/directives/Drag.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,SAAS,EAAoB,qBAAqB,EAAE,MAAM,SAAS,CAAC;AAC7E,OAAO,EAAE,SAAS,EAAqB,MAAM,qBAAqB,CAAC;AACnE,OAAO,EAAE,OAAO,EAAE,MAAM,oBAAoB,CAAC;AAK7C,OAAO,EAAE,iBAAiB,EAAE,MAAM,qBAAqB,CAAC;AAExD,MAAM,MAAM,SAAS,GAAG;IACpB,IAAI,CAAC,EAAE,CAAC,KAAK,EAAE,qBAAqB,KAAK,IAAI,CAAC;IAC9C,KAAK,CAAC,EAAE,MAAM,IAAI,CAAC;IACnB,GAAG,CAAC,EAAE,MAAM,IAAI,CAAC;IACjB,IAAI,CAAC,EAAE,iBAAiB,CAAC,MAAM,CAAC,CAAC;IACjC,SAAS,CAAC,EAAE,iBAAiB,CAAC,GAAG,GAAG,GAAG,GAAG,KAAK,CAAC,CAAC;IACjD,UAAU,CAAC,EAAE,iBAAiB,CAAC,MAAM,EAAE,CAAC,CAAC;IACzC,QAAQ,CAAC,EAAE;QACP,aAAa,CAAC,EAAE,iBAAiB,CAAC,MAAM,CAAC,CAAC;QAC1C,QAAQ,CAAC,EAAE,iBAAiB,CAAC,MAAM,CAAC,CAAC;KACxC,CAAC;CACL,CAAA;AAED,qBAAa,IAAK,SAAQ,SAAS;IAC/B,OAAO,CAAC,UAAU,CAAmC;IAErD,MAAM,CAAC,OAAO,EAAE,OAAO,CAAC,SAAS,CAAC;IAIlC,OAAO,CAAC,OAAO,EAAE,OAAO,CAAC,SAAS,CAAC;IAInC,QAAQ;IAER,SAAS;CAGZ;AAED,qBAAa,IAAK,SAAQ,SAAS;IAC/B,OAAO,CAAC,UAAU,CAAmC;IACrD,OAAO,CAAC,QAAQ,CAA0B;IAC1C,OAAO,CAAC,cAAc,CAAe;IACrC,OAAO,CAAC,UAAU,CAAS;IAC3B,OAAO,CAAC,QAAQ,CAAoB;IACpC,OAAO,CAAC,gBAAgB,CAAuB;IAC/C,OAAO,CAAC,mBAAmB,CAAsB;IACjD,OAAO,CAAC,WAAW,CAA0B;IAC7C,OAAO,CAAC,aAAa,CAAS;IAE9B,OAAO,CAAC,iBAAiB,CAAoD;IAC7E,OAAO,CAAC,gBAAgB,CAAwB;IAChD,OAAO,CAAC,kBAAkB,CAAoD;IAC9E,OAAO,CAAC,gBAAgB,CAA4C;IACpE,OAAO,CAAC,cAAc,CAA4C;IAElE,OAAO,CAAC,aAAa,CAAsB;IAE3C,MAAM,CAAC,OAAO,EAAE,OAAO,CAAC,SAAS,CAAC;IASlC,OAAO,CAAC,OAAO,EAAE,OAAO,CAAC,SAAS,CAAC;IA6CnC,IAAI,SAAS,QAaZ;IAED,IAAI,IAAI;;;MAaP;IAED;;;OAGG;IACH,OAAO,CAAC,UAAU;IA2ClB;;;OAGG;IACH,OAAO,CAAC,sBAAsB;IA4D9B;;OAEG;IACH,OAAO,CAAC,SAAS;IAejB,SAAS,CAAC,KAAK,EAAE,aAAa;IAS9B,OAAO,CAAC,KAAK,EAAE,aAAa;IAQ5B,OAAO,CAAC,sBAAsB;IAqC9B,OAAO,CAAC,aAAa;IAqBrB,OAAO,CAAC,SAAS;IASjB,QAAQ,CAAC,KAAK,KAAA;IAOd,SAAS;CAqBZ"}

package/dist/directives/Flash.d.ts

@@ -0,0 +1,117 @@
+import { Container } from 'pixi.js';
+import { Directive } from '../engine/directive';
+import { Element } from '../engine/reactive';
+import { Trigger } from '../engine/trigger';
+import { SignalOrPrimitive } from '../components/types';
+
+export type FlashType = 'alpha' | 'tint' | 'both';
+export type FlashProps = {
+    /**
+     * Trigger that activates the flash animation
+     * When the trigger is activated, the flash animation will start
+     */
+    trigger?: Trigger<any>;
+    /**
+     * Type of flash effect: 'alpha' (opacity), 'tint' (color), or 'both'
+     * @default 'alpha'
+     */
+    type?: SignalOrPrimitive<FlashType>;
+    /**
+     * Duration of the flash animation in milliseconds
+     * @default 300
+     */
+    duration?: SignalOrPrimitive<number>;
+    /**
+     * Number of flash cycles (flash on/off)
+     * @default 1
+     */
+    cycles?: SignalOrPrimitive<number>;
+    /**
+     * Alpha value when flashing (0 to 1)
+     * Only used when type is 'alpha' or 'both'
+     * @default 0.3
+     */
+    alpha?: SignalOrPrimitive<number>;
+    /**
+     * Tint color when flashing (hex color value)
+     * Only used when type is 'tint' or 'both'
+     * @default 0xffffff (white)
+     */
+    tint?: SignalOrPrimitive<number>;
+    /**
+     * Original alpha value to restore after flash
+     * If not provided, uses the current alpha value
+     */
+    originalAlpha?: number;
+    /**
+     * Original tint value to restore after flash
+     * If not provided, uses the current tint value
+     */
+    originalTint?: number;
+    /**
+     * Callback function called when flash starts
+     */
+    onStart?: () => void;
+    /**
+     * Callback function called when flash completes
+     */
+    onComplete?: () => void;
+};
+/**
+ * Flash directive that animates a display object's alpha and/or tint when a trigger is activated.
+ * Creates a flash effect by rapidly changing opacity or color.
+ *
+ * @example
+ * ```typescript
+ * // Basic usage with trigger
+ * const flashTrigger = trigger();
+ *
+ * onMount(element) {
+ *   // Element will flash when trigger is activated
+ *   element.props.flash = { trigger: flashTrigger };
+ * }
+ *
+ * // Trigger the flash
+ * flashTrigger.start();
+ * ```
+ */
+export declare class Flash extends Directive {
+    private elementRef;
+    private progressSignal;
+    private flashSubscription;
+    private alphaEffect;
+    private tintEffect;
+    private originalAlpha;
+    private originalTint;
+    private currentFlashConfig;
+    /**
+     * Initializes the flash directive
+     * @param element - The element to attach the flash effect to
+     */
+    onInit(element: Element<Container>): void;
+    /**
+     * Mounts the flash directive and sets up trigger listener
+     * @param element - The element being mounted
+     */
+    onMount(element: Element<Container>): void;
+    /**
+     * Gets the flash props with default values
+     * @returns FlashProps with defaults applied
+     */
+    get flashProps(): FlashProps;
+    /**
+     * Performs the flash animation using animatedSignal
+     * @param data - Optional data passed from the trigger that can override default options
+     */
+    private performFlash;
+    /**
+     * Updates the flash directive when props change
+     * @param props - Updated props
+     */
+    onUpdate(props: any): void;
+    /**
+     * Cleans up the flash directive
+     */
+    onDestroy(): void;
+}
+//# sourceMappingURL=Flash.d.ts.map

package/dist/directives/Flash.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Flash.d.ts","sourceRoot":"","sources":["../../src/directives/Flash.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,SAAS,CAAC;AACpC,OAAO,EAAE,SAAS,EAAqB,MAAM,qBAAqB,CAAC;AACnE,OAAO,EAAE,OAAO,EAAE,MAAM,oBAAoB,CAAC;AAE7C,OAAO,EAAiB,OAAO,EAAE,MAAM,mBAAmB,CAAC;AAE3D,OAAO,EAAE,iBAAiB,EAAE,MAAM,qBAAqB,CAAC;AAIxD,MAAM,MAAM,SAAS,GAAG,OAAO,GAAG,MAAM,GAAG,MAAM,CAAC;AAElD,MAAM,MAAM,UAAU,GAAG;IACrB;;;OAGG;IACH,OAAO,CAAC,EAAE,OAAO,CAAC,GAAG,CAAC,CAAC;IACvB;;;OAGG;IACH,IAAI,CAAC,EAAE,iBAAiB,CAAC,SAAS,CAAC,CAAC;IACpC;;;OAGG;IACH,QAAQ,CAAC,EAAE,iBAAiB,CAAC,MAAM,CAAC,CAAC;IACrC;;;OAGG;IACH,MAAM,CAAC,EAAE,iBAAiB,CAAC,MAAM,CAAC,CAAC;IACnC;;;;OAIG;IACH,KAAK,CAAC,EAAE,iBAAiB,CAAC,MAAM,CAAC,CAAC;IAClC;;;;OAIG;IACH,IAAI,CAAC,EAAE,iBAAiB,CAAC,MAAM,CAAC,CAAC;IACjC;;;OAGG;IACH,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB;;;OAGG;IACH,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB;;OAEG;IACH,OAAO,CAAC,EAAE,MAAM,IAAI,CAAC;IACrB;;OAEG;IACH,UAAU,CAAC,EAAE,MAAM,IAAI,CAAC;CAC3B,CAAA;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,qBAAa,KAAM,SAAQ,SAAS;IAChC,OAAO,CAAC,UAAU,CAAmC;IACrD,OAAO,CAAC,cAAc,CAAuC;IAC7D,OAAO,CAAC,iBAAiB,CAAa;IACtC,OAAO,CAAC,WAAW,CAA6B;IAChD,OAAO,CAAC,UAAU,CAA6B;IAC/C,OAAO,CAAC,aAAa,CAAa;IAClC,OAAO,CAAC,YAAY,CAAoB;IACxC,OAAO,CAAC,kBAAkB,CAMV;IAEhB;;;OAGG;IACH,MAAM,CAAC,OAAO,EAAE,OAAO,CAAC,SAAS,CAAC;IAIlC;;;OAGG;IACH,OAAO,CAAC,OAAO,EAAE,OAAO,CAAC,SAAS,CAAC;IAgCnC;;;OAGG;IACH,IAAI,UAAU,IAAI,UAAU,CAS3B;IAED;;;OAGG;YACW,YAAY;IAsL1B;;;OAGG;IACH,QAAQ,CAAC,KAAK,EAAE,GAAG;IAUnB;;OAEG;IACH,SAAS;CA4CZ"}

package/dist/directives/GamepadControls.d.ts

@@ -0,0 +1,225 @@
+import { ControlsBase, Controls } from './ControlsBase';
+import { WritableSignal } from '@signe/reactive';
+
+/**
+ * Gamepad configuration interface
+ *
+ * @example
+ * ```ts
+ * const gamepadConfig: GamepadConfig = {
+ *   enabled: true,
+ *   buttonMapping: {
+ *     'button_0': 'action',
+ *     'button_1': 'back'
+ *   },
+ *   axisMapping: {
+ *     'top': 'up',
+ *     'bottom': 'down',
+ *     'left': 'left',
+ *     'right': 'right'
+ *   },
+ *   moveInterval: 400,
+ *   onConnect: () => console.log('Gamepad connected!'),
+ *   onDisconnect: () => console.log('Gamepad disconnected!')
+ * };
+ * ```
+ */
+export interface GamepadConfig {
+    /** Whether gamepad is enabled (default: true) */
+    enabled?: boolean;
+    /** Mapping of gamepad button names to control names */
+    buttonMapping?: {
+        [buttonName: string]: string;
+    };
+    /** Mapping of axis directions to control directions */
+    axisMapping?: {
+        [axisDirection: string]: string;
+    };
+    /** Threshold for axis movement detection (default: 0.5) */
+    axisThreshold?: number;
+    /** Interval in milliseconds for repeating movement actions (default: 400) */
+    moveInterval?: number;
+    /** Callback called when a gamepad is connected */
+    onConnect?: () => void;
+    /** Callback called when a gamepad is disconnected */
+    onDisconnect?: () => void;
+    /** Signal that tracks gamepad connection status (optional) */
+    gamepadConnected?: WritableSignal<boolean>;
+}
+/**
+ * Gamepad input controls implementation
+ *
+ * Handles gamepad input events using joypad.js library and maps them to control actions.
+ * Supports button presses and analog stick movement with configurable mappings.
+ *
+ * The gamepad controls are automatically activated when joypad.js is available and enabled.
+ *
+ * @example
+ * ```ts
+ * const gamepadControls = new GamepadControls();
+ * gamepadControls.setInputs({
+ *   up: {
+ *     repeat: true,
+ *     bind: 'up',
+ *     keyDown() {
+ *       console.log('Up pressed');
+ *     }
+ *   }
+ * });
+ * gamepadControls.updateGamepadConfig({
+ *   enabled: true,
+ *   buttonMapping: {
+ *     'button_0': 'action'
+ *   }
+ * });
+ * gamepadControls.start();
+ * ```
+ */
+export declare class GamepadControls extends ControlsBase {
+    private gamepadEnabled;
+    private gamepadConfig;
+    private gamepadMoving;
+    private gamepadDirections;
+    private gamepadAxisDate;
+    private gamepadMoveInterval;
+    private joypad;
+    private connectCallbacks;
+    private disconnectCallbacks;
+    private currentPower;
+    /**
+     * Setup gamepad event listeners
+     * Initializes joypad.js if available
+     */
+    protected setupListeners(): void;
+    /**
+     * Cleanup gamepad event listeners and intervals
+     */
+    protected cleanup(): void;
+    /**
+     * Initialize joypad.js library if available
+     */
+    private initGamepad;
+    /**
+     * Handle gamepad connection event
+     */
+    private handleGamepadConnect;
+    /**
+     * Handle gamepad disconnection event
+     */
+    private handleGamepadDisconnect;
+    /**
+     * Handle gamepad button press event
+     *
+     * @param e - Button press event from joypad.js
+     */
+    private handleGamepadButtonPress;
+    /**
+     * Handle gamepad axis movement event
+     *
+     * @param e - Axis move event from joypad.js
+     */
+    private handleGamepadAxisMove;
+    /**
+     * Process continuous gamepad movement
+     * Called at intervals to repeat movement actions while axes are active
+     */
+    private processGamepadMovement;
+    /**
+     * Process gamepad inputs each step
+     * Handles timeout for stopping movements after axis inactivity
+     */
+    protected preStep(): void;
+    /**
+     * Update gamepad configuration
+     * Merges provided config with defaults
+     * Automatically registers callbacks from config
+     *
+     * @param config - Partial gamepad configuration
+     */
+    updateGamepadConfig(config: Partial<GamepadConfig>): void;
+    /**
+     * Extract gamepad config from controls configuration and update
+     * Note: Callbacks are stored but not automatically registered, they should be registered in mount()
+     *
+     * @param inputs - Controls configuration that may contain a 'gamepad' property
+     */
+    extractGamepadConfig(inputs: Controls & {
+        gamepad?: GamepadConfig;
+    }): void;
+    /**
+     * Get the current gamepad configuration
+     *
+     * @returns The gamepad configuration object
+     */
+    getGamepadConfig(): GamepadConfig;
+    /**
+     * Apply a control action programmatically
+     * Uses the bound controls to trigger actions
+     *
+     * @param controlName - Name of the control
+     * @param isDown - Whether the control is pressed (true) or released (false)
+     * @param payload - Optional payload to pass to keyDown/keyUp callbacks (e.g., { power: 0.8 })
+     * @returns Promise that resolves when the action is complete
+     */
+    applyControl(controlName: string | number, isDown?: boolean, payload?: any): Promise<void>;
+    /**
+     * Override setInputs to extract gamepad config
+     */
+    setInputs(inputs: Controls & {
+        gamepad?: GamepadConfig;
+    }): void;
+    /**
+     * Register a callback to be called when a gamepad is connected
+     *
+     * @param callback - Function to call when gamepad connects
+     * @example
+     * ```ts
+     * gamepadControls.onConnect(() => {
+     *   console.log('Gamepad connected!');
+     * });
+     * ```
+     */
+    onConnect(callback: () => void): void;
+    /**
+     * Register a callback to be called when a gamepad is disconnected
+     *
+     * @param callback - Function to call when gamepad disconnects
+     * @example
+     * ```ts
+     * gamepadControls.onDisconnect(() => {
+     *   console.log('Gamepad disconnected!');
+     * });
+     * ```
+     */
+    onDisconnect(callback: () => void): void;
+    /**
+     * Remove a connect callback
+     *
+     * @param callback - Callback to remove
+     */
+    offConnect(callback: () => void): void;
+    /**
+     * Remove a disconnect callback
+     *
+     * @param callback - Callback to remove
+     */
+    offDisconnect(callback: () => void): void;
+    /**
+     * Check if gamepad is currently connected
+     *
+     * @returns true if gamepad is connected, false otherwise
+     */
+    isConnected(): boolean;
+    /**
+     * Reinitialize gamepad listeners
+     * Useful if joypad.js becomes available after initialization
+     *
+     * @example
+     * ```ts
+     * // If joypad.js loads later
+     * gamepadControls.reinit();
+     * ```
+     */
+    reinit(): void;
+}
+//# sourceMappingURL=GamepadControls.d.ts.map

package/dist/directives/GamepadControls.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"GamepadControls.d.ts","sourceRoot":"","sources":["../../src/directives/GamepadControls.ts"],"names":[],"mappings":"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"}