@students-dev/audify-js 1.0.0 → 1.0.2

package/dist/providers/LavalinkProvider.js

@@ -0,0 +1,81 @@
+import { Track } from '../queue/Track';
+import { LavalinkManager } from 'lavalink-client';
+export class LavalinkProvider {
+    constructor(options = {}) {
+        this.name = 'lavalink';
+        this.version = '1.0.0';
+        this.engine = null;
+        this.manager = null;
+        this.node = null;
+        this.options = options;
+    }
+    async initialize(engine) {
+        this.engine = engine;
+        this.manager = new LavalinkManager({
+            nodes: [{
+                    host: this.options.host || 'localhost',
+                    port: this.options.port || 2333,
+                    // @ts-ignore
+                    password: this.options.password || 'youshallnotpass',
+                    secure: this.options.secure || false,
+                    id: 'main'
+                }],
+            sendToShard: (guildId, payload) => {
+                // Mock
+            }
+        });
+        // @ts-ignore
+        if (this.manager.connect)
+            await this.manager.connect();
+        // @ts-ignore
+        this.node = this.manager.nodes ? this.manager.nodes.get('main') : this.manager.node;
+    }
+    async resolve(identifier) {
+        if (!this.node)
+            throw new Error('Lavalink not connected');
+        const result = await this.node.rest.loadTracks(identifier);
+        if (result.loadType === 'TRACK_LOADED') {
+            return this._formatTrack(result.tracks[0]);
+        }
+        else if (result.loadType === 'PLAYLIST_LOADED' || result.loadType === 'SEARCH_RESULT') {
+            return result.tracks.map((t) => this._formatTrack(t));
+        }
+        return [];
+    }
+    async play(track) {
+        throw new Error('Lavalink play() requires guild/channel context. Use createPlayer() directly.');
+    }
+    createPlayer(guildId, channelId) {
+        if (!this.manager)
+            throw new Error('Not initialized');
+        return this.manager.createPlayer({
+            guildId,
+            voiceChannelId: channelId
+        });
+    }
+    async stop() {
+        // Stop all?
+    }
+    destroy() {
+        if (this.manager) {
+            // @ts-ignore
+            if (this.manager.destroy)
+                this.manager.destroy();
+        }
+    }
+    _formatTrack(lavalinkTrack) {
+        const info = lavalinkTrack.info;
+        return new Track(info.uri, {
+            id: lavalinkTrack.track,
+            title: info.title,
+            artist: info.author,
+            duration: Math.floor(info.length / 1000),
+            thumbnail: info.artworkUrl,
+            source: 'lavalink',
+            metadata: {
+                lavalinkTrack: lavalinkTrack.track,
+                identifier: info.identifier
+            }
+        });
+    }
+}

package/dist/providers/LocalProvider.js

@@ -0,0 +1,70 @@
+import { promises as fs } from 'fs';
+import { extname } from 'path';
+import { Track } from '../queue/Track';
+export class LocalProvider {
+    constructor() {
+        this.name = 'local';
+        this.version = '1.0.0';
+        this.engine = null;
+    }
+    async initialize(engine) {
+        this.engine = engine;
+    }
+    async resolve(path) {
+        if (!await this.exists(path)) {
+            throw new Error('File not found');
+        }
+        // Node.js specific checks
+        const stats = await fs.stat(path);
+        if (!stats.isFile()) {
+            throw new Error('Path is not a file');
+        }
+        const track = new Track(`file://${path}`, {
+            title: path.split('/').pop()?.replace(extname(path), '') || 'Unknown',
+            source: 'local',
+            metadata: {
+                size: stats.size,
+                modified: stats.mtime
+            }
+        });
+        return track;
+    }
+    async play(track) {
+        if (!this.engine)
+            throw new Error('Provider not initialized');
+        // For local files, we assume the player can handle file:// URLs or we might need to read it into a buffer here?
+        // The previous Player implementation used fetch(url). fetch supports file:// in some envs but not all.
+        // However, given the hybrid nature, we'll assume the engine's player handles the URL.
+        // Actually, Player.ts uses fetch(). fetch('file://...') might fail in Node if not polyfilled or configured.
+        // But let's stick to the architecture: Provider calls engine.player.load(track).
+        // Wait, AudioEngine.ts in JS called `player.play(track)`.
+        // So the Provider.play just needs to confirm it CAN play or do setup?
+        // If AudioEngine delegates to Provider, then Provider MUST do the work.
+        // "AudioEngine calls provider.play(track)" -> Provider must make sound happen.
+        // So LocalProvider should call this.engine.player.play(track).
+        // BUT checking for infinite loop: Engine calls Provider.play -> Provider calls Engine.player.play?
+        // Engine needs to know NOT to call Provider again.
+        // Engine.play(track) -> check provider -> provider.play(track)
+        // Provider.play(track) -> engine.player.loadSource(track.url) -> source.start()
+        // We need to expose `loadSource` or similar on engine/player.
+        // For now, I'll assume engine.player has low-level methods.
+        // Let's assume the Player has a `playStream(url)` method.
+        // I'll type cast engine.player for now.
+        await this.engine.player.playStream(track);
+    }
+    async stop() {
+        // Local provider doesn't manage state separate from engine
+    }
+    destroy() {
+        // No cleanup needed
+    }
+    async exists(path) {
+        try {
+            await fs.access(path);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+}

package/dist/providers/ProviderRegistry.js

@@ -0,0 +1,20 @@
+export class ProviderRegistry {
+    constructor() {
+        this.providers = new Map();
+    }
+    register(provider) {
+        this.providers.set(provider.name, provider);
+    }
+    unregister(name) {
+        this.providers.delete(name);
+    }
+    get(name) {
+        return this.providers.get(name);
+    }
+    getAll() {
+        return Array.from(this.providers.values());
+    }
+    has(name) {
+        return this.providers.has(name);
+    }
+}

package/dist/providers/SpotifyProvider.js

@@ -0,0 +1,59 @@
+import { Track } from '../queue/Track';
+import SpotifyWebApi from 'spotify-web-api-node';
+export class SpotifyProvider {
+    constructor(options = {}) {
+        this.name = 'spotify';
+        this.version = '1.0.0';
+        this.engine = null;
+        this.spotifyApi = new SpotifyWebApi({
+            clientId: options.clientId,
+            clientSecret: options.clientSecret,
+            redirectUri: options.redirectUri,
+            accessToken: options.accessToken,
+            refreshToken: options.refreshToken
+        });
+    }
+    async initialize(engine) {
+        this.engine = engine;
+    }
+    async resolve(query) {
+        // Check if query is ID or URL or Search
+        if (query.includes('spotify.com/track/')) {
+            const id = query.split('track/')[1].split('?')[0];
+            const data = await this.spotifyApi.getTrack(id);
+            return this._formatTrack(data.body);
+        }
+        // Default to search
+        const data = await this.spotifyApi.searchTracks(query);
+        return data.body.tracks?.items.map(t => this._formatTrack(t)) || [];
+    }
+    async play(track) {
+        if (!this.engine)
+            throw new Error('Provider not initialized');
+        // Spotify playback usually requires Web SDK or resolving to another source
+        // Here we can throw or try to resolve if Preview URL is available
+        if (track.metadata.preview_url) {
+            await this.engine.player.playStream({ ...track, url: track.metadata.preview_url });
+        }
+        else {
+            throw new Error('Spotify full playback not supported in this provider version (preview only)');
+        }
+    }
+    async stop() { }
+    destroy() { }
+    _formatTrack(spotifyTrack) {
+        return new Track(spotifyTrack.external_urls.spotify, {
+            id: spotifyTrack.id,
+            title: spotifyTrack.name,
+            artist: spotifyTrack.artists.map((a) => a.name).join(', '),
+            duration: Math.floor(spotifyTrack.duration_ms / 1000),
+            thumbnail: spotifyTrack.album.images[0]?.url,
+            source: 'spotify',
+            metadata: {
+                spotifyId: spotifyTrack.id,
+                preview_url: spotifyTrack.preview_url,
+                popularity: spotifyTrack.popularity
+            }
+        });
+    }
+}

package/dist/providers/YouTubeProvider.js

@@ -0,0 +1,48 @@
+import { Track } from '../queue/Track';
+export class YouTubeProvider {
+    constructor() {
+        this.name = 'youtube';
+        this.version = '1.0.0';
+        this.engine = null;
+    }
+    async initialize(engine) {
+        this.engine = engine;
+    }
+    async resolve(query) {
+        if (query.includes('youtube.com') || query.includes('youtu.be')) {
+            const videoId = this.extractVideoId(query);
+            if (!videoId)
+                throw new Error('Invalid YouTube URL');
+            return new Track(query, {
+                title: `YouTube Video ${videoId}`,
+                thumbnail: `https://img.youtube.com/vi/${videoId}/maxresdefault.jpg`,
+                source: 'youtube',
+                metadata: { videoId }
+            });
+        }
+        // Search not implemented in this mock
+        throw new Error('Search not implemented');
+    }
+    async play(track) {
+        if (!this.engine)
+            throw new Error('Provider not initialized');
+        // In a real app, resolve stream URL here (e.g. ytdl-core)
+        // const streamUrl = await ytdl(track.url);
+        // await this.engine.player.playStream(streamUrl);
+        throw new Error('Stream URL extraction requires additional dependencies (ytdl-core)');
+    }
+    async stop() { }
+    destroy() { }
+    extractVideoId(url) {
+        try {
+            const urlObj = new URL(url);
+            if (urlObj.hostname === 'youtu.be') {
+                return urlObj.pathname.slice(1);
+            }
+            return urlObj.searchParams.get('v');
+        }
+        catch {
+            return null;
+        }
+    }
+}

package/dist/queue/Queue.js

@@ -0,0 +1,186 @@
+import { Track } from './Track';
+import { EventBus } from '../events/EventBus';
+import { EVENTS } from '../constants';
+/**
+ * Audio queue management
+ */
+export class Queue {
+    constructor() {
+        this.tracks = [];
+        this.currentIndex = -1;
+        this.eventBus = new EventBus();
+    }
+    /**
+     * Add track(s) to queue
+     * @param tracks - Track(s) to add
+     * @param position - Position to insert (optional)
+     */
+    add(tracks, position) {
+        const trackArray = Array.isArray(tracks) ? tracks : [tracks];
+        const processedTracks = trackArray.map(track => {
+            if (typeof track === 'string') {
+                return new Track(track);
+            }
+            if (track instanceof Track) {
+                return track;
+            }
+            // It's ITrack or similar object
+            return new Track(track.url, track);
+        });
+        if (position !== undefined && position >= 0 && position <= this.tracks.length) {
+            this.tracks.splice(position, 0, ...processedTracks);
+        }
+        else {
+            this.tracks.push(...processedTracks);
+        }
+        processedTracks.forEach(track => {
+            this.eventBus.emit(EVENTS.TRACK_ADD, track);
+        });
+        this.eventBus.emit(EVENTS.QUEUE_UPDATE, this.tracks);
+    }
+    /**
+     * Remove track from queue
+     * @param identifier - Track index or ID
+     * @returns Removed track
+     */
+    remove(identifier) {
+        let index;
+        if (typeof identifier === 'number') {
+            index = identifier;
+        }
+        else {
+            index = this.tracks.findIndex(track => track.id === identifier);
+        }
+        if (index < 0 || index >= this.tracks.length)
+            return null;
+        const removed = this.tracks.splice(index, 1)[0];
+        if (this.currentIndex > index) {
+            this.currentIndex--;
+        }
+        else if (this.currentIndex === index) {
+            this.currentIndex = -1;
+        }
+        this.eventBus.emit(EVENTS.TRACK_REMOVE, removed);
+        this.eventBus.emit(EVENTS.QUEUE_UPDATE, this.tracks);
+        return removed;
+    }
+    /**
+     * Shuffle the queue
+     */
+    shuffle() {
+        if (this.tracks.length <= 1)
+            return;
+        let currentTrack = null;
+        if (this.currentIndex >= 0) {
+            currentTrack = this.tracks[this.currentIndex];
+        }
+        for (let i = this.tracks.length - 1; i > 0; i--) {
+            const j = Math.floor(Math.random() * (i + 1));
+            [this.tracks[i], this.tracks[j]] = [this.tracks[j], this.tracks[i]];
+        }
+        if (currentTrack) {
+            this.currentIndex = this.tracks.indexOf(currentTrack);
+        }
+        else {
+            this.currentIndex = -1;
+        }
+        this.eventBus.emit(EVENTS.QUEUE_UPDATE, this.tracks);
+    }
+    /**
+     * Clear the queue
+     */
+    clear() {
+        this.tracks = [];
+        this.currentIndex = -1;
+        this.eventBus.emit(EVENTS.QUEUE_UPDATE, this.tracks);
+    }
+    /**
+     * Jump to specific track
+     * @param index - Track index
+     * @returns Track at index
+     */
+    jump(index) {
+        if (index < 0 || index >= this.tracks.length)
+            return null;
+        this.currentIndex = index;
+        return this.tracks[index];
+    }
+    /**
+     * Get current track
+     * @returns Current track
+     */
+    getCurrent() {
+        return this.currentIndex >= 0 ? this.tracks[this.currentIndex] : null;
+    }
+    /**
+     * Get next track
+     * Moves cursor forward
+     * @param loop - Whether to loop back to start
+     * @returns Next track
+     */
+    next(loop = false) {
+        if (this.tracks.length === 0)
+            return null;
+        let nextIndex = this.currentIndex + 1;
+        if (nextIndex >= this.tracks.length) {
+            if (loop) {
+                nextIndex = 0;
+            }
+            else {
+                return null;
+            }
+        }
+        this.currentIndex = nextIndex;
+        return this.tracks[this.currentIndex];
+    }
+    /**
+     * Get previous track
+     * Moves cursor backward
+     * @param loop - Whether to loop to end
+     * @returns Previous track
+     */
+    previous(loop = false) {
+        if (this.tracks.length === 0)
+            return null;
+        let prevIndex = this.currentIndex - 1;
+        if (prevIndex < 0) {
+            if (loop) {
+                prevIndex = this.tracks.length - 1;
+            }
+            else {
+                return null;
+            }
+        }
+        this.currentIndex = prevIndex;
+        return this.tracks[this.currentIndex];
+    }
+    /**
+     * Get all tracks
+     * @returns Array of tracks
+     */
+    getTracks() {
+        return [...this.tracks];
+    }
+    /**
+     * Get queue size
+     * @returns Number of tracks
+     */
+    size() {
+        return this.tracks.length;
+    }
+    /**
+     * Check if queue is empty
+     * @returns Is empty
+     */
+    isEmpty() {
+        return this.tracks.length === 0;
+    }
+    /**
+     * Get track at index
+     * @param index - Track index
+     * @returns Track at index
+     */
+    getTrack(index) {
+        return index >= 0 && index < this.tracks.length ? this.tracks[index] : null;
+    }
+}

package/dist/queue/Track.js

@@ -0,0 +1,54 @@
+import { MetadataUtils } from '../utils/Metadata';
+/**
+ * Represents an audio track
+ */
+export class Track {
+    /**
+     * @param url - Track URL or file path
+     * @param options - Additional options
+     */
+    constructor(url, options = {}) {
+        const extracted = MetadataUtils.extract(url);
+        this.url = url;
+        this.title = options.title || extracted.title || 'Unknown Title';
+        this.artist = options.artist || extracted.artist;
+        this.duration = options.duration || extracted.duration;
+        this.thumbnail = options.thumbnail || extracted.thumbnail;
+        this.source = options.source || extracted.source || 'unknown';
+        this.metadata = options.metadata || {};
+        this.id = options.id || Math.random().toString(36).substr(2, 9);
+    }
+    /**
+     * Get track info
+     * @returns Track information
+     */
+    getInfo() {
+        return {
+            id: this.id,
+            url: this.url,
+            title: this.title,
+            artist: this.artist,
+            duration: this.duration,
+            thumbnail: this.thumbnail,
+            source: this.source,
+            metadata: this.metadata
+        };
+    }
+    /**
+     * Update track metadata
+     * @param metadata - New metadata
+     */
+    updateMetadata(metadata) {
+        Object.assign(this, metadata);
+        if (metadata.metadata) {
+            Object.assign(this.metadata, metadata.metadata);
+        }
+    }
+    /**
+     * Check if track is valid
+     * @returns Is valid
+     */
+    isValid() {
+        return !!(this.url && this.title);
+    }
+}

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];