@caperjs/core 0.1.0

package/lib/plugins/GSAPPlugin.d.ts

@@ -0,0 +1,634 @@
+import { gsap } from 'gsap';
+import { IApplication } from '../core';
+import { Signal } from '../signals';
+import { Eases } from '../utils';
+import { Plugin, IPlugin } from './Plugin';
+/**
+ * Configuration options for the GSAP plugin.
+ */
+export interface GSAPPluginOptions {
+    /** Custom easing functions to register with GSAP */
+    eases: Eases;
+}
+/**
+ * Interface for the GSAPPlugin, defining its public API for high-performance animations.
+ * Provides comprehensive GSAP integration with custom animation context management.
+ */
+export interface IGSAPPlugin extends IPlugin {
+    /**
+     * Array of all registered custom ease names.
+     * @readonly
+     */
+    readonly easeNames: string[];
+    /**
+     * Object containing all registered custom eases, where keys are ease names and values are GSAP ease functions.
+     * @readonly
+     */
+    readonly eases: Eases;
+    /**
+     * The GSAP instance for creating animations.
+     * @readonly
+     */
+    readonly anim: typeof gsap;
+    /**
+     * Adds one or more GSAP tweens or timelines to a specified animation context.
+     * Animation contexts are custom collections (Set) of tweens/timelines managed by this plugin,
+     * NOT `gsap.Context` instances. If no contextId is provided, animations are added to the global context.
+     *
+     * @param animation - A single GSAP tween/timeline or an array of them
+     * @param contextId - Optional ID of the custom animation context. Defaults to the global context
+     * @returns The animation(s) that were added
+     *
+     * @example
+     * ```typescript
+     * // Add single animation to specific context
+     * const tween = gsap.to(mySprite, { x: 100, duration: 1 });
+     * gsapPlugin.addAnimation(tween, 'gameplayAnimations');
+     *
+     * // Add multiple animations to global context
+     * const tweens = [
+     *   gsap.to(sprite1, { alpha: 0.5, duration: 1 }),
+     *   gsap.to(sprite2, { rotation: Math.PI, duration: 2 })
+     * ];
+     * gsapPlugin.addAnimation(tweens);
+     * ```
+     */
+    addAnimation(animation: gsap.core.Tween | gsap.core.Timeline | (gsap.core.Tween | gsap.core.Timeline)[], contextId?: string): gsap.core.Tween | gsap.core.Timeline | (gsap.core.Tween | gsap.core.Timeline)[];
+    /**
+     * Registers a custom ease function with GSAP.
+     *
+     * @param name - The name of the custom ease
+     * @param ease - The GSAP ease function
+     * @returns An object containing the registered ease
+     *
+     * @example
+     * ```typescript
+     * // Register a custom bounce ease
+     * gsapPlugin.registerCustomEase('myBounce', (progress) => {
+     *   return progress < 0.5
+     *     ? 2 * progress * progress
+     *     : 1 - Math.pow(-2 * progress + 2, 3) / 2;
+     * });
+     *
+     * // Use the custom ease in animations
+     * gsap.to(mySprite, { x: 200, duration: 1, ease: 'myBounce' });
+     * ```
+     */
+    registerCustomEase(name: string, ease: gsap.EaseFunction): Record<string, gsap.EaseFunction>;
+    /**
+     * Registers multiple custom ease functions with GSAP in batch.
+     *
+     * @param eases - An object where keys are ease names and values are GSAP ease functions
+     * @returns The complete map of registered eases
+     *
+     * @example
+     * ```typescript
+     * gsapPlugin.registerEases({
+     *   'softBounce': (t) => t * t * (3 - 2 * t),
+     *   'sharpEase': (t) => t * t * t,
+     *   'customBack': (t) => t * t * (2.7 * t - 1.7)
+     * });
+     * ```
+     */
+    registerEases(eases: Eases): Eases;
+    /**
+     * Retrieves a custom animation context (a Set of tweens/timelines) by its ID.
+     * This is NOT a `gsap.Context` instance but rather a custom collection for grouping animations.
+     *
+     * @param contextId - The ID of the animation context
+     * @returns The animation context (a Set of tweens/timelines) or null if not found
+     *
+     * @example
+     * ```typescript
+     * const menuAnimations = gsapPlugin.getContext('menuAnimations');
+     * if (menuAnimations) {
+     *   console.log(`Menu has ${menuAnimations.size} active animations`);
+     * }
+     * ```
+     */
+    getContext(contextId: string): Set<gsap.core.Tween | gsap.core.Timeline> | null;
+    /**
+     * Plays all animations in a specified custom animation context, or all animations in all contexts.
+     *
+     * @param contextId - Optional ID of the animation context. If omitted, plays all animations
+     *
+     * @example
+     * ```typescript
+     * // Play all animations in a specific context
+     * gsapPlugin.playAll('gameplayAnimations');
+     *
+     * // Play all animations in all contexts
+     * gsapPlugin.playAll();
+     * ```
+     */
+    playAll(contextId?: string): void;
+    /**
+     * Pauses all animations in a specified custom animation context, or all animations in all contexts.
+     *
+     * @param contextId - Optional ID of the animation context. If omitted, pauses all animations
+     *
+     * @example
+     * ```typescript
+     * // Pause game animations when menu opens
+     * gsapPlugin.pauseAll('gameplayAnimations');
+     *
+     * // Pause everything when app loses focus
+     * gsapPlugin.pauseAll();
+     * ```
+     */
+    pauseAll(contextId?: string): void;
+    /**
+     * Kills (stops and removes) all animations in a specified custom animation context, or all animations.
+     * If all contexts are killed, the plugin's global animation collection is recreated.
+     *
+     * @param contextId - Optional ID of the animation context. If omitted, kills all animations
+     *
+     * @example
+     * ```typescript
+     * // Kill specific context when transitioning scenes
+     * gsapPlugin.killAll('oldSceneAnimations');
+     *
+     * // Emergency stop all animations
+     * gsapPlugin.killAll();
+     * ```
+     */
+    killAll(contextId?: string): void;
+    /**
+     * Reverts all animations in a specified custom animation context to their initial state.
+     *
+     * @param contextId - Optional ID of the animation context. If omitted, reverts all animations
+     *
+     * @example
+     * ```typescript
+     * // Reset UI animations to initial state
+     * gsapPlugin.revertAll('uiAnimations');
+     *
+     * // Reset everything for game restart
+     * gsapPlugin.revertAll();
+     * ```
+     */
+    revertAll(contextId?: string): void;
+    /**
+     * Clears (removes) a specific custom animation context and its tracked animations.
+     * If this results in no active contexts, the global collection is recreated if all contexts are cleared.
+     *
+     * @param contextId - The ID of the animation context to clear
+     *
+     * @example
+     * ```typescript
+     * // Clean up completed level animations
+     * gsapPlugin.clear('level1Animations');
+     * ```
+     */
+    clear(contextId: string): void;
+    /**
+     * Clears all custom animation contexts and recreates the plugin's global animation collection.
+     *
+     * @example
+     * ```typescript
+     * // Complete reset when restarting the game
+     * gsapPlugin.clearAll();
+     * ```
+     */
+    clearAll(): void;
+    /**
+     * Kills all animations within the global animation collection managed by this plugin.
+     *
+     * @example
+     * ```typescript
+     * // Stop only global animations, keep context-specific ones
+     * gsapPlugin.killGlobal();
+     * ```
+     */
+    killGlobal(): void;
+    /**
+     * Reverts all animations within the global animation collection to their initial state.
+     *
+     * @example
+     * ```typescript
+     * // Reset global animations without affecting contexts
+     * gsapPlugin.revertGlobal();
+     * ```
+     */
+    revertGlobal(): void;
+    /**
+     * Clears all animations from the global animation collection managed by this plugin.
+     *
+     * @example
+     * ```typescript
+     * // Clear global animations for cleanup
+     * gsapPlugin.clearGlobal();
+     * ```
+     */
+    clearGlobal(): void;
+    onPlayAll: Signal<(contextId: string) => void>;
+    onPauseAll: Signal<(contextId: string) => void>;
+    onKillAll: Signal<(contextId: string) => void>;
+    onRevertAll: Signal<(contextId: string) => void>;
+    onClear: Signal<(detail: {
+        contextId: string;
+        kill: boolean;
+    }) => void>;
+    onClearAll: Signal<(kill: boolean) => void>;
+    onKillGlobal: Signal<() => void>;
+    onRevertGlobal: Signal<() => void>;
+    onClearGlobal: Signal<(kill: boolean) => void>;
+    onEaseRegistered: Signal<(detail: {
+        name: string;
+        ease: gsap.EaseFunction;
+    }) => void>;
+    onEasesRegistered: Signal<(eases: Eases) => void>;
+    onAnimationAddded: Signal<(detail: {
+        animation: gsap.core.Tween | gsap.core.Timeline;
+        contextId: string;
+    }) => void>;
+}
+/**
+ * Type alias for animation context collections.
+ * Represents a Set containing GSAP tweens and timelines for grouped animation management.
+ */
+export type AnimationContext = Set<gsap.core.Tween | gsap.core.Timeline>;
+/**
+ * High-performance GSAP animation plugin for PIXI.js applications.
+ *
+ * Integrates the GreenSock Animation Platform (GSAP) into the application framework,
+ * providing powerful and flexible animation capabilities with optimized PIXI.js integration.
+ * Features custom animation context management for grouped animation control, custom easing
+ * registration, and automatic PIXI.js property animation support.
+ *
+ * Key Features:
+ * - Full GSAP integration with PIXI.js optimization
+ * - Custom animation contexts for grouped control (pause/play/kill by category)
+ * - Custom easing function registration and management
+ * - Automatic PIXI filter integration (BlurFilter, ColorMatrixFilter)
+ * - Memory-efficient animation tracking and cleanup
+ * - Global and context-specific animation management
+ *
+ * **Important:** Animation "contexts" in this plugin are custom collections (Sets) for grouping
+ * animations and are NOT the same as `gsap.Context` objects provided by GSAP itself.
+ *
+ * @example
+ * ```typescript
+ * // Basic setup and usage
+ * const gsapPlugin = app.plugins.get<IGSAPPlugin>('GSAPPlugin');
+ *
+ * // Create optimized PIXI animations
+ * const sprite = new PIXI.Sprite(texture);
+ * gsapPlugin.anim.to(sprite, {
+ *   x: 100,
+ *   y: 50,
+ *   alpha: 0.8,
+ *   duration: 1,
+ *   ease: 'back.out(1.7)'
+ * });
+ *
+ * // Register custom eases for game feel
+ * gsapPlugin.registerCustomEase('gameJuice', (t) => {
+ *   return t < 0.5 ? 4 * t * t * t : 1 - Math.pow(-2 * t + 2, 3) / 2;
+ * });
+ *
+ * // Context-based animation management
+ * const menuTween = gsapPlugin.anim.to(menuButton, { scale: 1.1, duration: 0.3 });
+ * gsapPlugin.addAnimation(menuTween, 'menuAnimations');
+ *
+ * // Later: pause all menu animations when game starts
+ * gsapPlugin.pauseAll('menuAnimations');
+ *
+ * // Animate PIXI filters
+ * const blurFilter = new PIXI.BlurFilter();
+ * sprite.filters = [blurFilter];
+ * gsapPlugin.anim.to(blurFilter, { blur: 10, duration: 2 });
+ * ```
+ *
+ * @remarks
+ * - Automatically registers PixiPlugin for optimized PIXI.js property animations
+ * - Includes ColorMatrixFilter and BlurFilter integration for advanced effects
+ * - Uses efficient Set-based tracking for O(1) animation context operations
+ * - Provides both global and context-specific animation lifecycle management
+ * - Custom eases are automatically registered with GSAP and stored for reference
+ */
+export declare class GSAPPlugin extends Plugin implements IGSAPPlugin {
+    /** Internal identifier for the global animation context */
+    private static readonly GLOBAL_CONTEXT_ID;
+    /** Plugin identifier for framework registration */
+    readonly id = "GSAPPlugin";
+    onPlayAll: Signal<(contextId: string) => void>;
+    onPauseAll: Signal<(contextId: string) => void>;
+    onKillAll: Signal<(contextId: string) => void>;
+    onRevertAll: Signal<(contextId: string) => void>;
+    onClear: Signal<(detail: {
+        contextId: string;
+        kill: boolean;
+    }) => void>;
+    onClearAll: Signal<(kill: boolean) => void>;
+    onKillGlobal: Signal<() => void>;
+    onRevertGlobal: Signal<() => void>;
+    onClearGlobal: Signal<(kill: boolean) => void>;
+    onEaseRegistered: Signal<(detail: {
+        name: string;
+        ease: gsap.EaseFunction;
+    }) => void>;
+    onEasesRegistered: Signal<(eases: Eases) => void>;
+    onAnimationAddded: Signal<(detail: {
+        animation: gsap.core.Tween | gsap.core.Timeline;
+        contextId: string;
+    }) => void>;
+    /** Global animation context reference for quick access */
+    private _globalContext;
+    /** Map of all custom animation contexts by their string identifiers */
+    private _animationContexts;
+    /**
+     * Array of all registered custom ease names.
+     * @readonly
+     */
+    get easeNames(): string[];
+    /**
+     * Object containing all registered custom eases.
+     * @readonly
+     */
+    get eases(): Eases;
+    /**
+     * Initializes the GSAP plugin with PIXI.js integration and custom configurations.
+     * Sets up PixiPlugin, registers custom eases, and creates the global animation context.
+     *
+     * @param _ - Plugin options (currently unused, relies on app.config.gsap)
+     * @param app - The application instance providing configuration
+     *
+     * @example
+     * ```typescript
+     * // Plugin is automatically initialized by the framework
+     * // Configuration comes from app.config.gsap
+     * const config = {
+     *   gsap: {
+     *     eases: {
+     *       'customBounce': (t) => t * t * (3 - 2 * t),
+     *       'gameEase': (t) => Math.pow(t, 2.5)
+     *     }
+     *   }
+     * };
+     * ```
+     */
+    initialize(_: any, app: IApplication): Promise<void>;
+    /**
+     * Creates and initializes the global animation context.
+     * Sets up the default context for animations not assigned to specific contexts.
+     * @protected
+     */
+    protected createGlobalContext(): void;
+    /**
+     * Registers a single custom ease function with GSAP.
+     * The ease becomes available for use in all GSAP animations by name.
+     *
+     * @param name - Unique name identifier for the ease
+     * @param ease - GSAP-compatible easing function (takes progress 0-1, returns eased value)
+     * @returns Object containing the registered ease for chaining or reference
+     *
+     * @example
+     * ```typescript
+     * // Register a custom elastic ease
+     * gsapPlugin.registerCustomEase('elasticOut', (t) => {
+     *   const c4 = (2 * Math.PI) / 3;
+     *   return t === 0 ? 0 : t === 1 ? 1 :
+     *     Math.pow(2, -10 * t) * Math.sin((t * 10 - 0.75) * c4) + 1;
+     * });
+     *
+     * // Use in animations
+     * gsap.to(mySprite, { x: 100, duration: 1, ease: 'elasticOut' });
+     * ```
+     */
+    registerCustomEase(name: string, ease: gsap.EaseFunction): Record<string, gsap.EaseFunction>;
+    /**
+     * Registers multiple custom ease functions with GSAP in a single operation.
+     * Efficient batch registration for multiple custom eases.
+     *
+     * @param eases - Object mapping ease names to ease functions
+     * @returns The complete map of all registered eases
+     *
+     * @example
+     * ```typescript
+     * // Register a suite of game-specific eases
+     * gsapPlugin.registerEases({
+     *   'jumpEase': (t) => t * t * (3 - 2 * t),
+     *   'impactEase': (t) => 1 - Math.cos(t * Math.PI / 2),
+     *   'floatEase': (t) => Math.sin(t * Math.PI / 2),
+     *   'snapEase': (t) => t < 0.5 ? 2 * t * t : 1 - Math.pow(-2 * t + 2, 2) / 2
+     * });
+     * ```
+     */
+    registerEases(eases: Eases): Eases;
+    /**
+     * Gets the GSAP instance for creating animations.
+     * Provides access to the full GSAP API with PIXI.js optimizations enabled.
+     * @readonly
+     */
+    get anim(): typeof gsap;
+    /**
+     * Adds animation(s) to a specified context for grouped management.
+     * Creates the context if it doesn't exist. Defaults to global context if no contextId provided.
+     *
+     * @param animation - Single animation or array of animations to track
+     * @param contextId - Context identifier (defaults to global context)
+     * @returns The same animation(s) passed in for chaining
+     *
+     * @example
+     * ```typescript
+     * // Add to specific context for scene management
+     * const levelTweens = [
+     *   gsap.to(player, { x: 100, duration: 2 }),
+     *   gsap.to(enemy, { rotation: Math.PI, duration: 1.5 }),
+     *   gsap.to(powerup, { scale: 1.2, yoyo: true, repeat: -1, duration: 0.8 })
+     * ];
+     * gsapPlugin.addAnimation(levelTweens, 'level1Gameplay');
+     *
+     * // Add to global context (default)
+     * const bgTween = gsap.to(background, { alpha: 0.8, duration: 3 });
+     * gsapPlugin.addAnimation(bgTween);
+     * ```
+     */
+    addAnimation(animation: gsap.core.Tween | gsap.core.Timeline | (gsap.core.Tween | gsap.core.Timeline)[], contextId?: string): gsap.core.Tween | gsap.core.Timeline | (gsap.core.Tween | gsap.core.Timeline)[];
+    /**
+     * Retrieves a custom animation context by its identifier.
+     * Returns null if the context doesn't exist.
+     *
+     * @param contextId - The context identifier to look up
+     * @returns The animation context Set or null if not found
+     *
+     * @example
+     * ```typescript
+     * // Check if context exists and get info
+     * const gameplayContext = gsapPlugin.getContext('gameplayAnimations');
+     * if (gameplayContext) {
+     *   console.log(`Found ${gameplayContext.size} gameplay animations`);
+     *
+     *   // Iterate through animations if needed
+     *   gameplayContext.forEach(animation => {
+     *     console.log('Animation progress:', animation.progress());
+     *   });
+     * }
+     * ```
+     */
+    getContext(contextId: string): AnimationContext | null;
+    /**
+     * Plays all animations in the specified context or all contexts.
+     * Useful for resuming paused animations or ensuring all animations are active.
+     *
+     * @param contextId - Optional context identifier. If omitted, plays all animations in all contexts
+     *
+     * @example
+     * ```typescript
+     * // Resume specific context after pause
+     * gsapPlugin.playAll('menuAnimations');
+     *
+     * // Resume all animations (e.g., after app regains focus)
+     * gsapPlugin.playAll();
+     *
+     * // Conditional playback
+     * if (gameState === 'playing') {
+     *   gsapPlugin.playAll('gameplayAnimations');
+     * }
+     * ```
+     */
+    playAll(contextId?: string): void;
+    /**
+     * Pauses all animations in the specified context or all contexts.
+     * Animations retain their current progress and can be resumed with playAll().
+     *
+     * @param contextId - Optional context identifier. If omitted, pauses all animations in all contexts
+     *
+     * @example
+     * ```typescript
+     * // Pause game animations when menu opens
+     * gsapPlugin.pauseAll('gameplayAnimations');
+     *
+     * // Pause everything when app loses focus
+     * window.addEventListener('blur', () => {
+     *   gsapPlugin.pauseAll();
+     * });
+     *
+     * // Conditional pausing
+     * if (gameState === 'paused') {
+     *   gsapPlugin.pauseAll('gameplayAnimations');
+     * }
+     * ```
+     */
+    pauseAll(contextId?: string): void;
+    /**
+     * Kills (stops and removes) all animations in the specified context or all contexts.
+     * Killed animations cannot be resumed and are removed from tracking.
+     * If killing all contexts, the global context is automatically recreated.
+     *
+     * @param contextId - Optional context identifier. If omitted, kills all animations in all contexts
+     *
+     * @example
+     * ```typescript
+     * // Kill animations when transitioning scenes
+     * gsapPlugin.killAll('currentSceneAnimations');
+     *
+     * // Emergency stop all animations
+     * gsapPlugin.killAll();
+     *
+     * // Clean up specific context before recreation
+     * gsapPlugin.killAll('temporaryEffects');
+     * ```
+     */
+    killAll(contextId?: string): void;
+    /**
+     * Reverts all animations in the specified context or all contexts to their initial state.
+     * Animation targets return to their original property values before the animation started.
+     *
+     * @param contextId - Optional context identifier. If omitted, reverts all animations in all contexts
+     *
+     * @example
+     * ```typescript
+     * // Reset UI to initial state
+     * gsapPlugin.revertAll('uiAnimations');
+     *
+     * // Reset everything for game restart
+     * gsapPlugin.revertAll();
+     *
+     * // Reset temporary effects
+     * gsapPlugin.revertAll('screenEffects');
+     * ```
+     */
+    revertAll(contextId?: string): void;
+    /**
+     * Clears (removes) a specific animation context from tracking.
+     * Optionally kills the animations before clearing the context.
+     *
+     * @param contextId - The context identifier to clear
+     * @param kill - Whether to kill animations before clearing (default: false)
+     *
+     * @example
+     * ```typescript
+     * // Clear completed level context
+     * gsapPlugin.clear('level1Animations');
+     *
+     * // Clear and kill animations simultaneously
+     * gsapPlugin.clear('temporaryEffects', true);
+     * ```
+     */
+    clear(contextId: string, kill?: boolean): void;
+    /**
+     * Clears all animation contexts and recreates the global context.
+     * Optionally kills all animations before clearing contexts.
+     *
+     * @param kill - Whether to kill all animations before clearing (default: false)
+     *
+     * @example
+     * ```typescript
+     * // Complete reset for new game
+     * gsapPlugin.clearAll(true);
+     *
+     * // Clear tracking without killing animations
+     * gsapPlugin.clearAll(false);
+     * ```
+     */
+    clearAll(kill?: boolean): void;
+    /**
+     * Kills all animations within the global animation context only.
+     * This affects only animations added to the global context, not other custom contexts.
+     *
+     * @example
+     * ```typescript
+     * // Kill only global animations, preserve context-specific ones
+     * gsapPlugin.killGlobal();
+     *
+     * // Useful for clearing background animations while keeping UI animations
+     * gsapPlugin.killGlobal();
+     * gsapPlugin.playAll('uiAnimations'); // UI animations continue
+     * ```
+     */
+    killGlobal(): void;
+    /**
+     * Reverts all animations within the global animation context to their initial state.
+     * Only affects animations in the global context, not custom contexts.
+     *
+     * @example
+     * ```typescript
+     * // Reset only global animations
+     * gsapPlugin.revertGlobal();
+     *
+     * // Reset global animations while preserving context states
+     * gsapPlugin.revertGlobal();
+     * // Context-specific animations remain unchanged
+     * ```
+     */
+    revertGlobal(): void;
+    /**
+     * Clears all animations from the global animation context.
+     * Optionally kills the animations before clearing from tracking.
+     *
+     * @param kill - Whether to kill animations before clearing (default: false)
+     *
+     * @example
+     * ```typescript
+     * // Clear global context without killing
+     * gsapPlugin.clearGlobal();
+     *
+     * // Clear and kill global animations
+     * gsapPlugin.clearGlobal(true);
+     * ```
+     */
+    clearGlobal(kill?: boolean): void;
+}
+//# sourceMappingURL=GSAPPlugin.d.ts.map

package/lib/plugins/GSAPPlugin.d.ts.map

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

package/lib/plugins/KeyboardPlugin.d.ts

@@ -0,0 +1,53 @@
+import { IApplication } from '../core';
+import { Signal } from '../signals';
+import { KeyboardKey } from '../utils';
+import { IPlugin, Plugin } from './Plugin';
+export type KeyboardEventType = 'keydown' | 'keyup';
+export type KeyboardEventDetail = {
+    event: KeyboardEvent;
+    key: string;
+};
+export type KeySignal = Signal<(detail: KeyboardEventDetail) => void>;
+export interface IKeyboardPlugin extends IPlugin {
+    enabled: boolean;
+    readonly keysDown: Set<string>;
+    onKeyDown(key?: KeyboardKey): KeySignal;
+    onKeyUp(key?: KeyboardKey): KeySignal;
+    isKeyDown(key: string): boolean;
+}
+export declare function normalizeKey(key: string | undefined): string;
+export declare class KeyboardPlugin extends Plugin implements IKeyboardPlugin {
+    readonly id: string;
+    onGlobalKeyDown: Signal<(detail: KeyboardEventDetail) => void>;
+    onGlobalKeyUp: Signal<(detail: KeyboardEventDetail) => void>;
+    private _keyDownSignals;
+    private _keyUpSignals;
+    private _keysDown;
+    private _warnedNoConsumers;
+    get keysDown(): Set<string>;
+    private _enabled;
+    get enabled(): boolean;
+    set enabled(value: boolean);
+    initialize(_options: any, _app: IApplication): void;
+    destroy(): void;
+    onKeyDown(key?: KeyboardKey): KeySignal;
+    onKeyUp(key?: KeyboardKey): KeySignal;
+    isKeyDown(key: KeyboardKey): boolean;
+    _update(): void;
+    protected getCoreSignals(): string[];
+    protected getCoreFunctions(): string[];
+    private _handleKeyDown;
+    private _handleKeyUp;
+    /**
+     * Check if the signal exists and add it if it doesn't
+     * Also, if this is the first signal, start listening for the event
+     * @param {string} key
+     * @param {KeyboardEventType} eventType
+     * @returns {KeySignal}
+     * @private
+     */
+    private _checkAndAddSignal;
+    private _listen;
+    private _handleEvent;
+}
+//# sourceMappingURL=KeyboardPlugin.d.ts.map