@students-dev/audify-js 1.0.0 → 1.0.2

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'
+        };
+    }
+}

package/dist/utils/Probe.js

@@ -0,0 +1,59 @@
+/**
+ * Audio probing utilities
+ */
+export class ProbeUtils {
+    /**
+     * Probe audio file/stream for basic info
+     * @param source - Audio source
+     * @returns Probe result
+     */
+    static async probe(source) {
+        // In a real implementation, this would use ffprobe or similar
+        // For now, return basic mock data
+        return {
+            duration: null, // seconds
+            format: null, // e.g., 'mp3', 'wav'
+            bitrate: null, // kbps
+            sampleRate: null, // Hz
+            channels: null // 1 or 2
+        };
+    }
+    /**
+     * Check if source is a valid audio URL
+     * @param url - URL to check
+     * @returns Is valid audio URL
+     */
+    static isValidAudioUrl(url) {
+        if (!url || typeof url !== 'string')
+            return false;
+        try {
+            const parsed = new URL(url);
+            const audioExtensions = ['.mp3', '.wav', '.ogg', '.flac', '.aac', '.m4a'];
+            const path = parsed.pathname.toLowerCase();
+            return audioExtensions.some(ext => path.endsWith(ext)) ||
+                url.includes('youtube.com') ||
+                url.includes('youtu.be') ||
+                url.includes('soundcloud.com');
+        }
+        catch {
+            return false;
+        }
+    }
+    /**
+     * Get audio format from URL or buffer
+     * @param source - Audio source
+     * @returns Audio format
+     */
+    static getFormat(source) {
+        if (typeof source === 'string') {
+            const extensions = ['mp3', 'wav', 'ogg', 'flac', 'aac', 'm4a'];
+            for (const ext of extensions) {
+                if (source.toLowerCase().includes(`.${ext}`)) {
+                    return ext;
+                }
+            }
+        }
+        // For buffer, would need to check headers
+        return null;
+    }
+}

package/dist/utils/Time.js

@@ -0,0 +1,54 @@
+/**
+ * Time formatting utilities
+ */
+export class TimeUtils {
+    /**
+     * Format seconds to MM:SS or HH:MM:SS
+     * @param seconds - Time in seconds
+     * @returns Formatted time string
+     */
+    static format(seconds) {
+        if (!Number.isFinite(seconds) || seconds < 0)
+            return '00:00';
+        const hours = Math.floor(seconds / 3600);
+        const minutes = Math.floor((seconds % 3600) / 60);
+        const secs = Math.floor(seconds % 60);
+        if (hours > 0) {
+            return `${hours.toString().padStart(2, '0')}:${minutes.toString().padStart(2, '0')}:${secs.toString().padStart(2, '0')}`;
+        }
+        return `${minutes.toString().padStart(2, '0')}:${secs.toString().padStart(2, '0')}`;
+    }
+    /**
+     * Parse time string to seconds
+     * @param timeStr - Time string like "1:23" or "01:23:45"
+     * @returns Time in seconds
+     */
+    static parse(timeStr) {
+        if (!timeStr)
+            return 0;
+        const parts = timeStr.split(':').map(Number);
+        if (parts.length === 2) {
+            return parts[0] * 60 + parts[1];
+        }
+        else if (parts.length === 3) {
+            return parts[0] * 3600 + parts[1] * 60 + parts[2];
+        }
+        return 0;
+    }
+    /**
+     * Get current timestamp in milliseconds
+     * @returns Current time
+     */
+    static now() {
+        return Date.now();
+    }
+    /**
+     * Calculate duration between two timestamps
+     * @param start - Start time
+     * @param end - End time
+     * @returns Duration in milliseconds
+     */
+    static duration(start, end) {
+        return end - start;
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@students-dev/audify-js",
-  "version": "1.0.0",
+  "version": "1.0.2",
   "description": "Modern modular audio engine with queue, filters, plugin API, and event-driven design.",
   "type": "module",
   "main": "dist/cjs/index.js",
@@ -41,14 +41,24 @@
     "url": "https://github.com/students-dev/audify-js/issues"
   },
   "homepage": "https://github.com/students-dev/audify-js#readme",
+  "dependencies": {
+    "lavalink-client": "^2.5.1",
+    "spotify-web-api-node": "^5.0.1"
+  },
   "devDependencies": {
-    "@rollup/plugin-node-resolve": "^15.0.0",
-    "@rollup/plugin-commonjs": "^25.0.0",
-    "rollup": "^4.0.0",
-    "rollup-plugin-dts": "^6.0.0",
-    "typescript": "^5.0.0",
-    "jest": "^29.0.0",
-    "eslint": "^8.0.0"
+    "@rollup/plugin-commonjs": "^25.0.7",
+    "@rollup/plugin-node-resolve": "^15.2.3",
+    "@rollup/plugin-typescript": "^12.3.0",
+    "@types/jest": "^30.0.0",
+    "@types/node": "^25.0.3",
+    "@types/spotify-web-api-node": "^5.0.11",
+    "eslint": "^8.56.0",
+    "jest": "^29.7.0",
+    "rollup": "^4.9.6",
+    "rollup-plugin-dts": "^6.1.0",
+    "ts-jest": "^29.4.6",
+    "tslib": "^2.8.1",
+    "typescript": "^5.3.3"
   },
   "engines": {
     "node": ">=14.0.0"
@@ -57,4 +67,4 @@
     "dist",
     "README.md"
   ]
-}
+}