audio-channel-queue 1.4.0 → 1.6.0

package/dist/core.js

@@ -0,0 +1,273 @@
+"use strict";
+/**
+ * @fileoverview Core queue management functions for the audio-channel-queue package
+ */
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.stopAllAudio = exports.stopAllAudioInChannel = exports.stopCurrentAudioInChannel = exports.playAudioQueue = exports.queueAudioPriority = exports.queueAudio = void 0;
+const info_1 = require("./info");
+const utils_1 = require("./utils");
+const events_1 = require("./events");
+const volume_1 = require("./volume");
+/**
+ * Queues an audio file to a specific channel and starts playing if it's the first in queue
+ * @param audioUrl - The URL of the audio file to queue
+ * @param channelNumber - The channel number to queue the audio to (defaults to 0)
+ * @param options - Optional configuration for the audio file
+ * @returns Promise that resolves when the audio is queued and starts playing (if first in queue)
+ * @example
+ * ```typescript
+ * await queueAudio('https://example.com/song.mp3', 0);
+ * await queueAudio('./sounds/notification.wav'); // Uses default channel 0
+ * await queueAudio('./music/loop.mp3', 1, { loop: true }); // Loop the audio
+ * await queueAudio('./urgent.wav', 0, { addToFront: true }); // Add to front of queue
+ * ```
+ */
+const queueAudio = (audioUrl_1, ...args_1) => __awaiter(void 0, [audioUrl_1, ...args_1], void 0, function* (audioUrl, channelNumber = 0, options) {
+    if (!info_1.audioChannels[channelNumber]) {
+        info_1.audioChannels[channelNumber] = {
+            audioCompleteCallbacks: new Set(),
+            audioPauseCallbacks: new Set(),
+            audioResumeCallbacks: new Set(),
+            audioStartCallbacks: new Set(),
+            isPaused: false,
+            progressCallbacks: new Map(),
+            queue: [],
+            queueChangeCallbacks: new Set(),
+            volume: 1.0
+        };
+    }
+    const audio = new Audio(audioUrl);
+    // Apply audio configuration from options
+    if (options === null || options === void 0 ? void 0 : options.loop) {
+        audio.loop = true;
+    }
+    if ((options === null || options === void 0 ? void 0 : options.volume) !== undefined) {
+        const clampedVolume = Math.max(0, Math.min(1, options.volume));
+        // Handle NaN case - default to channel volume or 1.0
+        const safeVolume = isNaN(clampedVolume) ? (info_1.audioChannels[channelNumber].volume || 1.0) : clampedVolume;
+        audio.volume = safeVolume;
+        // Also update the channel volume
+        info_1.audioChannels[channelNumber].volume = safeVolume;
+    }
+    else {
+        // Use channel volume if no specific volume is set
+        const channelVolume = info_1.audioChannels[channelNumber].volume || 1.0;
+        audio.volume = channelVolume;
+    }
+    // Add to front or back of queue based on options
+    if (((options === null || options === void 0 ? void 0 : options.addToFront) || (options === null || options === void 0 ? void 0 : options.priority)) && info_1.audioChannels[channelNumber].queue.length > 0) {
+        // Insert after the currently playing audio (index 1)
+        info_1.audioChannels[channelNumber].queue.splice(1, 0, audio);
+    }
+    else if (((options === null || options === void 0 ? void 0 : options.addToFront) || (options === null || options === void 0 ? void 0 : options.priority)) && info_1.audioChannels[channelNumber].queue.length === 0) {
+        // If queue is empty, just add normally
+        info_1.audioChannels[channelNumber].queue.push(audio);
+    }
+    else {
+        // Default behavior - add to back of queue
+        info_1.audioChannels[channelNumber].queue.push(audio);
+    }
+    (0, events_1.emitQueueChange)(channelNumber, info_1.audioChannels);
+    if (info_1.audioChannels[channelNumber].queue.length === 1) {
+        // Don't await - let playback happen asynchronously
+        (0, exports.playAudioQueue)(channelNumber).catch(console.error);
+    }
+});
+exports.queueAudio = queueAudio;
+/**
+ * Adds an audio file to the front of the queue in a specific channel
+ * This is a convenience function that places the audio right after the currently playing track
+ * @param audioUrl - The URL of the audio file to queue
+ * @param channelNumber - The channel number to queue the audio to (defaults to 0)
+ * @param options - Optional configuration for the audio file
+ * @returns Promise that resolves when the audio is queued
+ * @example
+ * ```typescript
+ * await queueAudioPriority('./urgent-announcement.wav', 0);
+ * await queueAudioPriority('./priority-sound.mp3', 1, { loop: true });
+ * ```
+ */
+const queueAudioPriority = (audioUrl_1, ...args_1) => __awaiter(void 0, [audioUrl_1, ...args_1], void 0, function* (audioUrl, channelNumber = 0, options) {
+    const priorityOptions = Object.assign(Object.assign({}, options), { addToFront: true });
+    return (0, exports.queueAudio)(audioUrl, channelNumber, priorityOptions);
+});
+exports.queueAudioPriority = queueAudioPriority;
+/**
+ * Plays the audio queue for a specific channel
+ * @param channelNumber - The channel number to play
+ * @returns Promise that resolves when the current audio finishes playing
+ * @example
+ * ```typescript
+ * await playAudioQueue(0); // Play queue for channel 0
+ * ```
+ */
+const playAudioQueue = (channelNumber) => __awaiter(void 0, void 0, void 0, function* () {
+    const channel = info_1.audioChannels[channelNumber];
+    if (!channel || channel.queue.length === 0)
+        return;
+    const currentAudio = channel.queue[0];
+    // Apply channel volume if not already set
+    if (currentAudio.volume === 1.0 && channel.volume !== undefined) {
+        currentAudio.volume = channel.volume;
+    }
+    (0, events_1.setupProgressTracking)(currentAudio, channelNumber, info_1.audioChannels);
+    // Apply volume ducking when audio starts
+    yield (0, volume_1.applyVolumeDucking)(channelNumber);
+    return new Promise((resolve) => {
+        let hasStarted = false;
+        let metadataLoaded = false;
+        let playStarted = false;
+        // Check if we should fire onAudioStart (both conditions met)
+        const tryFireAudioStart = () => {
+            if (!hasStarted && metadataLoaded && playStarted) {
+                hasStarted = true;
+                (0, events_1.emitAudioStart)(channelNumber, {
+                    channelNumber,
+                    duration: currentAudio.duration * 1000, // Now guaranteed to have valid duration
+                    fileName: (0, utils_1.extractFileName)(currentAudio.src),
+                    src: currentAudio.src
+                }, info_1.audioChannels);
+            }
+        };
+        // Event handler for when metadata loads (duration becomes available)
+        const handleLoadedMetadata = () => {
+            metadataLoaded = true;
+            tryFireAudioStart();
+        };
+        // Event handler for when audio actually starts playing
+        const handlePlay = () => {
+            playStarted = true;
+            tryFireAudioStart();
+        };
+        // Event handler for when audio ends
+        const handleEnded = () => __awaiter(void 0, void 0, void 0, function* () {
+            (0, events_1.emitAudioComplete)(channelNumber, {
+                channelNumber,
+                fileName: (0, utils_1.extractFileName)(currentAudio.src),
+                remainingInQueue: channel.queue.length - 1,
+                src: currentAudio.src
+            }, info_1.audioChannels);
+            // Restore volume levels when priority channel stops
+            yield (0, volume_1.restoreVolumeLevels)(channelNumber);
+            // Clean up event listeners
+            currentAudio.removeEventListener('loadedmetadata', handleLoadedMetadata);
+            currentAudio.removeEventListener('play', handlePlay);
+            currentAudio.removeEventListener('ended', handleEnded);
+            (0, events_1.cleanupProgressTracking)(currentAudio, channelNumber, info_1.audioChannels);
+            // Handle looping vs non-looping audio
+            if (currentAudio.loop) {
+                // For looping audio, reset current time and continue playing
+                currentAudio.currentTime = 0;
+                yield currentAudio.play();
+                // Don't remove from queue, but resolve the promise so tests don't hang
+                resolve();
+            }
+            else {
+                // For non-looping audio, remove from queue and play next
+                channel.queue.shift();
+                // Emit queue change after completion
+                setTimeout(() => (0, events_1.emitQueueChange)(channelNumber, info_1.audioChannels), 10);
+                yield (0, exports.playAudioQueue)(channelNumber);
+                resolve();
+            }
+        });
+        // Add event listeners
+        currentAudio.addEventListener('loadedmetadata', handleLoadedMetadata);
+        currentAudio.addEventListener('play', handlePlay);
+        currentAudio.addEventListener('ended', handleEnded);
+        // Check if metadata is already loaded (in case it loads before we add the listener)
+        if (currentAudio.readyState >= 1) { // HAVE_METADATA or higher
+            metadataLoaded = true;
+        }
+        currentAudio.play();
+    });
+});
+exports.playAudioQueue = playAudioQueue;
+/**
+ * Stops the currently playing audio in a specific channel and plays the next audio in queue
+ * @param channelNumber - The channel number (defaults to 0)
+ * @example
+ * ```typescript
+ * await stopCurrentAudioInChannel(); // Stop current audio in default channel (0)
+ * await stopCurrentAudioInChannel(1); // Stop current audio in channel 1
+ * ```
+ */
+const stopCurrentAudioInChannel = (...args_1) => __awaiter(void 0, [...args_1], void 0, function* (channelNumber = 0) {
+    const channel = info_1.audioChannels[channelNumber];
+    if (channel && channel.queue.length > 0) {
+        const currentAudio = channel.queue[0];
+        (0, events_1.emitAudioComplete)(channelNumber, {
+            channelNumber,
+            fileName: (0, utils_1.extractFileName)(currentAudio.src),
+            remainingInQueue: channel.queue.length - 1,
+            src: currentAudio.src
+        }, info_1.audioChannels);
+        // Restore volume levels when stopping
+        yield (0, volume_1.restoreVolumeLevels)(channelNumber);
+        currentAudio.pause();
+        (0, events_1.cleanupProgressTracking)(currentAudio, channelNumber, info_1.audioChannels);
+        channel.queue.shift();
+        channel.isPaused = false; // Reset pause state
+        (0, events_1.emitQueueChange)(channelNumber, info_1.audioChannels);
+        // Start next audio without waiting for it to complete
+        (0, exports.playAudioQueue)(channelNumber).catch(console.error);
+    }
+});
+exports.stopCurrentAudioInChannel = stopCurrentAudioInChannel;
+/**
+ * Stops all audio in a specific channel and clears the entire queue
+ * @param channelNumber - The channel number (defaults to 0)
+ * @example
+ * ```typescript
+ * await stopAllAudioInChannel(); // Clear all audio in default channel (0)
+ * await stopAllAudioInChannel(1); // Clear all audio in channel 1
+ * ```
+ */
+const stopAllAudioInChannel = (...args_1) => __awaiter(void 0, [...args_1], void 0, function* (channelNumber = 0) {
+    const channel = info_1.audioChannels[channelNumber];
+    if (channel) {
+        if (channel.queue.length > 0) {
+            const currentAudio = channel.queue[0];
+            (0, events_1.emitAudioComplete)(channelNumber, {
+                channelNumber,
+                fileName: (0, utils_1.extractFileName)(currentAudio.src),
+                remainingInQueue: 0, // Will be 0 since we're clearing the queue
+                src: currentAudio.src
+            }, info_1.audioChannels);
+            // Restore volume levels when stopping
+            yield (0, volume_1.restoreVolumeLevels)(channelNumber);
+            currentAudio.pause();
+            (0, events_1.cleanupProgressTracking)(currentAudio, channelNumber, info_1.audioChannels);
+        }
+        // Clean up all progress tracking for this channel
+        channel.queue.forEach(audio => (0, events_1.cleanupProgressTracking)(audio, channelNumber, info_1.audioChannels));
+        channel.queue = [];
+        channel.isPaused = false; // Reset pause state
+        (0, events_1.emitQueueChange)(channelNumber, info_1.audioChannels);
+    }
+});
+exports.stopAllAudioInChannel = stopAllAudioInChannel;
+/**
+ * Stops all audio across all channels and clears all queues
+ * @example
+ * ```typescript
+ * await stopAllAudio(); // Emergency stop - clears everything
+ * ```
+ */
+const stopAllAudio = () => __awaiter(void 0, void 0, void 0, function* () {
+    const stopPromises = [];
+    info_1.audioChannels.forEach((_channel, index) => {
+        stopPromises.push((0, exports.stopAllAudioInChannel)(index));
+    });
+    yield Promise.all(stopPromises);
+});
+exports.stopAllAudio = stopAllAudio;

package/dist/events.d.ts

@@ -0,0 +1,81 @@
+/**
+ * @fileoverview Event handling and emission for the audio-channel-queue package
+ */
+import { AudioStartInfo, AudioCompleteInfo, ExtendedAudioQueueChannel, AudioInfo } from './types';
+/**
+ * Emits a queue change event to all registered listeners for a specific channel
+ * @param channelNumber - The channel number that experienced a queue change
+ * @param audioChannels - Array of audio channels
+ * @example
+ * ```typescript
+ * emitQueueChange(0, audioChannels); // Notifies all queue change listeners
+ * ```
+ */
+export declare const emitQueueChange: (channelNumber: number, audioChannels: ExtendedAudioQueueChannel[]) => void;
+/**
+ * Emits an audio start event to all registered listeners for a specific channel
+ * @param channelNumber - The channel number where audio started
+ * @param audioInfo - Information about the audio that started
+ * @param audioChannels - Array of audio channels
+ * @example
+ * ```typescript
+ * emitAudioStart(0, { src: 'song.mp3', fileName: 'song.mp3', duration: 180000, channelNumber: 0 }, audioChannels);
+ * ```
+ */
+export declare const emitAudioStart: (channelNumber: number, audioInfo: AudioStartInfo, audioChannels: ExtendedAudioQueueChannel[]) => void;
+/**
+ * Emits an audio complete event to all registered listeners for a specific channel
+ * @param channelNumber - The channel number where audio completed
+ * @param audioInfo - Information about the audio that completed
+ * @param audioChannels - Array of audio channels
+ * @example
+ * ```typescript
+ * emitAudioComplete(0, { src: 'song.mp3', fileName: 'song.mp3', channelNumber: 0, remainingInQueue: 2 }, audioChannels);
+ * ```
+ */
+export declare const emitAudioComplete: (channelNumber: number, audioInfo: AudioCompleteInfo, audioChannels: ExtendedAudioQueueChannel[]) => void;
+/**
+ * Emits an audio pause event to all registered listeners for a specific channel
+ * @param channelNumber - The channel number where audio was paused
+ * @param audioInfo - Information about the audio that was paused
+ * @param audioChannels - Array of audio channels
+ * @example
+ * ```typescript
+ * emitAudioPause(0, audioInfo, audioChannels);
+ * ```
+ */
+export declare const emitAudioPause: (channelNumber: number, audioInfo: AudioInfo, audioChannels: ExtendedAudioQueueChannel[]) => void;
+/**
+ * Emits an audio resume event to all registered listeners for a specific channel
+ * @param channelNumber - The channel number where audio was resumed
+ * @param audioInfo - Information about the audio that was resumed
+ * @param audioChannels - Array of audio channels
+ * @example
+ * ```typescript
+ * emitAudioResume(0, audioInfo, audioChannels);
+ * ```
+ */
+export declare const emitAudioResume: (channelNumber: number, audioInfo: AudioInfo, audioChannels: ExtendedAudioQueueChannel[]) => void;
+/**
+ * Sets up comprehensive progress tracking for an audio element
+ * @param audio - The HTML audio element to track
+ * @param channelNumber - The channel number this audio belongs to
+ * @param audioChannels - Array of audio channels
+ * @example
+ * ```typescript
+ * const audioElement = new Audio('song.mp3');
+ * setupProgressTracking(audioElement, 0, audioChannels);
+ * ```
+ */
+export declare const setupProgressTracking: (audio: HTMLAudioElement, channelNumber: number, audioChannels: ExtendedAudioQueueChannel[]) => void;
+/**
+ * Cleans up progress tracking for an audio element to prevent memory leaks
+ * @param audio - The HTML audio element to clean up
+ * @param channelNumber - The channel number this audio belongs to
+ * @param audioChannels - Array of audio channels
+ * @example
+ * ```typescript
+ * cleanupProgressTracking(audioElement, 0, audioChannels);
+ * ```
+ */
+export declare const cleanupProgressTracking: (audio: HTMLAudioElement, channelNumber: number, audioChannels: ExtendedAudioQueueChannel[]) => void;

package/dist/events.js

@@ -0,0 +1,210 @@
+"use strict";
+/**
+ * @fileoverview Event handling and emission for the audio-channel-queue package
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.cleanupProgressTracking = exports.setupProgressTracking = exports.emitAudioResume = exports.emitAudioPause = exports.emitAudioComplete = exports.emitAudioStart = exports.emitQueueChange = void 0;
+const utils_1 = require("./utils");
+/**
+ * Emits a queue change event to all registered listeners for a specific channel
+ * @param channelNumber - The channel number that experienced a queue change
+ * @param audioChannels - Array of audio channels
+ * @example
+ * ```typescript
+ * emitQueueChange(0, audioChannels); // Notifies all queue change listeners
+ * ```
+ */
+const emitQueueChange = (channelNumber, audioChannels) => {
+    const channel = audioChannels[channelNumber];
+    if (!channel || !channel.queueChangeCallbacks)
+        return;
+    const snapshot = (0, utils_1.createQueueSnapshot)(channelNumber, audioChannels);
+    if (!snapshot)
+        return;
+    channel.queueChangeCallbacks.forEach(callback => {
+        try {
+            callback(snapshot);
+        }
+        catch (error) {
+            console.error('Error in queue change callback:', error);
+        }
+    });
+};
+exports.emitQueueChange = emitQueueChange;
+/**
+ * Emits an audio start event to all registered listeners for a specific channel
+ * @param channelNumber - The channel number where audio started
+ * @param audioInfo - Information about the audio that started
+ * @param audioChannels - Array of audio channels
+ * @example
+ * ```typescript
+ * emitAudioStart(0, { src: 'song.mp3', fileName: 'song.mp3', duration: 180000, channelNumber: 0 }, audioChannels);
+ * ```
+ */
+const emitAudioStart = (channelNumber, audioInfo, audioChannels) => {
+    const channel = audioChannels[channelNumber];
+    if (!channel || !channel.audioStartCallbacks)
+        return;
+    channel.audioStartCallbacks.forEach(callback => {
+        try {
+            callback(audioInfo);
+        }
+        catch (error) {
+            console.error('Error in audio start callback:', error);
+        }
+    });
+};
+exports.emitAudioStart = emitAudioStart;
+/**
+ * Emits an audio complete event to all registered listeners for a specific channel
+ * @param channelNumber - The channel number where audio completed
+ * @param audioInfo - Information about the audio that completed
+ * @param audioChannels - Array of audio channels
+ * @example
+ * ```typescript
+ * emitAudioComplete(0, { src: 'song.mp3', fileName: 'song.mp3', channelNumber: 0, remainingInQueue: 2 }, audioChannels);
+ * ```
+ */
+const emitAudioComplete = (channelNumber, audioInfo, audioChannels) => {
+    const channel = audioChannels[channelNumber];
+    if (!channel || !channel.audioCompleteCallbacks)
+        return;
+    channel.audioCompleteCallbacks.forEach(callback => {
+        try {
+            callback(audioInfo);
+        }
+        catch (error) {
+            console.error('Error in audio complete callback:', error);
+        }
+    });
+};
+exports.emitAudioComplete = emitAudioComplete;
+/**
+ * Emits an audio pause event to all registered listeners for a specific channel
+ * @param channelNumber - The channel number where audio was paused
+ * @param audioInfo - Information about the audio that was paused
+ * @param audioChannels - Array of audio channels
+ * @example
+ * ```typescript
+ * emitAudioPause(0, audioInfo, audioChannels);
+ * ```
+ */
+const emitAudioPause = (channelNumber, audioInfo, audioChannels) => {
+    const channel = audioChannels[channelNumber];
+    if (!channel || !channel.audioPauseCallbacks)
+        return;
+    channel.audioPauseCallbacks.forEach(callback => {
+        try {
+            callback(channelNumber, audioInfo);
+        }
+        catch (error) {
+            console.error('Error in audio pause callback:', error);
+        }
+    });
+};
+exports.emitAudioPause = emitAudioPause;
+/**
+ * Emits an audio resume event to all registered listeners for a specific channel
+ * @param channelNumber - The channel number where audio was resumed
+ * @param audioInfo - Information about the audio that was resumed
+ * @param audioChannels - Array of audio channels
+ * @example
+ * ```typescript
+ * emitAudioResume(0, audioInfo, audioChannels);
+ * ```
+ */
+const emitAudioResume = (channelNumber, audioInfo, audioChannels) => {
+    const channel = audioChannels[channelNumber];
+    if (!channel || !channel.audioResumeCallbacks)
+        return;
+    channel.audioResumeCallbacks.forEach(callback => {
+        try {
+            callback(channelNumber, audioInfo);
+        }
+        catch (error) {
+            console.error('Error in audio resume callback:', error);
+        }
+    });
+};
+exports.emitAudioResume = emitAudioResume;
+// Store listener functions for cleanup
+const progressListeners = new WeakMap();
+/**
+ * Sets up comprehensive progress tracking for an audio element
+ * @param audio - The HTML audio element to track
+ * @param channelNumber - The channel number this audio belongs to
+ * @param audioChannels - Array of audio channels
+ * @example
+ * ```typescript
+ * const audioElement = new Audio('song.mp3');
+ * setupProgressTracking(audioElement, 0, audioChannels);
+ * ```
+ */
+const setupProgressTracking = (audio, channelNumber, audioChannels) => {
+    const channel = audioChannels[channelNumber];
+    if (!channel)
+        return;
+    if (!channel.progressCallbacks) {
+        channel.progressCallbacks = new Map();
+    }
+    // Don't set up tracking if already exists
+    if (progressListeners.has(audio))
+        return;
+    const updateProgress = () => {
+        var _a, _b;
+        // Get callbacks for this specific audio element AND the channel-wide callbacks
+        const audioCallbacks = ((_a = channel.progressCallbacks) === null || _a === void 0 ? void 0 : _a.get(audio)) || new Set();
+        const channelCallbacks = ((_b = channel.progressCallbacks) === null || _b === void 0 ? void 0 : _b.get(null)) || new Set();
+        // Combine both sets of callbacks
+        const allCallbacks = new Set([...audioCallbacks, ...channelCallbacks]);
+        if (allCallbacks.size === 0)
+            return;
+        const info = (0, utils_1.getAudioInfoFromElement)(audio, channelNumber, audioChannels);
+        if (info) {
+            allCallbacks.forEach((callback) => {
+                try {
+                    callback(info);
+                }
+                catch (error) {
+                    console.error('Error in progress callback:', error);
+                }
+            });
+        }
+    };
+    // Store the listener function for cleanup
+    progressListeners.set(audio, updateProgress);
+    // Set up comprehensive event listeners for progress tracking
+    audio.addEventListener('timeupdate', updateProgress);
+    audio.addEventListener('loadedmetadata', updateProgress);
+    audio.addEventListener('play', updateProgress);
+    audio.addEventListener('pause', updateProgress);
+    audio.addEventListener('ended', updateProgress);
+};
+exports.setupProgressTracking = setupProgressTracking;
+/**
+ * Cleans up progress tracking for an audio element to prevent memory leaks
+ * @param audio - The HTML audio element to clean up
+ * @param channelNumber - The channel number this audio belongs to
+ * @param audioChannels - Array of audio channels
+ * @example
+ * ```typescript
+ * cleanupProgressTracking(audioElement, 0, audioChannels);
+ * ```
+ */
+const cleanupProgressTracking = (audio, channelNumber, audioChannels) => {
+    const channel = audioChannels[channelNumber];
+    if (!channel || !channel.progressCallbacks)
+        return;
+    // Remove event listeners
+    const updateProgress = progressListeners.get(audio);
+    if (updateProgress) {
+        audio.removeEventListener('timeupdate', updateProgress);
+        audio.removeEventListener('loadedmetadata', updateProgress);
+        audio.removeEventListener('play', updateProgress);
+        audio.removeEventListener('pause', updateProgress);
+        audio.removeEventListener('ended', updateProgress);
+        progressListeners.delete(audio);
+    }
+    channel.progressCallbacks.delete(audio);
+};
+exports.cleanupProgressTracking = cleanupProgressTracking;

package/dist/index.d.ts

@@ -0,0 +1,29 @@
+/**
+ * @fileoverview Main entry point for the audio-channel-queue package
+ *
+ * A comprehensive audio queue management system with real-time progress tracking,
+ * multi-channel support, pause/resume functionality, volume control with ducking,
+ * looping capabilities, and extensive event handling.
+ *
+ * @example Basic Usage
+ * ```typescript
+ * import { queueAudio, onAudioProgress, pauseChannel } from 'audio-channel-queue';
+ *
+ * // Queue an audio file
+ * await queueAudio('song.mp3');
+ *
+ * // Track progress
+ * onAudioProgress(0, (info) => {
+ *   console.log(`Progress: ${info.progress * 100}%`);
+ * });
+ *
+ * // Pause playback
+ * await pauseChannel(0);
+ * ```
+ */
+export type { AudioCompleteCallback, AudioCompleteInfo, AudioInfo, AudioPauseCallback, AudioQueue, AudioQueueChannel, AudioQueueOptions, AudioResumeCallback, AudioStartCallback, AudioStartInfo, ExtendedAudioQueueChannel, ProgressCallback, QueueChangeCallback, QueueItem, QueueSnapshot, VolumeConfig } from './types';
+export { playAudioQueue, queueAudio, queueAudioPriority, stopAllAudio, stopAllAudioInChannel, stopCurrentAudioInChannel } from './core';
+export { getAllChannelsPauseState, isChannelPaused, pauseAllChannels, pauseChannel, resumeAllChannels, resumeChannel, togglePauseAllChannels, togglePauseChannel } from './pause';
+export { applyVolumeDucking, clearVolumeDucking, getAllChannelsVolume, getChannelVolume, restoreVolumeLevels, setAllChannelsVolume, setChannelVolume, setVolumeDucking, transitionVolume } from './volume';
+export { audioChannels, getAllChannelsInfo, getCurrentAudioInfo, getQueueSnapshot, offAudioPause, offAudioProgress, offAudioResume, offQueueChange, onAudioComplete, onAudioPause, onAudioProgress, onAudioResume, onAudioStart, onQueueChange } from './info';
+export { cleanWebpackFilename, createQueueSnapshot, extractFileName, getAudioInfoFromElement } from './utils';

package/dist/index.js

@@ -0,0 +1,77 @@
+"use strict";
+/**
+ * @fileoverview Main entry point for the audio-channel-queue package
+ *
+ * A comprehensive audio queue management system with real-time progress tracking,
+ * multi-channel support, pause/resume functionality, volume control with ducking,
+ * looping capabilities, and extensive event handling.
+ *
+ * @example Basic Usage
+ * ```typescript
+ * import { queueAudio, onAudioProgress, pauseChannel } from 'audio-channel-queue';
+ *
+ * // Queue an audio file
+ * await queueAudio('song.mp3');
+ *
+ * // Track progress
+ * onAudioProgress(0, (info) => {
+ *   console.log(`Progress: ${info.progress * 100}%`);
+ * });
+ *
+ * // Pause playback
+ * await pauseChannel(0);
+ * ```
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getAudioInfoFromElement = exports.extractFileName = exports.createQueueSnapshot = exports.cleanWebpackFilename = exports.onQueueChange = exports.onAudioStart = exports.onAudioResume = exports.onAudioProgress = exports.onAudioPause = exports.onAudioComplete = exports.offQueueChange = exports.offAudioResume = exports.offAudioProgress = exports.offAudioPause = exports.getQueueSnapshot = exports.getCurrentAudioInfo = exports.getAllChannelsInfo = exports.audioChannels = exports.transitionVolume = exports.setVolumeDucking = exports.setChannelVolume = exports.setAllChannelsVolume = exports.restoreVolumeLevels = exports.getChannelVolume = exports.getAllChannelsVolume = exports.clearVolumeDucking = exports.applyVolumeDucking = exports.togglePauseChannel = exports.togglePauseAllChannels = exports.resumeChannel = exports.resumeAllChannels = exports.pauseChannel = exports.pauseAllChannels = exports.isChannelPaused = exports.getAllChannelsPauseState = exports.stopCurrentAudioInChannel = exports.stopAllAudioInChannel = exports.stopAllAudio = exports.queueAudioPriority = exports.queueAudio = exports.playAudioQueue = void 0;
+// Export core queue management functions
+var core_1 = require("./core");
+Object.defineProperty(exports, "playAudioQueue", { enumerable: true, get: function () { return core_1.playAudioQueue; } });
+Object.defineProperty(exports, "queueAudio", { enumerable: true, get: function () { return core_1.queueAudio; } });
+Object.defineProperty(exports, "queueAudioPriority", { enumerable: true, get: function () { return core_1.queueAudioPriority; } });
+Object.defineProperty(exports, "stopAllAudio", { enumerable: true, get: function () { return core_1.stopAllAudio; } });
+Object.defineProperty(exports, "stopAllAudioInChannel", { enumerable: true, get: function () { return core_1.stopAllAudioInChannel; } });
+Object.defineProperty(exports, "stopCurrentAudioInChannel", { enumerable: true, get: function () { return core_1.stopCurrentAudioInChannel; } });
+// Export pause and resume functionality
+var pause_1 = require("./pause");
+Object.defineProperty(exports, "getAllChannelsPauseState", { enumerable: true, get: function () { return pause_1.getAllChannelsPauseState; } });
+Object.defineProperty(exports, "isChannelPaused", { enumerable: true, get: function () { return pause_1.isChannelPaused; } });
+Object.defineProperty(exports, "pauseAllChannels", { enumerable: true, get: function () { return pause_1.pauseAllChannels; } });
+Object.defineProperty(exports, "pauseChannel", { enumerable: true, get: function () { return pause_1.pauseChannel; } });
+Object.defineProperty(exports, "resumeAllChannels", { enumerable: true, get: function () { return pause_1.resumeAllChannels; } });
+Object.defineProperty(exports, "resumeChannel", { enumerable: true, get: function () { return pause_1.resumeChannel; } });
+Object.defineProperty(exports, "togglePauseAllChannels", { enumerable: true, get: function () { return pause_1.togglePauseAllChannels; } });
+Object.defineProperty(exports, "togglePauseChannel", { enumerable: true, get: function () { return pause_1.togglePauseChannel; } });
+// Export volume control functions
+var volume_1 = require("./volume");
+Object.defineProperty(exports, "applyVolumeDucking", { enumerable: true, get: function () { return volume_1.applyVolumeDucking; } });
+Object.defineProperty(exports, "clearVolumeDucking", { enumerable: true, get: function () { return volume_1.clearVolumeDucking; } });
+Object.defineProperty(exports, "getAllChannelsVolume", { enumerable: true, get: function () { return volume_1.getAllChannelsVolume; } });
+Object.defineProperty(exports, "getChannelVolume", { enumerable: true, get: function () { return volume_1.getChannelVolume; } });
+Object.defineProperty(exports, "restoreVolumeLevels", { enumerable: true, get: function () { return volume_1.restoreVolumeLevels; } });
+Object.defineProperty(exports, "setAllChannelsVolume", { enumerable: true, get: function () { return volume_1.setAllChannelsVolume; } });
+Object.defineProperty(exports, "setChannelVolume", { enumerable: true, get: function () { return volume_1.setChannelVolume; } });
+Object.defineProperty(exports, "setVolumeDucking", { enumerable: true, get: function () { return volume_1.setVolumeDucking; } });
+Object.defineProperty(exports, "transitionVolume", { enumerable: true, get: function () { return volume_1.transitionVolume; } });
+// Export audio information and progress tracking functions
+var info_1 = require("./info");
+Object.defineProperty(exports, "audioChannels", { enumerable: true, get: function () { return info_1.audioChannels; } });
+Object.defineProperty(exports, "getAllChannelsInfo", { enumerable: true, get: function () { return info_1.getAllChannelsInfo; } });
+Object.defineProperty(exports, "getCurrentAudioInfo", { enumerable: true, get: function () { return info_1.getCurrentAudioInfo; } });
+Object.defineProperty(exports, "getQueueSnapshot", { enumerable: true, get: function () { return info_1.getQueueSnapshot; } });
+Object.defineProperty(exports, "offAudioPause", { enumerable: true, get: function () { return info_1.offAudioPause; } });
+Object.defineProperty(exports, "offAudioProgress", { enumerable: true, get: function () { return info_1.offAudioProgress; } });
+Object.defineProperty(exports, "offAudioResume", { enumerable: true, get: function () { return info_1.offAudioResume; } });
+Object.defineProperty(exports, "offQueueChange", { enumerable: true, get: function () { return info_1.offQueueChange; } });
+Object.defineProperty(exports, "onAudioComplete", { enumerable: true, get: function () { return info_1.onAudioComplete; } });
+Object.defineProperty(exports, "onAudioPause", { enumerable: true, get: function () { return info_1.onAudioPause; } });
+Object.defineProperty(exports, "onAudioProgress", { enumerable: true, get: function () { return info_1.onAudioProgress; } });
+Object.defineProperty(exports, "onAudioResume", { enumerable: true, get: function () { return info_1.onAudioResume; } });
+Object.defineProperty(exports, "onAudioStart", { enumerable: true, get: function () { return info_1.onAudioStart; } });
+Object.defineProperty(exports, "onQueueChange", { enumerable: true, get: function () { return info_1.onQueueChange; } });
+// Export utility functions (for advanced usage)
+var utils_1 = require("./utils");
+Object.defineProperty(exports, "cleanWebpackFilename", { enumerable: true, get: function () { return utils_1.cleanWebpackFilename; } });
+Object.defineProperty(exports, "createQueueSnapshot", { enumerable: true, get: function () { return utils_1.createQueueSnapshot; } });
+Object.defineProperty(exports, "extractFileName", { enumerable: true, get: function () { return utils_1.extractFileName; } });
+Object.defineProperty(exports, "getAudioInfoFromElement", { enumerable: true, get: function () { return utils_1.getAudioInfoFromElement; } });