audio-channel-queue 1.4.0 → 1.5.0

package/dist/events.js

@@ -0,0 +1,162 @@
+"use strict";
+/**
+ * @fileoverview Event handling and emission for the audio-channel-queue package
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.cleanupProgressTracking = exports.setupProgressTracking = 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;
+// 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);
+        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,23 @@
+/**
+ * @fileoverview Main entry point for the audio-channel-queue package
+ *
+ * A comprehensive audio queue management system with real-time progress tracking,
+ * multi-channel support, and extensive event handling capabilities.
+ *
+ * @example Basic Usage
+ * ```typescript
+ * import { queueAudio, onAudioProgress } from 'audio-channel-queue';
+ *
+ * // Queue an audio file
+ * await queueAudio('song.mp3');
+ *
+ * // Track progress
+ * onAudioProgress(0, (info) => {
+ *   console.log(`Progress: ${info.progress * 100}%`);
+ * });
+ * ```
+ */
+export type { AudioCompleteCallback, AudioCompleteInfo, AudioInfo, AudioQueue, AudioQueueChannel, AudioStartCallback, AudioStartInfo, ExtendedAudioQueueChannel, ProgressCallback, QueueChangeCallback, QueueItem, QueueSnapshot } from './types';
+export { playAudioQueue, queueAudio, stopAllAudio, stopAllAudioInChannel, stopCurrentAudioInChannel } from './core';
+export { audioChannels, getAllChannelsInfo, getCurrentAudioInfo, getQueueSnapshot, offAudioProgress, onAudioComplete, onAudioProgress, onAudioStart, onQueueChange, offQueueChange } from './info';
+export { cleanWebpackFilename, createQueueSnapshot, extractFileName, getAudioInfoFromElement } from './utils';

package/dist/index.js

@@ -0,0 +1,47 @@
+"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, and extensive event handling capabilities.
+ *
+ * @example Basic Usage
+ * ```typescript
+ * import { queueAudio, onAudioProgress } from 'audio-channel-queue';
+ *
+ * // Queue an audio file
+ * await queueAudio('song.mp3');
+ *
+ * // Track progress
+ * onAudioProgress(0, (info) => {
+ *   console.log(`Progress: ${info.progress * 100}%`);
+ * });
+ * ```
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getAudioInfoFromElement = exports.extractFileName = exports.createQueueSnapshot = exports.cleanWebpackFilename = exports.offQueueChange = exports.onQueueChange = exports.onAudioStart = exports.onAudioProgress = exports.onAudioComplete = exports.offAudioProgress = exports.getQueueSnapshot = exports.getCurrentAudioInfo = exports.getAllChannelsInfo = exports.audioChannels = exports.stopCurrentAudioInChannel = exports.stopAllAudioInChannel = exports.stopAllAudio = 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, "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 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, "offAudioProgress", { enumerable: true, get: function () { return info_1.offAudioProgress; } });
+Object.defineProperty(exports, "onAudioComplete", { enumerable: true, get: function () { return info_1.onAudioComplete; } });
+Object.defineProperty(exports, "onAudioProgress", { enumerable: true, get: function () { return info_1.onAudioProgress; } });
+Object.defineProperty(exports, "onAudioStart", { enumerable: true, get: function () { return info_1.onAudioStart; } });
+Object.defineProperty(exports, "onQueueChange", { enumerable: true, get: function () { return info_1.onQueueChange; } });
+Object.defineProperty(exports, "offQueueChange", { enumerable: true, get: function () { return info_1.offQueueChange; } });
+// 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; } });

package/dist/info.d.ts

@@ -0,0 +1,122 @@
+/**
+ * @fileoverview Audio information and progress tracking functions for the audio-channel-queue package
+ */
+import { AudioInfo, QueueSnapshot, ProgressCallback, QueueChangeCallback, AudioStartCallback, AudioCompleteCallback, ExtendedAudioQueueChannel } from './types';
+/**
+ * Global array of extended audio queue channels
+ */
+export declare const audioChannels: ExtendedAudioQueueChannel[];
+/**
+ * Gets current audio information for a specific channel
+ * @param channelNumber - The channel number (defaults to 0)
+ * @returns AudioInfo object or null if no audio is playing
+ * @example
+ * ```typescript
+ * const info = getCurrentAudioInfo(0);
+ * if (info) {
+ *   console.log(`Currently playing: ${info.fileName}`);
+ *   console.log(`Progress: ${(info.progress * 100).toFixed(1)}%`);
+ * }
+ * ```
+ */
+export declare const getCurrentAudioInfo: (channelNumber?: number) => AudioInfo | null;
+/**
+ * Gets audio information for all channels
+ * @returns Array of AudioInfo objects (null for channels with no audio)
+ * @example
+ * ```typescript
+ * const allInfo = getAllChannelsInfo();
+ * allInfo.forEach((info, channel) => {
+ *   if (info) {
+ *     console.log(`Channel ${channel}: ${info.fileName}`);
+ *   }
+ * });
+ * ```
+ */
+export declare const getAllChannelsInfo: () => (AudioInfo | null)[];
+/**
+ * Gets a complete snapshot of the queue state for a specific channel
+ * @param channelNumber - The channel number
+ * @returns QueueSnapshot object or null if channel doesn't exist
+ * @example
+ * ```typescript
+ * const snapshot = getQueueSnapshot(0);
+ * if (snapshot) {
+ *   console.log(`Queue has ${snapshot.totalItems} items`);
+ *   console.log(`Currently playing: ${snapshot.items[0]?.fileName}`);
+ * }
+ * ```
+ */
+export declare const getQueueSnapshot: (channelNumber: number) => QueueSnapshot | null;
+/**
+ * Subscribes to real-time progress updates for a specific channel
+ * @param channelNumber - The channel number
+ * @param callback - Function to call with audio info updates
+ * @example
+ * ```typescript
+ * onAudioProgress(0, (info) => {
+ *   updateProgressBar(info.progress);
+ *   updateTimeDisplay(info.currentTime, info.duration);
+ * });
+ * ```
+ */
+export declare const onAudioProgress: (channelNumber: number, callback: ProgressCallback) => void;
+/**
+ * Removes progress listeners for a specific channel
+ * @param channelNumber - The channel number
+ * @example
+ * ```typescript
+ * offAudioProgress(0); // Stop receiving progress updates for channel 0
+ * ```
+ */
+export declare const offAudioProgress: (channelNumber: number) => void;
+/**
+ * Subscribes to queue change events for a specific channel
+ * @param channelNumber - The channel number to monitor
+ * @param callback - Function to call when queue changes
+ * @example
+ * ```typescript
+ * onQueueChange(0, (snapshot) => {
+ *   updateQueueDisplay(snapshot.items);
+ *   updateQueueCount(snapshot.totalItems);
+ * });
+ * ```
+ */
+export declare const onQueueChange: (channelNumber: number, callback: QueueChangeCallback) => void;
+/**
+ * Removes queue change listeners for a specific channel
+ * @param channelNumber - The channel number
+ * @example
+ * ```typescript
+ * offQueueChange(0); // Stop receiving queue change notifications for channel 0
+ * ```
+ */
+export declare const offQueueChange: (channelNumber: number) => void;
+/**
+ * Subscribes to audio start events for a specific channel
+ * @param channelNumber - The channel number to monitor
+ * @param callback - Function to call when audio starts playing
+ * @example
+ * ```typescript
+ * onAudioStart(0, (info) => {
+ *   showNowPlaying(info.fileName);
+ *   setTotalDuration(info.duration);
+ * });
+ * ```
+ */
+export declare const onAudioStart: (channelNumber: number, callback: AudioStartCallback) => void;
+/**
+ * Subscribes to audio complete events for a specific channel
+ * @param channelNumber - The channel number to monitor
+ * @param callback - Function to call when audio completes
+ * @example
+ * ```typescript
+ * onAudioComplete(0, (info) => {
+ *   logPlaybackComplete(info.fileName);
+ *   if (info.remainingInQueue === 0) {
+ *     showQueueComplete();
+ *   }
+ * });
+ * ```
+ */
+export declare const onAudioComplete: (channelNumber: number, callback: AudioCompleteCallback) => void;

package/dist/info.js

@@ -0,0 +1,240 @@
+"use strict";
+/**
+ * @fileoverview Audio information and progress tracking functions for the audio-channel-queue package
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.onAudioComplete = exports.onAudioStart = exports.offQueueChange = exports.onQueueChange = exports.offAudioProgress = exports.onAudioProgress = exports.getQueueSnapshot = exports.getAllChannelsInfo = exports.getCurrentAudioInfo = exports.audioChannels = void 0;
+const utils_1 = require("./utils");
+const events_1 = require("./events");
+/**
+ * Global array of extended audio queue channels
+ */
+exports.audioChannels = [];
+/**
+ * Gets current audio information for a specific channel
+ * @param channelNumber - The channel number (defaults to 0)
+ * @returns AudioInfo object or null if no audio is playing
+ * @example
+ * ```typescript
+ * const info = getCurrentAudioInfo(0);
+ * if (info) {
+ *   console.log(`Currently playing: ${info.fileName}`);
+ *   console.log(`Progress: ${(info.progress * 100).toFixed(1)}%`);
+ * }
+ * ```
+ */
+const getCurrentAudioInfo = (channelNumber = 0) => {
+    const channel = exports.audioChannels[channelNumber];
+    if (!channel || channel.queue.length === 0) {
+        return null;
+    }
+    const currentAudio = channel.queue[0];
+    return (0, utils_1.getAudioInfoFromElement)(currentAudio);
+};
+exports.getCurrentAudioInfo = getCurrentAudioInfo;
+/**
+ * Gets audio information for all channels
+ * @returns Array of AudioInfo objects (null for channels with no audio)
+ * @example
+ * ```typescript
+ * const allInfo = getAllChannelsInfo();
+ * allInfo.forEach((info, channel) => {
+ *   if (info) {
+ *     console.log(`Channel ${channel}: ${info.fileName}`);
+ *   }
+ * });
+ * ```
+ */
+const getAllChannelsInfo = () => {
+    const allChannelsInfo = [];
+    for (let i = 0; i < exports.audioChannels.length; i++) {
+        allChannelsInfo.push((0, exports.getCurrentAudioInfo)(i));
+    }
+    return allChannelsInfo;
+};
+exports.getAllChannelsInfo = getAllChannelsInfo;
+/**
+ * Gets a complete snapshot of the queue state for a specific channel
+ * @param channelNumber - The channel number
+ * @returns QueueSnapshot object or null if channel doesn't exist
+ * @example
+ * ```typescript
+ * const snapshot = getQueueSnapshot(0);
+ * if (snapshot) {
+ *   console.log(`Queue has ${snapshot.totalItems} items`);
+ *   console.log(`Currently playing: ${snapshot.items[0]?.fileName}`);
+ * }
+ * ```
+ */
+const getQueueSnapshot = (channelNumber) => {
+    return (0, utils_1.createQueueSnapshot)(channelNumber, exports.audioChannels);
+};
+exports.getQueueSnapshot = getQueueSnapshot;
+/**
+ * Subscribes to real-time progress updates for a specific channel
+ * @param channelNumber - The channel number
+ * @param callback - Function to call with audio info updates
+ * @example
+ * ```typescript
+ * onAudioProgress(0, (info) => {
+ *   updateProgressBar(info.progress);
+ *   updateTimeDisplay(info.currentTime, info.duration);
+ * });
+ * ```
+ */
+const onAudioProgress = (channelNumber, callback) => {
+    if (!exports.audioChannels[channelNumber]) {
+        exports.audioChannels[channelNumber] = {
+            audioCompleteCallbacks: new Set(),
+            audioStartCallbacks: new Set(),
+            progressCallbacks: new Map(),
+            queue: [],
+            queueChangeCallbacks: new Set()
+        };
+    }
+    const channel = exports.audioChannels[channelNumber];
+    if (!channel.progressCallbacks) {
+        channel.progressCallbacks = new Map();
+    }
+    // Add callback for current audio if exists
+    if (channel.queue.length > 0) {
+        const currentAudio = channel.queue[0];
+        if (!channel.progressCallbacks.has(currentAudio)) {
+            channel.progressCallbacks.set(currentAudio, new Set());
+        }
+        channel.progressCallbacks.get(currentAudio).add(callback);
+        // Set up tracking if not already done
+        (0, events_1.setupProgressTracking)(currentAudio, channelNumber, exports.audioChannels);
+    }
+    // Store callback for future audio elements in this channel
+    if (!channel.progressCallbacks.has(null)) {
+        channel.progressCallbacks.set(null, new Set());
+    }
+    channel.progressCallbacks.get(null).add(callback);
+};
+exports.onAudioProgress = onAudioProgress;
+/**
+ * Removes progress listeners for a specific channel
+ * @param channelNumber - The channel number
+ * @example
+ * ```typescript
+ * offAudioProgress(0); // Stop receiving progress updates for channel 0
+ * ```
+ */
+const offAudioProgress = (channelNumber) => {
+    const channel = exports.audioChannels[channelNumber];
+    if (!channel || !channel.progressCallbacks)
+        return;
+    // Clean up event listeners for current audio if exists
+    if (channel.queue.length > 0) {
+        const currentAudio = channel.queue[0];
+        (0, events_1.cleanupProgressTracking)(currentAudio, channelNumber, exports.audioChannels);
+    }
+    // Clear all callbacks for this channel
+    channel.progressCallbacks.clear();
+};
+exports.offAudioProgress = offAudioProgress;
+/**
+ * Subscribes to queue change events for a specific channel
+ * @param channelNumber - The channel number to monitor
+ * @param callback - Function to call when queue changes
+ * @example
+ * ```typescript
+ * onQueueChange(0, (snapshot) => {
+ *   updateQueueDisplay(snapshot.items);
+ *   updateQueueCount(snapshot.totalItems);
+ * });
+ * ```
+ */
+const onQueueChange = (channelNumber, callback) => {
+    if (!exports.audioChannels[channelNumber]) {
+        exports.audioChannels[channelNumber] = {
+            audioCompleteCallbacks: new Set(),
+            audioStartCallbacks: new Set(),
+            progressCallbacks: new Map(),
+            queue: [],
+            queueChangeCallbacks: new Set()
+        };
+    }
+    const channel = exports.audioChannels[channelNumber];
+    if (!channel.queueChangeCallbacks) {
+        channel.queueChangeCallbacks = new Set();
+    }
+    channel.queueChangeCallbacks.add(callback);
+};
+exports.onQueueChange = onQueueChange;
+/**
+ * Removes queue change listeners for a specific channel
+ * @param channelNumber - The channel number
+ * @example
+ * ```typescript
+ * offQueueChange(0); // Stop receiving queue change notifications for channel 0
+ * ```
+ */
+const offQueueChange = (channelNumber) => {
+    const channel = exports.audioChannels[channelNumber];
+    if (!channel || !channel.queueChangeCallbacks)
+        return;
+    channel.queueChangeCallbacks.clear();
+};
+exports.offQueueChange = offQueueChange;
+/**
+ * Subscribes to audio start events for a specific channel
+ * @param channelNumber - The channel number to monitor
+ * @param callback - Function to call when audio starts playing
+ * @example
+ * ```typescript
+ * onAudioStart(0, (info) => {
+ *   showNowPlaying(info.fileName);
+ *   setTotalDuration(info.duration);
+ * });
+ * ```
+ */
+const onAudioStart = (channelNumber, callback) => {
+    if (!exports.audioChannels[channelNumber]) {
+        exports.audioChannels[channelNumber] = {
+            audioCompleteCallbacks: new Set(),
+            audioStartCallbacks: new Set(),
+            progressCallbacks: new Map(),
+            queue: [],
+            queueChangeCallbacks: new Set()
+        };
+    }
+    const channel = exports.audioChannels[channelNumber];
+    if (!channel.audioStartCallbacks) {
+        channel.audioStartCallbacks = new Set();
+    }
+    channel.audioStartCallbacks.add(callback);
+};
+exports.onAudioStart = onAudioStart;
+/**
+ * Subscribes to audio complete events for a specific channel
+ * @param channelNumber - The channel number to monitor
+ * @param callback - Function to call when audio completes
+ * @example
+ * ```typescript
+ * onAudioComplete(0, (info) => {
+ *   logPlaybackComplete(info.fileName);
+ *   if (info.remainingInQueue === 0) {
+ *     showQueueComplete();
+ *   }
+ * });
+ * ```
+ */
+const onAudioComplete = (channelNumber, callback) => {
+    if (!exports.audioChannels[channelNumber]) {
+        exports.audioChannels[channelNumber] = {
+            audioCompleteCallbacks: new Set(),
+            audioStartCallbacks: new Set(),
+            progressCallbacks: new Map(),
+            queue: [],
+            queueChangeCallbacks: new Set()
+        };
+    }
+    const channel = exports.audioChannels[channelNumber];
+    if (!channel.audioCompleteCallbacks) {
+        channel.audioCompleteCallbacks = new Set();
+    }
+    channel.audioCompleteCallbacks.add(callback);
+};
+exports.onAudioComplete = onAudioComplete;