@students-dev/audify-js 1.0.1 → 1.0.2

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

@@ -1,54 +1,14 @@
-/**
- * Spotify provider for client-side API integration
- */
-export class SpotifyProvider {
-    constructor(options?: {});
-    spotifyApi: any;
-    /**
-     * Set access token
-     * @param {string} token - OAuth access token
-     */
-    setAccessToken(token: string): void;
-    /**
-     * Set refresh token
-     * @param {string} token - OAuth refresh token
-     */
-    setRefreshToken(token: string): void;
-    /**
-     * Refresh access token
-     * @returns {Promise<Object>} Token response
-     */
-    refreshAccessToken(): Promise<any>;
-    /**
-     * Search tracks
-     * @param {string} query - Search query
-     * @param {Object} options - Search options
-     * @returns {Promise<Array>} Array of track objects
-     */
-    searchTracks(query: string, options?: any): Promise<any[]>;
-    /**
-     * Get track by ID
-     * @param {string} trackId - Spotify track ID
-     * @returns {Promise<Object>} Track object
-     */
-    getTrack(trackId: string): Promise<any>;
-    /**
-     * Get tracks by IDs
-     * @param {Array<string>} trackIds - Array of Spotify track IDs
-     * @returns {Promise<Array>} Array of track objects
-     */
-    getTracks(trackIds: Array<string>): Promise<any[]>;
-    /**
-     * Get audio features for track
-     * @param {string} trackId - Spotify track ID
-     * @returns {Promise<Object>} Audio features
-     */
-    getAudioFeatures(trackId: string): Promise<any>;
-    /**
-     * Format Spotify track to internal format
-     * @param {Object} spotifyTrack - Spotify track object
-     * @returns {Object} Formatted track
-     * @private
-     */
+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;
 }

package/dist/types/queue/Queue.d.ts

@@ -1,20 +1,24 @@
+import { Track } from './Track';
+import { EventBus } from '../events/EventBus';
+import { ITrack } from '../interfaces';
 /**
  * Audio queue management
  */
-export class Queue {
-    tracks: any[];
-    currentIndex: number;
+export declare class Queue {
+    private tracks;
+    private currentIndex;
     eventBus: EventBus;
+    constructor();
     /**
      * Add track(s) to queue
-     * @param {Track|Track[]|string|string[]} tracks - Track(s) to add
-     * @param {number} position - Position to insert (optional)
+     * @param tracks - Track(s) to add
+     * @param position - Position to insert (optional)
      */
-    add(tracks: Track | Track[] | string | string[], position: number): void;
+    add(tracks: Track | ITrack | (Track | ITrack)[] | string | string[], position?: number): void;
     /**
      * Remove track from queue
-     * @param {number|string} identifier - Track index or ID
-     * @returns {Track|null} Removed track
+     * @param identifier - Track index or ID
+     * @returns Removed track
      */
     remove(identifier: number | string): Track | null;
     /**
@@ -27,46 +31,48 @@ export class Queue {
     clear(): void;
     /**
      * Jump to specific track
-     * @param {number} index - Track index
-     * @returns {Track|null} Track at index
+     * @param index - Track index
+     * @returns Track at index
      */
     jump(index: number): Track | null;
     /**
      * Get current track
-     * @returns {Track|null} Current track
+     * @returns Current track
      */
     getCurrent(): Track | null;
     /**
      * Get next track
-     * @returns {Track|null} Next track
+     * Moves cursor forward
+     * @param loop - Whether to loop back to start
+     * @returns Next track
      */
-    getNext(): Track | null;
+    next(loop?: boolean): Track | null;
     /**
      * Get previous track
-     * @returns {Track|null} Previous track
+     * Moves cursor backward
+     * @param loop - Whether to loop to end
+     * @returns Previous track
      */
-    getPrevious(): Track | null;
+    previous(loop?: boolean): Track | null;
     /**
      * Get all tracks
-     * @returns {Track[]} Array of tracks
+     * @returns Array of tracks
      */
     getTracks(): Track[];
     /**
      * Get queue size
-     * @returns {number} Number of tracks
+     * @returns Number of tracks
      */
     size(): number;
     /**
      * Check if queue is empty
-     * @returns {boolean} Is empty
+     * @returns Is empty
      */
     isEmpty(): boolean;
     /**
      * Get track at index
-     * @param {number} index - Track index
-     * @returns {Track|null} Track at index
+     * @param index - Track index
+     * @returns Track at index
      */
     getTrack(index: number): Track | null;
 }
-import { EventBus } from '../events/EventBus.js';
-import { Track } from './Track.js';

package/dist/types/queue/Track.d.ts

@@ -1,32 +1,34 @@
+import { ITrack } from '../interfaces';
 /**
  * Represents an audio track
  */
-export class Track {
+export declare class Track implements ITrack {
+    id: string;
+    url: string;
+    title: string;
+    artist?: string;
+    duration?: number;
+    thumbnail?: string;
+    source?: string;
+    metadata: Record<string, any>;
     /**
-     * @param {string} url - Track URL or file path
-     * @param {Object} options - Additional options
+     * @param url - Track URL or file path
+     * @param options - Additional options
      */
-    constructor(url: string, options?: any);
-    url: string;
-    title: any;
-    artist: any;
-    duration: any;
-    thumbnail: any;
-    metadata: any;
-    id: any;
+    constructor(url: string, options?: Partial<ITrack>);
     /**
      * Get track info
-     * @returns {Object} Track information
+     * @returns Track information
      */
-    getInfo(): any;
+    getInfo(): ITrack;
     /**
      * Update track metadata
-     * @param {Object} metadata - New metadata
+     * @param metadata - New metadata
      */
-    updateMetadata(metadata: any): void;
+    updateMetadata(metadata: Partial<ITrack>): void;
     /**
      * Check if track is valid
-     * @returns {boolean} Is valid
+     * @returns Is valid
      */
     isValid(): boolean;
 }

package/dist/types/utils/Logger.d.ts

@@ -1,39 +1,35 @@
+export type LogLevel = 'debug' | 'info' | 'warn' | 'error';
 /**
  * Logger utility with different levels
  */
-export class Logger {
-    constructor(level?: string);
-    levels: {
-        debug: number;
-        info: number;
-        warn: number;
-        error: number;
-    };
-    currentLevel: any;
+export declare class Logger {
+    private levels;
+    private currentLevel;
+    constructor(level?: LogLevel);
     /**
      * Set log level
-     * @param {string} level - Log level (debug, info, warn, error)
+     * @param level - Log level (debug, info, warn, error)
      */
-    setLevel(level: string): void;
+    setLevel(level: LogLevel): void;
     /**
      * Debug log
-     * @param {...*} args - Arguments to log
+     * @param args - Arguments to log
      */
     debug(...args: any[]): void;
     /**
      * Info log
-     * @param {...*} args - Arguments to log
+     * @param args - Arguments to log
      */
     info(...args: any[]): void;
     /**
      * Warning log
-     * @param {...*} args - Arguments to log
+     * @param args - Arguments to log
      */
     warn(...args: any[]): void;
     /**
      * Error log
-     * @param {...*} args - Arguments to log
+     * @param args - Arguments to log
      */
     error(...args: any[]): void;
 }
-export const logger: Logger;
+export declare const logger: Logger;

package/dist/types/utils/Metadata.d.ts

@@ -1,35 +1,36 @@
+import { ITrack } from '../interfaces';
 /**
  * Metadata parsing utilities
  */
-export class MetadataUtils {
+export declare class MetadataUtils {
     /**
      * Extract basic metadata from URL or file path
-     * @param {string} source - URL or file path
-     * @returns {Object} Metadata object
+     * @param source - URL or file path
+     * @returns Metadata object
      */
-    static extract(source: string): any;
+    static extract(source: string): Partial<ITrack>;
     /**
      * Extract title from source
-     * @param {string} source - Source string
-     * @returns {string} Extracted title
+     * @param source - Source string
+     * @returns Extracted title
      */
     static extractTitle(source: string): string;
     /**
      * Extract YouTube metadata (basic)
-     * @param {string} url - YouTube URL
-     * @returns {Object} Metadata
+     * @param url - YouTube URL
+     * @returns Metadata
      */
-    static extractYouTubeMetadata(url: string): any;
+    private static extractYouTubeMetadata;
     /**
      * Extract SoundCloud metadata (basic)
-     * @param {string} url - SoundCloud URL
-     * @returns {Object} Metadata
+     * @param url - SoundCloud URL
+     * @returns Metadata
      */
-    static extractSoundCloudMetadata(url: string): any;
+    private static extractSoundCloudMetadata;
     /**
      * Extract file metadata (basic)
-     * @param {string} path - File path
-     * @returns {Object} Metadata
+     * @param path - File path
+     * @returns Metadata
      */
-    static extractFileMetadata(path: string): any;
+    private static extractFileMetadata;
 }

package/dist/types/utils/Probe.d.ts

@@ -1,23 +1,23 @@
 /**
  * Audio probing utilities
  */
-export class ProbeUtils {
+export declare class ProbeUtils {
     /**
      * Probe audio file/stream for basic info
-     * @param {string|Buffer|ReadableStream} source - Audio source
-     * @returns {Promise<Object>} Probe result
+     * @param source - Audio source
+     * @returns Probe result
      */
     static probe(source: string | Buffer | ReadableStream): Promise<any>;
     /**
      * Check if source is a valid audio URL
-     * @param {string} url - URL to check
-     * @returns {boolean} Is valid audio URL
+     * @param url - URL to check
+     * @returns Is valid audio URL
      */
     static isValidAudioUrl(url: string): boolean;
     /**
      * Get audio format from URL or buffer
-     * @param {string|Buffer} source - Audio source
-     * @returns {string|null} Audio format
+     * @param source - Audio source
+     * @returns Audio format
      */
     static getFormat(source: string | Buffer): string | null;
 }

package/dist/types/utils/Time.d.ts

@@ -1,29 +1,29 @@
 /**
  * Time formatting utilities
  */
-export class TimeUtils {
+export declare class TimeUtils {
     /**
      * Format seconds to MM:SS or HH:MM:SS
-     * @param {number} seconds - Time in seconds
-     * @returns {string} Formatted time string
+     * @param seconds - Time in seconds
+     * @returns Formatted time string
      */
     static format(seconds: number): string;
     /**
      * Parse time string to seconds
-     * @param {string} timeStr - Time string like "1:23" or "01:23:45"
-     * @returns {number} Time in seconds
+     * @param timeStr - Time string like "1:23" or "01:23:45"
+     * @returns Time in seconds
      */
     static parse(timeStr: string): number;
     /**
      * Get current timestamp in milliseconds
-     * @returns {number} Current time
+     * @returns Current time
      */
     static now(): number;
     /**
      * Calculate duration between two timestamps
-     * @param {number} start - Start time
-     * @param {number} end - End time
-     * @returns {number} Duration in milliseconds
+     * @param start - Start time
+     * @param end - End time
+     * @returns Duration in milliseconds
      */
     static duration(start: number, end: number): number;
 }

package/dist/utils/Logger.js

@@ -0,0 +1,59 @@
+/**
+ * Logger utility with different levels
+ */
+export class Logger {
+    constructor(level = 'info') {
+        this.levels = {
+            debug: 0,
+            info: 1,
+            warn: 2,
+            error: 3
+        };
+        this.currentLevel = this.levels[level];
+    }
+    /**
+     * Set log level
+     * @param level - Log level (debug, info, warn, error)
+     */
+    setLevel(level) {
+        this.currentLevel = this.levels[level] || this.levels.info;
+    }
+    /**
+     * Debug log
+     * @param args - Arguments to log
+     */
+    debug(...args) {
+        if (this.currentLevel <= this.levels.debug) {
+            console.debug('[DEBUG]', ...args);
+        }
+    }
+    /**
+     * Info log
+     * @param args - Arguments to log
+     */
+    info(...args) {
+        if (this.currentLevel <= this.levels.info) {
+            console.info('[INFO]', ...args);
+        }
+    }
+    /**
+     * Warning log
+     * @param args - Arguments to log
+     */
+    warn(...args) {
+        if (this.currentLevel <= this.levels.warn) {
+            console.warn('[WARN]', ...args);
+        }
+    }
+    /**
+     * Error log
+     * @param args - Arguments to log
+     */
+    error(...args) {
+        if (this.currentLevel <= this.levels.error) {
+            console.error('[ERROR]', ...args);
+        }
+    }
+}
+// Default logger instance
+export const logger = new Logger();

package/dist/utils/Metadata.js

@@ -0,0 +1,90 @@
+/**
+ * Metadata parsing utilities
+ */
+export class MetadataUtils {
+    /**
+     * Extract basic metadata from URL or file path
+     * @param source - URL or file path
+     * @returns Metadata object
+     */
+    static extract(source) {
+        if (!source)
+            return {};
+        const metadata = {
+            title: this.extractTitle(source),
+            artist: undefined,
+            duration: undefined,
+            thumbnail: undefined
+        };
+        // For YouTube URLs
+        if (source.includes('youtube.com') || source.includes('youtu.be')) {
+            return this.extractYouTubeMetadata(source);
+        }
+        // For SoundCloud URLs
+        if (source.includes('soundcloud.com')) {
+            return this.extractSoundCloudMetadata(source);
+        }
+        // For local files
+        if (!source.startsWith('http')) {
+            return this.extractFileMetadata(source);
+        }
+        return metadata;
+    }
+    /**
+     * Extract title from source
+     * @param source - Source string
+     * @returns Extracted title
+     */
+    static extractTitle(source) {
+        if (!source)
+            return 'Unknown Track';
+        // Try to extract from URL query params
+        try {
+            const url = new URL(source);
+            const title = url.searchParams.get('title') || url.searchParams.get('name');
+            if (title)
+                return decodeURIComponent(title);
+        }
+        catch { } // eslint-disable-line no-empty
+        // Extract from file path
+        const parts = source.split('/').pop()?.split('\\').pop();
+        if (parts) {
+            return parts.replace(/\.[^/.]+$/, ''); // Remove extension
+        }
+        return 'Unknown Track';
+    }
+    /**
+     * Extract YouTube metadata (basic)
+     * @param url - YouTube URL
+     * @returns Metadata
+     */
+    static extractYouTubeMetadata(url) {
+        return {
+            title: 'YouTube Track',
+            source: 'youtube'
+        };
+    }
+    /**
+     * Extract SoundCloud metadata (basic)
+     * @param url - SoundCloud URL
+     * @returns Metadata
+     */
+    static extractSoundCloudMetadata(url) {
+        return {
+            title: 'SoundCloud Track',
+            source: 'soundcloud'
+        };
+    }
+    /**
+     * Extract file metadata (basic)
+     * @param path - File path
+     * @returns Metadata
+     */
+    static extractFileMetadata(path) {
+        const title = this.extractTitle(path);
+        return {
+            title,
+            source: 'local'
+        };
+    }
+}