audio-channel-queue 1.4.0 → 1.6.0

package/dist/volume.js

@@ -0,0 +1,302 @@
+"use strict";
+/**
+ * @fileoverview Volume 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.restoreVolumeLevels = exports.applyVolumeDucking = exports.clearVolumeDucking = exports.setVolumeDucking = exports.setAllChannelsVolume = exports.getAllChannelsVolume = exports.getChannelVolume = exports.setChannelVolume = exports.transitionVolume = void 0;
+const info_1 = require("./info");
+// Store active volume transitions to handle interruptions
+const activeTransitions = new Map();
+/**
+ * Easing functions for smooth volume transitions
+ */
+const easingFunctions = {
+    linear: (t) => t,
+    'ease-in': (t) => t * t,
+    'ease-out': (t) => t * (2 - t),
+    'ease-in-out': (t) => t < 0.5 ? 2 * t * t : -1 + (4 - 2 * t) * t
+};
+/**
+ * Smoothly transitions volume for a specific channel over time
+ * @param channelNumber - The channel number to transition
+ * @param targetVolume - Target volume level (0-1)
+ * @param duration - Transition duration in milliseconds
+ * @param easing - Easing function type
+ * @returns Promise that resolves when transition completes
+ * @example
+ * ```typescript
+ * await transitionVolume(0, 0.2, 500, 'ease-out'); // Duck to 20% over 500ms
+ * ```
+ */
+const transitionVolume = (channelNumber_1, targetVolume_1, ...args_1) => __awaiter(void 0, [channelNumber_1, targetVolume_1, ...args_1], void 0, function* (channelNumber, targetVolume, duration = 250, easing = 'ease-out') {
+    const channel = info_1.audioChannels[channelNumber];
+    if (!channel || channel.queue.length === 0)
+        return;
+    const currentAudio = channel.queue[0];
+    const startVolume = currentAudio.volume;
+    const volumeDelta = targetVolume - startVolume;
+    // Cancel any existing transition for this channel
+    if (activeTransitions.has(channelNumber)) {
+        clearTimeout(activeTransitions.get(channelNumber));
+        activeTransitions.delete(channelNumber);
+    }
+    // If no change needed, resolve immediately
+    if (Math.abs(volumeDelta) < 0.001) {
+        channel.volume = targetVolume;
+        return Promise.resolve();
+    }
+    // Handle zero duration - instant change
+    if (duration <= 0) {
+        channel.volume = targetVolume;
+        if (channel.queue.length > 0) {
+            channel.queue[0].volume = targetVolume;
+        }
+        return Promise.resolve();
+    }
+    const startTime = performance.now();
+    const easingFn = easingFunctions[easing];
+    return new Promise((resolve) => {
+        const updateVolume = () => {
+            const elapsed = performance.now() - startTime;
+            const progress = Math.min(elapsed / duration, 1);
+            const easedProgress = easingFn(progress);
+            const currentVolume = startVolume + (volumeDelta * easedProgress);
+            const clampedVolume = Math.max(0, Math.min(1, currentVolume));
+            // Apply volume to both channel config and current audio
+            channel.volume = clampedVolume;
+            if (channel.queue.length > 0) {
+                channel.queue[0].volume = clampedVolume;
+            }
+            if (progress >= 1) {
+                // Transition complete
+                activeTransitions.delete(channelNumber);
+                resolve();
+            }
+            else {
+                // Use requestAnimationFrame in browser, setTimeout in tests
+                if (typeof requestAnimationFrame !== 'undefined') {
+                    const rafId = requestAnimationFrame(updateVolume);
+                    activeTransitions.set(channelNumber, rafId);
+                }
+                else {
+                    // In test environment, use shorter intervals
+                    const timeoutId = setTimeout(updateVolume, 1);
+                    activeTransitions.set(channelNumber, timeoutId);
+                }
+            }
+        };
+        updateVolume();
+    });
+});
+exports.transitionVolume = transitionVolume;
+/**
+ * Sets the volume for a specific channel with optional smooth transition
+ * @param channelNumber - The channel number to set volume for
+ * @param volume - Volume level (0-1)
+ * @param transitionDuration - Optional transition duration in milliseconds
+ * @param easing - Optional easing function
+ * @example
+ * ```typescript
+ * setChannelVolume(0, 0.5); // Set channel 0 to 50%
+ * setChannelVolume(0, 0.5, 300, 'ease-out'); // Smooth transition over 300ms
+ * ```
+ */
+const setChannelVolume = (channelNumber, volume, transitionDuration, easing) => __awaiter(void 0, void 0, void 0, function* () {
+    const clampedVolume = Math.max(0, Math.min(1, volume));
+    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: clampedVolume
+        };
+        return;
+    }
+    if (transitionDuration && transitionDuration > 0) {
+        // Smooth transition
+        yield (0, exports.transitionVolume)(channelNumber, clampedVolume, transitionDuration, easing);
+    }
+    else {
+        // Instant change (backward compatibility)
+        info_1.audioChannels[channelNumber].volume = clampedVolume;
+        const channel = info_1.audioChannels[channelNumber];
+        if (channel.queue.length > 0) {
+            const currentAudio = channel.queue[0];
+            currentAudio.volume = clampedVolume;
+        }
+    }
+});
+exports.setChannelVolume = setChannelVolume;
+/**
+ * Gets the current volume for a specific channel
+ * @param channelNumber - The channel number to get volume for (defaults to 0)
+ * @returns Current volume level (0-1) or 1.0 if channel doesn't exist
+ * @example
+ * ```typescript
+ * const volume = getChannelVolume(0);
+ * const defaultChannelVolume = getChannelVolume(); // Gets channel 0
+ * console.log(`Channel 0 volume: ${volume * 100}%`);
+ * ```
+ */
+const getChannelVolume = (channelNumber = 0) => {
+    const channel = info_1.audioChannels[channelNumber];
+    return (channel === null || channel === void 0 ? void 0 : channel.volume) || 1.0;
+};
+exports.getChannelVolume = getChannelVolume;
+/**
+ * Gets the volume levels for all channels
+ * @returns Array of volume levels (0-1) for each channel
+ * @example
+ * ```typescript
+ * const volumes = getAllChannelsVolume();
+ * volumes.forEach((volume, index) => {
+ *   console.log(`Channel ${index}: ${volume * 100}%`);
+ * });
+ * ```
+ */
+const getAllChannelsVolume = () => {
+    return info_1.audioChannels.map((channel) => (channel === null || channel === void 0 ? void 0 : channel.volume) || 1.0);
+};
+exports.getAllChannelsVolume = getAllChannelsVolume;
+/**
+ * Sets volume for all channels to the same level
+ * @param volume - Volume level (0-1) to apply to all channels
+ * @example
+ * ```typescript
+ * await setAllChannelsVolume(0.6); // Set all channels to 60% volume
+ * ```
+ */
+const setAllChannelsVolume = (volume) => __awaiter(void 0, void 0, void 0, function* () {
+    const promises = [];
+    info_1.audioChannels.forEach((_channel, index) => {
+        promises.push((0, exports.setChannelVolume)(index, volume));
+    });
+    yield Promise.all(promises);
+});
+exports.setAllChannelsVolume = setAllChannelsVolume;
+/**
+ * Configures volume ducking for channels. When the priority channel plays audio,
+ * all other channels will be automatically reduced to the ducking volume level
+ * @param config - Volume ducking configuration
+ * @example
+ * ```typescript
+ * // When channel 1 plays, reduce all other channels to 20% volume
+ * setVolumeDucking({
+ *   priorityChannel: 1,
+ *   priorityVolume: 1.0,
+ *   duckingVolume: 0.2
+ * });
+ * ```
+ */
+const setVolumeDucking = (config) => {
+    // First, ensure we have enough channels for the priority channel
+    while (info_1.audioChannels.length <= config.priorityChannel) {
+        info_1.audioChannels.push({
+            audioCompleteCallbacks: new Set(),
+            audioPauseCallbacks: new Set(),
+            audioResumeCallbacks: new Set(),
+            audioStartCallbacks: new Set(),
+            isPaused: false,
+            progressCallbacks: new Map(),
+            queue: [],
+            queueChangeCallbacks: new Set(),
+            volume: 1.0
+        });
+    }
+    // Apply the config to all existing channels
+    info_1.audioChannels.forEach((channel, index) => {
+        if (!info_1.audioChannels[index]) {
+            info_1.audioChannels[index] = {
+                audioCompleteCallbacks: new Set(),
+                audioPauseCallbacks: new Set(),
+                audioResumeCallbacks: new Set(),
+                audioStartCallbacks: new Set(),
+                isPaused: false,
+                progressCallbacks: new Map(),
+                queue: [],
+                queueChangeCallbacks: new Set(),
+                volume: 1.0
+            };
+        }
+        info_1.audioChannels[index].volumeConfig = config;
+    });
+};
+exports.setVolumeDucking = setVolumeDucking;
+/**
+ * Removes volume ducking configuration from all channels
+ * @example
+ * ```typescript
+ * clearVolumeDucking(); // Remove all volume ducking effects
+ * ```
+ */
+const clearVolumeDucking = () => {
+    info_1.audioChannels.forEach((channel) => {
+        if (channel) {
+            delete channel.volumeConfig;
+        }
+    });
+};
+exports.clearVolumeDucking = clearVolumeDucking;
+/**
+ * Applies volume ducking effects based on current playback state with smooth transitions
+ * @param activeChannelNumber - The channel that just started playing
+ * @internal
+ */
+const applyVolumeDucking = (activeChannelNumber) => __awaiter(void 0, void 0, void 0, function* () {
+    const transitionPromises = [];
+    info_1.audioChannels.forEach((channel, channelNumber) => {
+        if (channel === null || channel === void 0 ? void 0 : channel.volumeConfig) {
+            const config = channel.volumeConfig;
+            if (activeChannelNumber === config.priorityChannel) {
+                const duration = config.duckTransitionDuration || 250;
+                const easing = config.transitionEasing || 'ease-out';
+                // Priority channel is active, duck other channels
+                if (channelNumber === config.priorityChannel) {
+                    transitionPromises.push((0, exports.transitionVolume)(channelNumber, config.priorityVolume, duration, easing));
+                }
+                else {
+                    transitionPromises.push((0, exports.transitionVolume)(channelNumber, config.duckingVolume, duration, easing));
+                }
+            }
+        }
+    });
+    // Wait for all transitions to complete
+    yield Promise.all(transitionPromises);
+});
+exports.applyVolumeDucking = applyVolumeDucking;
+/**
+ * Restores normal volume levels when priority channel stops with smooth transitions
+ * @param stoppedChannelNumber - The channel that just stopped playing
+ * @internal
+ */
+const restoreVolumeLevels = (stoppedChannelNumber) => __awaiter(void 0, void 0, void 0, function* () {
+    const transitionPromises = [];
+    info_1.audioChannels.forEach((channel, channelNumber) => {
+        if (channel === null || channel === void 0 ? void 0 : channel.volumeConfig) {
+            const config = channel.volumeConfig;
+            if (stoppedChannelNumber === config.priorityChannel) {
+                const duration = config.restoreTransitionDuration || 500;
+                const easing = config.transitionEasing || 'ease-out';
+                // Priority channel stopped, restore normal volumes
+                transitionPromises.push((0, exports.transitionVolume)(channelNumber, channel.volume || 1.0, duration, easing));
+            }
+        }
+    });
+    // Wait for all transitions to complete
+    yield Promise.all(transitionPromises);
+});
+exports.restoreVolumeLevels = restoreVolumeLevels;

package/package.json

@@ -1,9 +1,9 @@
 {
   "name": "audio-channel-queue",
-  "version": "1.4.0",
+  "version": "1.6.0",
   "description": "Allows you to queue audio files to different playback channels.",
-  "main": "dist/audio.js",
-  "types": "dist/audio.d.ts",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
   "files": [
     "dist",
     "src"
@@ -11,7 +11,9 @@
   "scripts": {
     "build": "tsc",
     "prepare": "npm run build",
-    "test": "jest"
+    "test": "jest",
+    "test:watch": "jest --watch",
+    "test:coverage": "jest --coverage"
   },
   "repository": {
     "type": "git",
@@ -29,9 +31,13 @@
     "url": "https://github.com/tonycarpenter21/audio-queue-package/issues"
   },
   "homepage": "https://github.com/tonycarpenter21/audio-queue-package#readme",
+  "engines": {
+    "node": ">=14.0.0"
+  },
   "devDependencies": {
     "@types/jest": "^29.5.13",
     "jest": "^29.7.0",
+    "jest-environment-jsdom": "^29.7.0",
     "ts-jest": "^29.2.5",
     "typescript": "^5.6.2"
   }

package/src/core.ts

@@ -0,0 +1,306 @@
+/**
+ * @fileoverview Core queue management functions for the audio-channel-queue package
+ */
+
+import { ExtendedAudioQueueChannel, AudioQueueOptions } from './types';
+import { audioChannels } from './info';
+import { extractFileName } from './utils';
+import { 
+  emitQueueChange, 
+  emitAudioStart, 
+  emitAudioComplete, 
+  setupProgressTracking, 
+  cleanupProgressTracking 
+} from './events';
+import { applyVolumeDucking, restoreVolumeLevels } from './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
+ * ```
+ */
+export const queueAudio = async (
+  audioUrl: string, 
+  channelNumber: number = 0, 
+  options?: AudioQueueOptions
+): Promise<void> => {
+  if (!audioChannels[channelNumber]) {
+    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: HTMLAudioElement = new Audio(audioUrl);
+  
+  // Apply audio configuration from options
+  if (options?.loop) {
+    audio.loop = true;
+  }
+  
+  if (options?.volume !== undefined) {
+    const clampedVolume: number = Math.max(0, Math.min(1, options.volume));
+    // Handle NaN case - default to channel volume or 1.0
+    const safeVolume: number = isNaN(clampedVolume) ? (audioChannels[channelNumber].volume || 1.0) : clampedVolume;
+    audio.volume = safeVolume;
+    // Also update the channel volume
+    audioChannels[channelNumber].volume = safeVolume;
+  } else {
+    // Use channel volume if no specific volume is set
+    const channelVolume: number = audioChannels[channelNumber].volume || 1.0;
+    audio.volume = channelVolume;
+  }
+
+  // Add to front or back of queue based on options
+  if ((options?.addToFront || options?.priority) && audioChannels[channelNumber].queue.length > 0) {
+    // Insert after the currently playing audio (index 1)
+    audioChannels[channelNumber].queue.splice(1, 0, audio);
+  } else if ((options?.addToFront || options?.priority) && audioChannels[channelNumber].queue.length === 0) {
+    // If queue is empty, just add normally
+    audioChannels[channelNumber].queue.push(audio);
+  } else {
+    // Default behavior - add to back of queue
+    audioChannels[channelNumber].queue.push(audio);
+  }
+
+  emitQueueChange(channelNumber, audioChannels);
+
+  if (audioChannels[channelNumber].queue.length === 1) {
+    // Don't await - let playback happen asynchronously
+    playAudioQueue(channelNumber).catch(console.error);
+  }
+};
+
+/**
+ * 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 });
+ * ```
+ */
+export const queueAudioPriority = async (
+  audioUrl: string, 
+  channelNumber: number = 0, 
+  options?: AudioQueueOptions
+): Promise<void> => {
+  const priorityOptions: AudioQueueOptions = { ...options, addToFront: true };
+  return queueAudio(audioUrl, channelNumber, priorityOptions);
+};
+
+/**
+ * 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
+ * ```
+ */
+export const playAudioQueue = async (channelNumber: number): Promise<void> => {
+  const channel: ExtendedAudioQueueChannel = audioChannels[channelNumber];
+
+  if (!channel || channel.queue.length === 0) return;
+
+  const currentAudio: HTMLAudioElement = channel.queue[0];
+
+  // Apply channel volume if not already set
+  if (currentAudio.volume === 1.0 && channel.volume !== undefined) {
+    currentAudio.volume = channel.volume;
+  }
+
+  setupProgressTracking(currentAudio, channelNumber, audioChannels);
+
+  // Apply volume ducking when audio starts
+  await applyVolumeDucking(channelNumber);
+
+  return new Promise<void>((resolve) => {
+    let hasStarted: boolean = false;
+    let metadataLoaded: boolean = false;
+    let playStarted: boolean = false;
+    
+    // Check if we should fire onAudioStart (both conditions met)
+    const tryFireAudioStart = (): void => {
+      if (!hasStarted && metadataLoaded && playStarted) {
+        hasStarted = true;
+        emitAudioStart(channelNumber, {
+          channelNumber,
+          duration: currentAudio.duration * 1000, // Now guaranteed to have valid duration
+          fileName: extractFileName(currentAudio.src),
+          src: currentAudio.src
+        }, audioChannels);
+      }
+    };
+
+    // Event handler for when metadata loads (duration becomes available)
+    const handleLoadedMetadata = (): void => {
+      metadataLoaded = true;
+      tryFireAudioStart();
+    };
+
+    // Event handler for when audio actually starts playing
+    const handlePlay = (): void => {
+      playStarted = true;
+      tryFireAudioStart();
+    };
+
+    // Event handler for when audio ends
+    const handleEnded = async (): Promise<void> => {
+      emitAudioComplete(channelNumber, {
+        channelNumber,
+        fileName: extractFileName(currentAudio.src),
+        remainingInQueue: channel.queue.length - 1,
+        src: currentAudio.src
+      }, audioChannels);
+
+      // Restore volume levels when priority channel stops
+      await restoreVolumeLevels(channelNumber);
+
+      // Clean up event listeners
+      currentAudio.removeEventListener('loadedmetadata', handleLoadedMetadata);
+      currentAudio.removeEventListener('play', handlePlay);
+      currentAudio.removeEventListener('ended', handleEnded);
+      
+      cleanupProgressTracking(currentAudio, channelNumber, audioChannels);
+      
+      // Handle looping vs non-looping audio
+      if (currentAudio.loop) {
+        // For looping audio, reset current time and continue playing
+        currentAudio.currentTime = 0;
+        await 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(() => emitQueueChange(channelNumber, audioChannels), 10);
+        
+        await 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();
+  });
+};
+
+/**
+ * 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
+ * ```
+ */
+export const stopCurrentAudioInChannel = async (channelNumber: number = 0): Promise<void> => {
+  const channel: ExtendedAudioQueueChannel = audioChannels[channelNumber];
+  if (channel && channel.queue.length > 0) {
+    const currentAudio: HTMLAudioElement = channel.queue[0];
+    
+    emitAudioComplete(channelNumber, {
+      channelNumber,
+      fileName: extractFileName(currentAudio.src),
+      remainingInQueue: channel.queue.length - 1,
+      src: currentAudio.src
+    }, audioChannels);
+
+    // Restore volume levels when stopping
+    await restoreVolumeLevels(channelNumber);
+
+    currentAudio.pause();
+    cleanupProgressTracking(currentAudio, channelNumber, audioChannels);
+    channel.queue.shift();
+    channel.isPaused = false; // Reset pause state
+
+    emitQueueChange(channelNumber, audioChannels);
+    
+    // Start next audio without waiting for it to complete
+    playAudioQueue(channelNumber).catch(console.error);
+  }
+};
+
+/**
+ * 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
+ * ```
+ */
+export const stopAllAudioInChannel = async (channelNumber: number = 0): Promise<void> => {
+  const channel: ExtendedAudioQueueChannel = audioChannels[channelNumber];
+  if (channel) {
+    if (channel.queue.length > 0) {
+      const currentAudio: HTMLAudioElement = channel.queue[0];
+      
+      emitAudioComplete(channelNumber, {
+        channelNumber,
+        fileName: extractFileName(currentAudio.src),
+        remainingInQueue: 0, // Will be 0 since we're clearing the queue
+        src: currentAudio.src
+      }, audioChannels);
+
+      // Restore volume levels when stopping
+      await restoreVolumeLevels(channelNumber);
+
+      currentAudio.pause();
+      cleanupProgressTracking(currentAudio, channelNumber, audioChannels);
+    }
+    // Clean up all progress tracking for this channel
+    channel.queue.forEach(audio => cleanupProgressTracking(audio, channelNumber, audioChannels));
+    channel.queue = [];
+    channel.isPaused = false; // Reset pause state
+    
+    emitQueueChange(channelNumber, audioChannels);
+  }
+};
+
+/**
+ * Stops all audio across all channels and clears all queues
+ * @example
+ * ```typescript
+ * await stopAllAudio(); // Emergency stop - clears everything
+ * ```
+ */
+export const stopAllAudio = async (): Promise<void> => {
+  const stopPromises: Promise<void>[] = [];
+  audioChannels.forEach((_channel: ExtendedAudioQueueChannel, index: number) => {
+    stopPromises.push(stopAllAudioInChannel(index));
+  });
+  await Promise.all(stopPromises);
+};