@students-dev/audify-js 1.0.0 → 1.0.2

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

@@ -9,6 +9,8 @@ export class AudioEngine {
     filters: Filters;
     queue: Queue;
     eventBus: EventBus;
+    spotifyProvider: SpotifyProvider;
+    lavalinkProvider: LavalinkProvider;
     isReady: boolean;
     /**
      * Initialize the audio engine
@@ -46,7 +48,7 @@ export class AudioEngine {
      * Remove track from queue
      * @param {number|string} identifier - Track index or ID
      */
-    remove(identifier: number | string): import("../index.js").Track;
+    remove(identifier: number | string): Track;
     /**
      * Skip to next track
      */
@@ -89,6 +91,44 @@ export class AudioEngine {
      * @returns {Object} Engine state
      */
     getState(): any;
+    /**
+     * Initialize Spotify provider
+     * @param {Object} options - Spotify options
+     */
+    initSpotify(options?: any): void;
+    /**
+     * Load Spotify track and add to queue
+     * @param {string} trackId - Spotify track ID
+     * @param {Object} options - Options including token
+     * @returns {Promise<Track>} Added track
+     */
+    loadSpotifyTrack(trackId: string, options?: any): Promise<Track>;
+    /**
+     * Search Spotify tracks
+     * @param {string} query - Search query
+     * @param {Object} options - Search options
+     * @returns {Promise<Array>} Search results
+     */
+    searchSpotifyTracks(query: string, options?: any): Promise<any[]>;
+    /**
+     * Connect to Lavalink server
+     * @param {Object} options - Lavalink connection options
+     * @returns {Promise<void>}
+     */
+    connectLavalink(options?: any): Promise<void>;
+    /**
+     * Load Lavalink track and add to queue
+     * @param {string} identifier - Track identifier
+     * @returns {Promise<Track|Array<Track>>} Added track(s)
+     */
+    loadLavalinkTrack(identifier: string): Promise<Track | Array<Track>>;
+    /**
+     * Get Lavalink player for guild/channel
+     * @param {string} guildId - Guild ID
+     * @param {string} channelId - Voice channel ID
+     * @returns {Object} Lavalink player
+     */
+    getLavalinkPlayer(guildId: string, channelId: string): any;
     /**
      * Destroy the engine
      */
@@ -98,3 +138,6 @@ import { Player } from './Player.js';
 import { Filters } from './Filters.js';
 import { Queue } from '../queue/Queue.js';
 import { EventBus } from '../events/EventBus.js';
+import { SpotifyProvider } from '../providers/SpotifyProvider.js';
+import { LavalinkProvider } from '../providers/LavalinkProvider.js';
+import { Track } from '../queue/Track.js';

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,13 +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 * 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

@@ -0,0 +1,17 @@
+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;
+}

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

@@ -1,23 +1,12 @@
-/**
- * Local file provider for Node.js
- */
-export class LocalProvider {
-    /**
-     * Check if path is a valid local audio file
-     * @param {string} path - File path
-     * @returns {boolean} Is valid audio file
-     */
-    static isValidPath(path: string): boolean;
-    /**
-     * Get track info from local file
-     * @param {string} path - File path
-     * @returns {Promise<Object>} Track info
-     */
-    static getInfo(path: string): Promise<any>;
-    /**
-     * Check if file exists
-     * @param {string} path - File path
-     * @returns {Promise<boolean>} File exists
-     */
-    static exists(path: string): Promise<boolean>;
+import { IProvider, ITrack, IAudioEngine } from '../interfaces';
+export declare class LocalProvider implements IProvider {
+    name: string;
+    version: string;
+    private engine;
+    initialize(engine: IAudioEngine): Promise<void>;
+    resolve(path: string): Promise<ITrack | ITrack[]>;
+    play(track: ITrack): Promise<void>;
+    stop(): Promise<void>;
+    destroy(): void;
+    private exists;
 }

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

@@ -0,0 +1,10 @@
+import { IProvider } from '../interfaces';
+export declare class ProviderRegistry {
+    private providers;
+    constructor();
+    register(provider: IProvider): void;
+    unregister(name: string): void;
+    get(name: string): IProvider | undefined;
+    getAll(): IProvider[];
+    has(name: string): boolean;
+}

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

@@ -0,0 +1,14 @@
+import { IProvider, ITrack, IAudioEngine } from '../interfaces';
+export declare class SpotifyProvider implements IProvider {
+    name: string;
+    version: string;
+    private engine;
+    private spotifyApi;
+    constructor(options?: any);
+    initialize(engine: IAudioEngine): Promise<void>;
+    resolve(query: string): Promise<ITrack | ITrack[]>;
+    play(track: ITrack): Promise<void>;
+    stop(): Promise<void>;
+    destroy(): void;
+    private _formatTrack;
+}

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

@@ -1,29 +1,12 @@
-/**
- * YouTube provider for basic info fetching
- */
-export class YouTubeProvider {
-    /**
-     * Check if URL is a valid YouTube URL
-     * @param {string} url - URL to check
-     * @returns {boolean} Is valid YouTube URL
-     */
-    static isValidUrl(url: string): boolean;
-    /**
-     * Extract video ID from YouTube URL
-     * @param {string} url - YouTube URL
-     * @returns {string|null} Video ID
-     */
-    static extractVideoId(url: string): string | null;
-    /**
-     * Get basic track info from YouTube URL
-     * @param {string} url - YouTube URL
-     * @returns {Promise<Object>} Track info
-     */
-    static getInfo(url: string): Promise<any>;
-    /**
-     * Get stream URL (not implemented without dependencies)
-     * @param {string} url - YouTube URL
-     * @returns {Promise<string>} Stream URL
-     */
-    static getStreamUrl(url: string): Promise<string>;
+import { IProvider, ITrack, IAudioEngine } from '../interfaces';
+export declare class YouTubeProvider implements IProvider {
+    name: string;
+    version: string;
+    private engine;
+    initialize(engine: IAudioEngine): Promise<void>;
+    resolve(query: string): Promise<ITrack | ITrack[]>;
+    play(track: ITrack): Promise<void>;
+    stop(): Promise<void>;
+    destroy(): void;
+    private extractVideoId;
 }