@students-dev/audify-js 1.0.1 → 1.0.2

package/dist/types/AudioEngine.d.ts

@@ -0,0 +1,107 @@
+import { Player } from './engine/Player';
+import { Filters } from './engine/Filters';
+import { Queue } from './queue/Queue';
+import { EventBus } from './events/EventBus';
+import { ProviderRegistry } from './providers/ProviderRegistry';
+import { PluginManager } from './plugins/PluginManager';
+import { LoopMode } from './constants';
+import { IAudioEngine, IProvider, ITrack } from './interfaces';
+/**
+ * Main audio engine class
+ */
+export declare class AudioEngine implements IAudioEngine {
+    options: any;
+    player: Player;
+    filters: Filters;
+    queue: Queue;
+    eventBus: EventBus;
+    providers: ProviderRegistry;
+    plugins: PluginManager;
+    isReady: boolean;
+    constructor(options?: any);
+    /**
+     * Initialize the audio engine
+     */
+    initialize(): Promise<void>;
+    registerProvider(provider: IProvider): Promise<void>;
+    getProvider(name: string): IProvider | undefined;
+    /**
+     * Play track or resume playback
+     * @param track - Track to play or track identifier
+     */
+    play(track?: ITrack | string): Promise<void>;
+    /**
+     * Pause playback
+     */
+    pause(): void;
+    /**
+     * Stop playback
+     */
+    stop(): void;
+    /**
+     * Seek to position
+     * @param time - Time in seconds
+     */
+    seek(time: number): void;
+    /**
+     * Set volume
+     * @param volume - Volume level (0-1)
+     */
+    setVolume(volume: number): void;
+    /**
+     * Add track(s) to queue
+     * @param tracks - Track(s) to add
+     */
+    add(tracks: ITrack | ITrack[] | string | string[]): void;
+    /**
+     * Remove track from queue
+     * @param identifier - Track index or ID
+     */
+    remove(identifier: number | string): ITrack | null;
+    /**
+     * Skip to next track
+     */
+    next(): void;
+    /**
+     * Go to previous track
+     */
+    previous(): void;
+    /**
+     * Shuffle queue
+     */
+    shuffle(): void;
+    /**
+     * Clear queue
+     */
+    clear(): void;
+    /**
+     * Jump to track in queue
+     * @param index - Track index
+     */
+    jump(index: number): void;
+    /**
+     * Apply audio filter
+     * @param type - Filter type
+     * @param options - Filter options
+     */
+    applyFilter(type: any, options: any): void;
+    /**
+     * Remove audio filter
+     * @param type - Filter type
+     */
+    removeFilter(type: any): void;
+    /**
+     * Set loop mode
+     * @param mode - Loop mode
+     */
+    setLoopMode(mode: LoopMode): void;
+    /**
+     * Get current state
+     * @returns Engine state
+     */
+    getState(): any;
+    /**
+     * Destroy the engine
+     */
+    destroy(): void;
+}

package/dist/types/constants/index.d.ts

@@ -0,0 +1,39 @@
+export declare const EVENTS: {
+    readonly READY: "ready";
+    readonly ERROR: "error";
+    readonly PLAY: "play";
+    readonly PAUSE: "pause";
+    readonly STOP: "stop";
+    readonly TRACK_START: "trackStart";
+    readonly TRACK_END: "trackEnd";
+    readonly TRACK_ADD: "trackAdd";
+    readonly TRACK_REMOVE: "trackRemove";
+    readonly QUEUE_UPDATE: "queueUpdate";
+    readonly FILTER_APPLIED: "filterApplied";
+    readonly VOLUME_CHANGE: "volumeChange";
+    readonly SEEK: "seek";
+};
+export type EventType = typeof EVENTS[keyof typeof EVENTS];
+export declare const LOOP_MODES: {
+    readonly OFF: "off";
+    readonly TRACK: "track";
+    readonly QUEUE: "queue";
+};
+export type LoopMode = typeof LOOP_MODES[keyof typeof LOOP_MODES];
+export declare const PLAYER_STATES: {
+    readonly IDLE: "idle";
+    readonly PLAYING: "playing";
+    readonly PAUSED: "paused";
+    readonly BUFFERING: "buffering";
+};
+export type PlayerState = typeof PLAYER_STATES[keyof typeof PLAYER_STATES];
+export declare const FILTER_TYPES: {
+    readonly BASSBOOST: "bassboost";
+    readonly NIGHTCORE: "nightcore";
+    readonly VAPORWAVE: "vaporwave";
+    readonly ROTATE_8D: "8d";
+    readonly PITCH: "pitch";
+    readonly SPEED: "speed";
+    readonly REVERB: "reverb";
+};
+export type FilterType = typeof FILTER_TYPES[keyof typeof FILTER_TYPES];

package/dist/types/engine/Filters.d.ts

@@ -1,48 +1,49 @@
+import { FilterType } from '../constants';
 /**
  * Audio filters and effects
  */
-export class Filters {
-    constructor(audioContext: any);
-    audioContext: any;
-    filters: Map<any, any>;
-    enabled: Set<any>;
+export declare class Filters {
+    private audioContext;
+    private filters;
+    private enabled;
+    constructor(audioContext: AudioContext);
     /**
      * Apply filter
-     * @param {string} type - Filter type
-     * @param {Object} options - Filter options
+     * @param type - Filter type
+     * @param options - Filter options
      */
-    apply(type: string, options?: any): void;
+    apply(type: FilterType, options?: any): void;
     /**
      * Remove filter
-     * @param {string} type - Filter type
+     * @param type - Filter type
      */
-    remove(type: string): void;
+    remove(type: FilterType): void;
     /**
      * Clear all filters
      */
     clear(): void;
     /**
      * Check if filter is enabled
-     * @param {string} type - Filter type
-     * @returns {boolean} Is enabled
+     * @param type - Filter type
+     * @returns Is enabled
      */
-    isEnabled(type: string): boolean;
+    isEnabled(type: FilterType): boolean;
     /**
      * Get enabled filters
-     * @returns {Set} Enabled filter types
+     * @returns Enabled filter types
      */
-    getEnabled(): Set<any>;
-    applyBassBoost(options?: {}): void;
-    applyNightcore(options?: {}): void;
-    applyVaporwave(options?: {}): void;
-    apply8DRotate(options?: {}): void;
-    applyPitch(options?: {}): void;
-    applySpeed(options?: {}): void;
-    applyReverb(options?: {}): void;
+    getEnabled(): Set<FilterType>;
+    private applyBassBoost;
+    private applyNightcore;
+    private applyVaporwave;
+    private apply8DRotate;
+    private applyPitch;
+    private applySpeed;
+    private applyReverb;
     /**
      * Connect filters to audio node
-     * @param {AudioNode} input - Input node
-     * @param {AudioNode} output - Output node
+     * @param input - Input node
+     * @param output - Output node
      */
     connect(input: AudioNode, output: AudioNode): void;
 }

package/dist/types/engine/MockAudioContext.d.ts

@@ -0,0 +1,43 @@
+export declare class MockAudioContext {
+    state: string;
+    currentTime: number;
+    private startTime;
+    constructor();
+    private updateTime;
+    createGain(): {
+        connect: () => void;
+        gain: {
+            value: number;
+        };
+    };
+    createBiquadFilter(): {
+        connect: () => void;
+        frequency: {
+            value: number;
+        };
+        gain: {
+            value: number;
+        };
+    };
+    createPanner(): {
+        connect: () => void;
+    };
+    createConvolver(): {
+        connect: () => void;
+    };
+    createBufferSource(): MockAudioBufferSource;
+    decodeAudioData(buffer: ArrayBuffer): Promise<any>;
+    suspend(): void;
+    resume(): void;
+    close(): void;
+}
+declare class MockAudioBufferSource {
+    buffer: any;
+    onended: (() => void) | null;
+    private context;
+    constructor(context: MockAudioContext);
+    connect(): void;
+    start(when?: number, offset?: number): void;
+    stop(): void;
+}
+export {};

package/dist/types/engine/Player.d.ts

@@ -1,22 +1,32 @@
+import { LoopMode } from '../constants';
+import { EventBus } from '../events/EventBus';
+import { ITrack } from '../interfaces';
+import { AudioEngine } from '../AudioEngine';
 /**
  * Audio player with playback controls
  */
-export class Player {
-    constructor(audioEngine: any);
-    audioEngine: any;
-    audioContext: any;
-    source: any;
+export declare class Player {
+    private audioEngine;
+    audioContext: AudioContext;
+    private source;
     isPlaying: boolean;
     currentTime: number;
     duration: number;
     volume: number;
-    loopMode: string;
+    loopMode: LoopMode;
     eventBus: EventBus;
+    constructor(audioEngine: AudioEngine);
     /**
-     * Play audio
-     * @param {Track} track - Track to play
+     * Play audio track
+     * @param track - Track to play
      */
-    play(track: Track): Promise<void>;
+    play(track: ITrack): Promise<void>;
+    /**
+     * Play audio from URL/Stream directly
+     * This is called by Providers or as fallback
+     * @param track - Track object with URL
+     */
+    playStream(track: ITrack): Promise<void>;
     /**
      * Pause playback
      */
@@ -31,32 +41,26 @@ export class Player {
     stop(): void;
     /**
      * Seek to position
-     * @param {number} time - Time in seconds
+     * @param time - Time in seconds
      */
     seek(time: number): void;
     /**
      * Set volume
-     * @param {number} volume - Volume level (0-1)
+     * @param volume - Volume level (0-1)
      */
     setVolume(volume: number): void;
     /**
      * Set loop mode
-     * @param {string} mode - Loop mode
-     */
-    setLoopMode(mode: string): void;
-    /**
-     * Load track into player
-     * @param {Track} track - Track to load
+     * @param mode - Loop mode
      */
-    loadTrack(track: Track): Promise<void>;
+    setLoopMode(mode: LoopMode): void;
     /**
      * Handle track end based on loop mode
      */
-    handleTrackEnd(): void;
+    private handleTrackEnd;
     /**
      * Get current playback state
-     * @returns {Object} State object
+     * @returns State object
      */
     getState(): any;
 }
-import { EventBus } from '../events/EventBus.js';

package/dist/types/events/EventBus.d.ts

@@ -1,35 +1,37 @@
+export type Listener = (data?: any) => void;
 /**
  * Simple event emitter for handling events
  */
-export class EventBus {
-    events: {};
+export declare class EventBus {
+    private events;
+    constructor();
     /**
      * Register an event listener
-     * @param {string} event - Event name
-     * @param {Function} callback - Callback function
+     * @param event - Event name
+     * @param callback - Callback function
      */
-    on(event: string, callback: Function): void;
+    on(event: string, callback: Listener): void;
     /**
      * Remove an event listener
-     * @param {string} event - Event name
-     * @param {Function} callback - Callback function
+     * @param event - Event name
+     * @param callback - Callback function
      */
-    off(event: string, callback: Function): void;
+    off(event: string, callback: Listener): void;
     /**
      * Emit an event
-     * @param {string} event - Event name
-     * @param {*} data - Data to pass to listeners
+     * @param event - Event name
+     * @param data - Data to pass to listeners
      */
-    emit(event: string, data: any): void;
+    emit(event: string, data?: any): void;
     /**
      * Remove all listeners for an event
-     * @param {string} event - Event name
+     * @param event - Event name
      */
     removeAllListeners(event: string): void;
     /**
      * Get all listeners for an event
-     * @param {string} event - Event name
-     * @returns {Function[]} Array of listeners
+     * @param event - Event name
+     * @returns Array of listeners
      */
-    listeners(event: string): Function[];
+    listeners(event: string): Listener[];
 }

package/dist/types/index.d.ts

@@ -1,15 +1,17 @@
-export { AudioEngine } from "./engine/AudioEngine.js";
-export { Queue } from "./queue/Queue.js";
-export { Track } from "./queue/Track.js";
-export { PluginManager } from "./plugins/PluginManager.js";
-export { EventBus } from "./events/EventBus.js";
-export { Logger } from "./utils/Logger.js";
-export { TimeUtils } from "./utils/Time.js";
-export { MetadataUtils } from "./utils/Metadata.js";
-export { ProbeUtils } from "./utils/Probe.js";
-export { YouTubeProvider } from "./providers/YouTubeProvider.js";
-export { SoundCloudProvider } from "./providers/SoundCloudProvider.js";
-export { LocalProvider } from "./providers/LocalProvider.js";
-export { SpotifyProvider } from "./providers/SpotifyProvider.js";
-export { LavalinkProvider } from "./providers/LavalinkProvider.js";
-export * from "./constants/Modes.js";
+export { AudioEngine } from './AudioEngine';
+export { Queue } from './queue/Queue';
+export { Track } from './queue/Track';
+export { Filters as FilterManager } from './engine/Filters';
+export { Filters } from './engine/Filters';
+export { PluginManager } from './plugins/PluginManager';
+export { Plugin } from './plugins/Plugin';
+export { EventBus } from './events/EventBus';
+export * from './constants';
+export * from './interfaces';
+export * from './providers/LocalProvider';
+export * from './providers/YouTubeProvider';
+export * from './providers/SpotifyProvider';
+export * from './providers/LavalinkProvider';
+export * from './utils/Logger';
+export * from './utils/Time';
+export * from './utils/Metadata';

package/dist/types/interfaces/index.d.ts

@@ -0,0 +1,31 @@
+export interface ITrack {
+    id: string;
+    url: string;
+    title: string;
+    artist?: string;
+    duration?: number;
+    thumbnail?: string;
+    source?: string;
+    metadata: Record<string, any>;
+}
+export interface IAudioEngine {
+    play(track: ITrack): Promise<void>;
+    player: any;
+}
+export interface IProvider {
+    name: string;
+    version: string;
+    initialize(engine: IAudioEngine): Promise<void>;
+    resolve(query: string): Promise<ITrack | ITrack[]>;
+    play(track: ITrack): Promise<void>;
+    stop(): Promise<void>;
+    destroy(): void;
+}
+export interface IPlugin {
+    name: string;
+    version: string;
+    onLoad(engine: IAudioEngine): void;
+    onUnload(): void;
+    onEnable(): void;
+    onDisable(): void;
+}

package/dist/types/plugins/Plugin.d.ts

@@ -1,49 +1,17 @@
-/**
- * Base plugin class
- */
-export class Plugin {
-    constructor(name: any, version?: string);
-    name: any;
+import { IPlugin, IAudioEngine } from '../interfaces';
+export declare abstract class Plugin implements IPlugin {
+    name: string;
     version: string;
     enabled: boolean;
     loaded: boolean;
-    /**
-     * Called when plugin is loaded
-     * @param {AudioEngine} engine - Audio engine instance
-     */
-    onLoad(engine: AudioEngine): void;
-    engine: AudioEngine;
-    /**
-     * Called when plugin is enabled
-     */
+    protected engine?: IAudioEngine;
+    constructor(name: string, version?: string);
+    onLoad(engine: IAudioEngine): void;
+    onUnload(): void;
     onEnable(): void;
-    /**
-     * Called when plugin is disabled
-     */
     onDisable(): void;
-    /**
-     * Hook called before play
-     * @param {Track} track - Track being played
-     */
-    beforePlay(track: Track): void;
-    /**
-     * Hook called after play
-     * @param {Track} track - Track being played
-     */
-    afterPlay(track: Track): void;
-    /**
-     * Hook called when track ends
-     * @param {Track} track - Track that ended
-     */
-    trackEnd(track: Track): void;
-    /**
-     * Hook called when queue updates
-     * @param {Queue} queue - Updated queue
-     */
-    queueUpdate(queue: Queue): void;
-    /**
-     * Get plugin info
-     * @returns {Object} Plugin information
-     */
-    getInfo(): any;
+    beforePlay(track: any): void;
+    afterPlay(track: any): void;
+    trackEnd(track: any): void;
+    queueUpdate(queue: any): void;
 }

package/dist/types/plugins/PluginManager.d.ts

@@ -1,51 +1,51 @@
+import { IPlugin, IAudioEngine } from '../interfaces';
 /**
  * Plugin manager for loading and managing plugins
  */
-export class PluginManager {
-    constructor(audioEngine: any);
-    engine: any;
-    plugins: Map<any, any>;
+export declare class PluginManager {
+    private engine;
+    private plugins;
+    constructor(engine: IAudioEngine);
     /**
      * Load a plugin
-     * @param {Plugin} plugin - Plugin instance
+     * @param plugin - Plugin instance
      */
-    load(plugin: Plugin): void;
+    load(plugin: IPlugin): void;
     /**
      * Enable a plugin
-     * @param {string} name - Plugin name
+     * @param name - Plugin name
      */
     enable(name: string): void;
     /**
      * Disable a plugin
-     * @param {string} name - Plugin name
+     * @param name - Plugin name
      */
     disable(name: string): void;
     /**
      * Unload a plugin
-     * @param {string} name - Plugin name
+     * @param name - Plugin name
      */
     unload(name: string): void;
     /**
      * Get plugin by name
-     * @param {string} name - Plugin name
-     * @returns {Plugin|null} Plugin instance
+     * @param name - Plugin name
+     * @returns Plugin instance
      */
-    get(name: string): Plugin | null;
+    get(name: string): IPlugin | undefined;
     /**
      * Get all plugins
-     * @returns {Map} Map of plugins
+     * @returns Map of plugins
      */
-    getAll(): Map<any, any>;
+    getAll(): Map<string, IPlugin>;
     /**
      * Get enabled plugins
-     * @returns {Plugin[]} Array of enabled plugins
+     * @returns Array of enabled plugins
      */
-    getEnabled(): Plugin[];
+    getEnabled(): IPlugin[];
     /**
      * Call hook on all enabled plugins
-     * @param {string} hook - Hook name
-     * @param {...*} args - Arguments to pass
+     * @param hook - Hook name
+     * @param args - Arguments to pass
      */
     callHook(hook: string, ...args: any[]): void;
 }
-import { Plugin } from './Plugin.js';

package/dist/types/providers/LavalinkProvider.d.ts

@@ -1,48 +1,17 @@
-/**
- * Lavalink provider for connecting to Lavalink server
- */
-export class LavalinkProvider {
-    constructor(options?: {});
-    host: any;
-    port: any;
-    password: any;
-    secure: any;
-    manager: LavalinkManager<import("lavalink-client").Player>;
-    node: any;
-    isConnected: boolean;
-    /**
-     * Connect to Lavalink server
-     * @returns {Promise<void>}
-     */
-    connect(): Promise<void>;
-    /**
-     * Disconnect from Lavalink server
-     */
-    disconnect(): void;
-    /**
-     * Create a player for a guild/channel
-     * @param {string} guildId - Guild ID
-     * @param {string} channelId - Voice channel ID
-     * @returns {Object} Player instance
-     */
-    createPlayer(guildId: string, channelId: string): any;
-    /**
-     * Load track from Lavalink
-     * @param {string} identifier - Track identifier (URL or search query)
-     * @returns {Promise<Object>} Track info
-     */
-    loadTrack(identifier: string): Promise<any>;
-    /**
-     * Format Lavalink track to internal format
-     * @param {Object} lavalinkTrack - Lavalink track object
-     * @returns {Object} Formatted track
-     * @private
-     */
+import { IProvider, ITrack, IAudioEngine } from '../interfaces';
+export declare class LavalinkProvider implements IProvider {
+    name: string;
+    version: string;
+    private engine;
+    private manager;
+    private node;
+    private options;
+    constructor(options?: any);
+    initialize(engine: IAudioEngine): Promise<void>;
+    resolve(identifier: string): Promise<ITrack | ITrack[]>;
+    play(track: ITrack): Promise<void>;
+    createPlayer(guildId: string, channelId: string): import("lavalink-client").Player;
+    stop(): Promise<void>;
+    destroy(): void;
     private _formatTrack;
-    /**
-     * Get node stats
-     * @returns {Promise<Object>} Node stats
-     */
-    getStats(): Promise<any>;
 }
-import { LavalinkManager } from 'lavalink-client';