audio-channel-queue 1.8.0 → 1.10.0

package/src/events.ts

@@ -2,13 +2,14 @@
  * @fileoverview Event handling and emission for the audio-channel-queue package
  */
 
-import { 
-  AudioStartInfo, 
-  AudioCompleteInfo, 
+import {
+  AudioStartInfo,
+  AudioCompleteInfo,
   ExtendedAudioQueueChannel,
   QueueSnapshot,
   ProgressCallback,
   AudioInfo,
+  GLOBAL_PROGRESS_KEY
 } from './types';
 import { createQueueSnapshot, getAudioInfoFromElement } from './utils';
 
@@ -22,19 +23,20 @@ import { createQueueSnapshot, getAudioInfoFromElement } from './utils';
  * ```
  */
 export const emitQueueChange = (
-  channelNumber: number, 
+  channelNumber: number,
   audioChannels: ExtendedAudioQueueChannel[]
 ): void => {
   const channel: ExtendedAudioQueueChannel = audioChannels[channelNumber];
-  if (!channel || !channel.queueChangeCallbacks) return;
+  if (!channel?.queueChangeCallbacks) return;
 
   const snapshot: QueueSnapshot | null = createQueueSnapshot(channelNumber, audioChannels);
   if (!snapshot) return;
 
-  channel.queueChangeCallbacks.forEach(callback => {
+  channel.queueChangeCallbacks.forEach((callback) => {
     try {
       callback(snapshot);
     } catch (error) {
+      // eslint-disable-next-line no-console
       console.error('Error in queue change callback:', error);
     }
   });
@@ -51,17 +53,18 @@ export const emitQueueChange = (
  * ```
  */
 export const emitAudioStart = (
-  channelNumber: number, 
+  channelNumber: number,
   audioInfo: AudioStartInfo,
   audioChannels: ExtendedAudioQueueChannel[]
 ): void => {
   const channel: ExtendedAudioQueueChannel = audioChannels[channelNumber];
-  if (!channel || !channel.audioStartCallbacks) return;
+  if (!channel?.audioStartCallbacks) return;
 
-  channel.audioStartCallbacks.forEach(callback => {
+  channel.audioStartCallbacks.forEach((callback) => {
     try {
       callback(audioInfo);
     } catch (error) {
+      // eslint-disable-next-line no-console
       console.error('Error in audio start callback:', error);
     }
   });
@@ -78,17 +81,18 @@ export const emitAudioStart = (
  * ```
  */
 export const emitAudioComplete = (
-  channelNumber: number, 
+  channelNumber: number,
   audioInfo: AudioCompleteInfo,
   audioChannels: ExtendedAudioQueueChannel[]
 ): void => {
   const channel: ExtendedAudioQueueChannel = audioChannels[channelNumber];
-  if (!channel || !channel.audioCompleteCallbacks) return;
+  if (!channel?.audioCompleteCallbacks) return;
 
-  channel.audioCompleteCallbacks.forEach(callback => {
+  channel.audioCompleteCallbacks.forEach((callback) => {
     try {
       callback(audioInfo);
     } catch (error) {
+      // eslint-disable-next-line no-console
       console.error('Error in audio complete callback:', error);
     }
   });
@@ -105,17 +109,18 @@ export const emitAudioComplete = (
  * ```
  */
 export const emitAudioPause = (
-  channelNumber: number, 
+  channelNumber: number,
   audioInfo: AudioInfo,
   audioChannels: ExtendedAudioQueueChannel[]
 ): void => {
   const channel: ExtendedAudioQueueChannel = audioChannels[channelNumber];
-  if (!channel || !channel.audioPauseCallbacks) return;
+  if (!channel?.audioPauseCallbacks) return;
 
-  channel.audioPauseCallbacks.forEach(callback => {
+  channel.audioPauseCallbacks.forEach((callback) => {
     try {
       callback(channelNumber, audioInfo);
     } catch (error) {
+      // eslint-disable-next-line no-console
       console.error('Error in audio pause callback:', error);
     }
   });
@@ -132,24 +137,25 @@ export const emitAudioPause = (
  * ```
  */
 export const emitAudioResume = (
-  channelNumber: number, 
+  channelNumber: number,
   audioInfo: AudioInfo,
   audioChannels: ExtendedAudioQueueChannel[]
 ): void => {
   const channel: ExtendedAudioQueueChannel = audioChannels[channelNumber];
-  if (!channel || !channel.audioResumeCallbacks) return;
+  if (!channel?.audioResumeCallbacks) return;
 
-  channel.audioResumeCallbacks.forEach(callback => {
+  channel.audioResumeCallbacks.forEach((callback) => {
     try {
       callback(channelNumber, audioInfo);
     } catch (error) {
+      // eslint-disable-next-line no-console
       console.error('Error in audio resume callback:', error);
     }
   });
 };
 
 // Store listener functions for cleanup
-const progressListeners = new WeakMap<HTMLAudioElement, () => void>();
+const progressListeners: WeakMap<HTMLAudioElement, () => void> = new WeakMap();
 
 /**
  * Sets up comprehensive progress tracking for an audio element
@@ -163,7 +169,7 @@ const progressListeners = new WeakMap<HTMLAudioElement, () => void>();
  * ```
  */
 export const setupProgressTracking = (
-  audio: HTMLAudioElement, 
+  audio: HTMLAudioElement,
   channelNumber: number,
   audioChannels: ExtendedAudioQueueChannel[]
 ): void => {
@@ -179,12 +185,14 @@ export const setupProgressTracking = (
 
   const updateProgress = (): void => {
     // Get callbacks for this specific audio element AND the channel-wide callbacks
-    const audioCallbacks: Set<ProgressCallback> = channel.progressCallbacks?.get(audio) || new Set();
-    const channelCallbacks: Set<ProgressCallback> = channel.progressCallbacks?.get(null as any) || new Set();
-    
+    const audioCallbacks: Set<ProgressCallback> =
+      channel.progressCallbacks?.get(audio) ?? new Set();
+    const channelCallbacks: Set<ProgressCallback> =
+      channel.progressCallbacks?.get(GLOBAL_PROGRESS_KEY) ?? new Set();
+
     // Combine both sets of callbacks
     const allCallbacks: Set<ProgressCallback> = new Set([...audioCallbacks, ...channelCallbacks]);
-    
+
     if (allCallbacks.size === 0) return;
 
     const info: AudioInfo | null = getAudioInfoFromElement(audio, channelNumber, audioChannels);
@@ -193,6 +201,7 @@ export const setupProgressTracking = (
         try {
           callback(info);
         } catch (error) {
+          // eslint-disable-next-line no-console
           console.error('Error in progress callback:', error);
         }
       });
@@ -221,12 +230,12 @@ export const setupProgressTracking = (
  * ```
  */
 export const cleanupProgressTracking = (
-  audio: HTMLAudioElement, 
+  audio: HTMLAudioElement,
   channelNumber: number,
   audioChannels: ExtendedAudioQueueChannel[]
 ): void => {
   const channel: ExtendedAudioQueueChannel = audioChannels[channelNumber];
-  if (!channel || !channel.progressCallbacks) return;
+  if (!channel?.progressCallbacks) return;
 
   // Remove event listeners
   const updateProgress: (() => void) | undefined = progressListeners.get(audio);
@@ -240,4 +249,4 @@ export const cleanupProgressTracking = (
   }
 
   channel.progressCallbacks.delete(audio);
-}; 
+};

package/src/index.ts

@@ -5,65 +5,89 @@
  */
 
 // Core queue management functions
-export { queueAudio, queueAudioPriority, stopCurrentAudioInChannel, stopAllAudioInChannel, stopAllAudio, playAudioQueue } from './core';
+export {
+  queueAudio,
+  queueAudioPriority,
+  stopCurrentAudioInChannel,
+  stopAllAudioInChannel,
+  stopAllAudio,
+  playAudioQueue,
+  destroyChannel,
+  destroyAllChannels,
+  setQueueConfig,
+  getQueueConfig,
+  setChannelQueueLimit
+} from './core';
+
+// Queue manipulation functions
+export {
+  clearQueueAfterCurrent,
+  getQueueItemInfo,
+  getQueueLength,
+  removeQueuedItem,
+  reorderQueue,
+  swapQueueItems
+} from './queue-manipulation';
 
 // Error handling and recovery functions
-export { 
-  getErrorRecovery, 
-  getRetryConfig, 
-  offAudioError, 
-  onAudioError, 
+export {
+  getErrorRecovery,
+  getRetryConfig,
+  offAudioError,
+  onAudioError,
   retryFailedAudio,
-  setErrorRecovery, 
-  setRetryConfig, 
+  setErrorRecovery,
+  setRetryConfig
 } from './errors';
 
 // Pause and resume management functions
-export { 
-  getAllChannelsPauseState, 
-  isChannelPaused, 
-  pauseAllChannels, 
+export {
+  getAllChannelsPauseState,
+  isChannelPaused,
+  pauseAllChannels,
   pauseAllWithFade,
-  pauseChannel, 
+  pauseChannel,
   pauseWithFade,
-  resumeAllChannels, 
+  resumeAllChannels,
   resumeAllWithFade,
-  resumeChannel, 
+  resumeChannel,
   resumeWithFade,
   togglePauseAllChannels,
   togglePauseAllWithFade,
   togglePauseChannel,
-  togglePauseWithFade,
+  togglePauseWithFade
 } from './pause';
 
 // Volume control and ducking functions
-export { 
+export {
   clearVolumeDucking,
   fadeVolume,
-  getAllChannelsVolume, 
-  getChannelVolume, 
+  getAllChannelsVolume,
+  getChannelVolume,
   getFadeConfig,
-  setAllChannelsVolume, 
-  setChannelVolume, 
+  setAllChannelsVolume,
+  setChannelVolume,
   setVolumeDucking,
   transitionVolume,
+  cancelVolumeTransition,
+  cancelAllVolumeTransitions
 } from './volume';
 
 // Audio information and progress tracking functions
-export { 
-  getAllChannelsInfo, 
-  getCurrentAudioInfo, 
-  getQueueSnapshot, 
-  offAudioPause, 
-  offAudioProgress, 
+export {
+  getAllChannelsInfo,
+  getCurrentAudioInfo,
+  getQueueSnapshot,
+  offAudioPause,
+  offAudioProgress,
   offAudioResume,
-  offQueueChange, 
-  onAudioComplete, 
-  onAudioPause, 
-  onAudioProgress, 
-  onAudioResume, 
-  onAudioStart, 
-  onQueueChange, 
+  offQueueChange,
+  onAudioComplete,
+  onAudioPause,
+  onAudioProgress,
+  onAudioResume,
+  onAudioStart,
+  onQueueChange
 } from './info';
 
 // Core data access for legacy compatibility
@@ -74,16 +98,18 @@ export {
   cleanWebpackFilename,
   createQueueSnapshot,
   extractFileName,
-  getAudioInfoFromElement
+  getAudioInfoFromElement,
+  sanitizeForDisplay,
+  validateAudioUrl
 } from './utils';
 
 // TypeScript type definitions and interfaces
-export type { 
+export type {
   AudioCompleteCallback,
   AudioCompleteInfo,
   AudioErrorCallback,
   AudioErrorInfo,
-  AudioInfo, 
+  AudioInfo,
   AudioPauseCallback,
   AudioQueueOptions,
   AudioResumeCallback,
@@ -96,13 +122,12 @@ export type {
   ProgressCallback,
   QueueChangeCallback,
   QueueItem,
+  QueueManipulationResult,
   QueueSnapshot,
   RetryConfig,
-  VolumeConfig 
+  VolumeConfig,
+  QueueConfig
 } from './types';
 
-// Enums
-export { 
-  EasingType,
-  FadeType 
-} from './types'; 
+// Enums and constants
+export { EasingType, FadeType, MAX_CHANNELS, TimerType, GLOBAL_PROGRESS_KEY } from './types';

package/src/info.ts

@@ -2,16 +2,18 @@
  * @fileoverview Audio information and progress tracking functions for the audio-channel-queue package
  */
 
-import { 
-  AudioInfo, 
-  QueueSnapshot, 
+import {
+  AudioInfo,
+  QueueSnapshot,
   ProgressCallback,
   QueueChangeCallback,
   AudioStartCallback,
   AudioCompleteCallback,
   AudioPauseCallback,
   AudioResumeCallback,
-  ExtendedAudioQueueChannel
+  ExtendedAudioQueueChannel,
+  GLOBAL_PROGRESS_KEY,
+  MAX_CHANNELS
 } from './types';
 import { getAudioInfoFromElement, createQueueSnapshot } from './utils';
 import { setupProgressTracking, cleanupProgressTracking } from './events';
@@ -19,8 +21,85 @@ import { setupProgressTracking, cleanupProgressTracking } from './events';
 /**
  * Global array to store audio channels with their queues and callback management
  * Each channel maintains its own audio queue and event callback sets
+ *
+ * Note: While you can inspect this array for debugging, direct modification is discouraged.
+ * Use the provided API functions for safe channel management.
  */
-export const audioChannels: ExtendedAudioQueueChannel[] = [];
+export const audioChannels: ExtendedAudioQueueChannel[] = new Proxy(
+  [] as ExtendedAudioQueueChannel[],
+  {
+    deleteProperty(target: ExtendedAudioQueueChannel[], prop: string | symbol): boolean {
+      if (typeof prop === 'string' && !isNaN(Number(prop))) {
+        // eslint-disable-next-line no-console
+        console.warn(
+          'Warning: Direct deletion from audioChannels detected. ' +
+            'Consider using stopAllAudioInChannel() for proper cleanup.'
+        );
+      }
+      delete (target as unknown as Record<string, unknown>)[prop as string];
+      return true;
+    },
+    get(target: ExtendedAudioQueueChannel[], prop: string | symbol): unknown {
+      const value = (target as unknown as Record<string, unknown>)[prop as string];
+
+      // Return channel objects with warnings on modification attempts
+      if (
+        typeof value === 'object' &&
+        value !== null &&
+        typeof prop === 'string' &&
+        !isNaN(Number(prop))
+      ) {
+        return new Proxy(value as ExtendedAudioQueueChannel, {
+          set(
+            channelTarget: ExtendedAudioQueueChannel,
+            channelProp: string | symbol,
+            channelValue: unknown
+          ): boolean {
+            // Allow internal modifications but warn about direct property changes
+            if (
+              typeof channelProp === 'string' &&
+              !['queue', 'volume', 'isPaused', 'isLocked', 'volumeConfig'].includes(channelProp)
+            ) {
+              // eslint-disable-next-line no-console
+              console.warn(
+                `Warning: Direct modification of channel.${channelProp} detected. ` +
+                  'Use API functions for safer channel management.'
+              );
+            }
+            const key = typeof channelProp === 'symbol' ? channelProp.toString() : channelProp;
+            (channelTarget as unknown as Record<string, unknown>)[key] = channelValue;
+            return true;
+          }
+        });
+      }
+
+      return value;
+    },
+    set(target: ExtendedAudioQueueChannel[], prop: string | symbol, value: unknown): boolean {
+      // Allow normal array operations
+      const key = typeof prop === 'symbol' ? prop.toString() : prop;
+      (target as unknown as Record<string, unknown>)[key] = value;
+      return true;
+    }
+  }
+);
+
+/**
+ * Validates a channel number against MAX_CHANNELS limit
+ * @param channelNumber - The channel number to validate
+ * @throws Error if the channel number is invalid
+ * @internal
+ */
+const validateChannelNumber = (channelNumber: number): void => {
+  if (channelNumber < 0) {
+    throw new Error('Channel number must be non-negative');
+  }
+  if (channelNumber >= MAX_CHANNELS) {
+    throw new Error(
+      `Channel number ${channelNumber} exceeds maximum allowed channels (${MAX_CHANNELS})`
+    );
+  }
+};
 
 /**
  * Gets current audio information for a specific channel
@@ -60,28 +139,29 @@ export const getCurrentAudioInfo = (channelNumber: number = 0): AudioInfo | null
  */
 export const getAllChannelsInfo = (): (AudioInfo | null)[] => {
   const allChannelsInfo: (AudioInfo | null)[] = [];
-  
-  for (let i = 0; i < audioChannels.length; i++) {
+
+  for (let i: number = 0; i < audioChannels.length; i++) {
     allChannelsInfo.push(getCurrentAudioInfo(i));
   }
-  
+
   return allChannelsInfo;
 };
 
 /**
  * Gets a complete snapshot of the queue state for a specific channel
- * @param channelNumber - The channel number
+ * @param channelNumber - The channel number (defaults to 0)
  * @returns QueueSnapshot object or null if channel doesn't exist
  * @example
  * ```typescript
- * const snapshot = getQueueSnapshot(0);
+ * const snapshot = getQueueSnapshot();
  * if (snapshot) {
  *   console.log(`Queue has ${snapshot.totalItems} items`);
  *   console.log(`Currently playing: ${snapshot.items[0]?.fileName}`);
  * }
+ * const channelSnapshot = getQueueSnapshot(2);
  * ```
  */
-export const getQueueSnapshot = (channelNumber: number): QueueSnapshot | null => {
+export const getQueueSnapshot = (channelNumber: number = 0): QueueSnapshot | null => {
   return createQueueSnapshot(channelNumber, audioChannels);
 };
 
@@ -89,6 +169,7 @@ export 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
+ * @throws Error if the channel number exceeds the maximum allowed channels
  * @example
  * ```typescript
  * onAudioProgress(0, (info) => {
@@ -98,8 +179,10 @@ export const getQueueSnapshot = (channelNumber: number): QueueSnapshot | null =>
  * ```
  */
 export const onAudioProgress = (channelNumber: number, callback: ProgressCallback): void => {
+  validateChannelNumber(channelNumber);
+
   if (!audioChannels[channelNumber]) {
-    audioChannels[channelNumber] = { 
+    audioChannels[channelNumber] = {
       audioCompleteCallbacks: new Set(),
       audioErrorCallbacks: new Set(),
       audioPauseCallbacks: new Set(),
@@ -125,29 +208,30 @@ export const onAudioProgress = (channelNumber: number, callback: ProgressCallbac
       channel.progressCallbacks.set(currentAudio, new Set());
     }
     channel.progressCallbacks.get(currentAudio)!.add(callback);
-    
+
     // Set up tracking if not already done
     setupProgressTracking(currentAudio, channelNumber, audioChannels);
   }
 
   // Store callback for future audio elements in this channel
-  if (!channel.progressCallbacks.has(null as any)) {
-    channel.progressCallbacks.set(null as any, new Set());
+  if (!channel.progressCallbacks.has(GLOBAL_PROGRESS_KEY)) {
+    channel.progressCallbacks.set(GLOBAL_PROGRESS_KEY, new Set());
   }
-  channel.progressCallbacks.get(null as any)!.add(callback);
+  channel.progressCallbacks.get(GLOBAL_PROGRESS_KEY)!.add(callback);
 };
 
 /**
  * Removes progress listeners for a specific channel
- * @param channelNumber - The channel number
+ * @param channelNumber - The channel number (defaults to 0)
  * @example
  * ```typescript
- * offAudioProgress(0); // Stop receiving progress updates for channel 0
+ * offAudioProgress();
+ * offAudioProgress(1); // Stop receiving progress updates for channel 1
  * ```
  */
-export const offAudioProgress = (channelNumber: number): void => {
+export function offAudioProgress(channelNumber: number = 0): void {
   const channel: ExtendedAudioQueueChannel = audioChannels[channelNumber];
-  if (!channel || !channel.progressCallbacks) return;
+  if (!channel?.progressCallbacks) return;
 
   // Clean up event listeners for current audio if exists
   if (channel.queue.length > 0) {
@@ -157,12 +241,13 @@ export const offAudioProgress = (channelNumber: number): void => {
 
   // Clear all callbacks for this channel
   channel.progressCallbacks.clear();
-};
+}
 
 /**
  * Subscribes to queue change events for a specific channel
  * @param channelNumber - The channel number to monitor
  * @param callback - Function to call when queue changes
+ * @throws Error if the channel number exceeds the maximum allowed channels
  * @example
  * ```typescript
  * onQueueChange(0, (snapshot) => {
@@ -172,8 +257,10 @@ export const offAudioProgress = (channelNumber: number): void => {
  * ```
  */
 export const onQueueChange = (channelNumber: number, callback: QueueChangeCallback): void => {
+  validateChannelNumber(channelNumber);
+
   if (!audioChannels[channelNumber]) {
-    audioChannels[channelNumber] = { 
+    audioChannels[channelNumber] = {
       audioCompleteCallbacks: new Set(),
       audioErrorCallbacks: new Set(),
       audioPauseCallbacks: new Set(),
@@ -205,7 +292,7 @@ export const onQueueChange = (channelNumber: number, callback: QueueChangeCallba
  */
 export const offQueueChange = (channelNumber: number): void => {
   const channel: ExtendedAudioQueueChannel = audioChannels[channelNumber];
-  if (!channel || !channel.queueChangeCallbacks) return;
+  if (!channel?.queueChangeCallbacks) return;
 
   channel.queueChangeCallbacks.clear();
 };
@@ -214,6 +301,7 @@ export 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
+ * @throws Error if the channel number exceeds the maximum allowed channels
  * @example
  * ```typescript
  * onAudioStart(0, (info) => {
@@ -223,8 +311,10 @@ export const offQueueChange = (channelNumber: number): void => {
  * ```
  */
 export const onAudioStart = (channelNumber: number, callback: AudioStartCallback): void => {
+  validateChannelNumber(channelNumber);
+
   if (!audioChannels[channelNumber]) {
-    audioChannels[channelNumber] = { 
+    audioChannels[channelNumber] = {
       audioCompleteCallbacks: new Set(),
       audioErrorCallbacks: new Set(),
       audioPauseCallbacks: new Set(),
@@ -250,6 +340,7 @@ export const onAudioStart = (channelNumber: number, callback: AudioStartCallback
  * Subscribes to audio complete events for a specific channel
  * @param channelNumber - The channel number to monitor
  * @param callback - Function to call when audio completes
+ * @throws Error if the channel number exceeds the maximum allowed channels
  * @example
  * ```typescript
  * onAudioComplete(0, (info) => {
@@ -261,8 +352,10 @@ export const onAudioStart = (channelNumber: number, callback: AudioStartCallback
  * ```
  */
 export const onAudioComplete = (channelNumber: number, callback: AudioCompleteCallback): void => {
+  validateChannelNumber(channelNumber);
+
   if (!audioChannels[channelNumber]) {
-    audioChannels[channelNumber] = { 
+    audioChannels[channelNumber] = {
       audioCompleteCallbacks: new Set(),
       audioErrorCallbacks: new Set(),
       audioPauseCallbacks: new Set(),
@@ -288,6 +381,7 @@ export const onAudioComplete = (channelNumber: number, callback: AudioCompleteCa
  * Subscribes to audio pause events for a specific channel
  * @param channelNumber - The channel number to monitor
  * @param callback - Function to call when audio is paused
+ * @throws Error if the channel number exceeds the maximum allowed channels
  * @example
  * ```typescript
  * onAudioPause(0, (channelNumber, info) => {
@@ -297,8 +391,10 @@ export const onAudioComplete = (channelNumber: number, callback: AudioCompleteCa
  * ```
  */
 export const onAudioPause = (channelNumber: number, callback: AudioPauseCallback): void => {
+  validateChannelNumber(channelNumber);
+
   if (!audioChannels[channelNumber]) {
-    audioChannels[channelNumber] = { 
+    audioChannels[channelNumber] = {
       audioCompleteCallbacks: new Set(),
       audioErrorCallbacks: new Set(),
       audioPauseCallbacks: new Set(),
@@ -324,6 +420,7 @@ export const onAudioPause = (channelNumber: number, callback: AudioPauseCallback
  * Subscribes to audio resume events for a specific channel
  * @param channelNumber - The channel number to monitor
  * @param callback - Function to call when audio is resumed
+ * @throws Error if the channel number exceeds the maximum allowed channels
  * @example
  * ```typescript
  * onAudioResume(0, (channelNumber, info) => {
@@ -333,8 +430,10 @@ export const onAudioPause = (channelNumber: number, callback: AudioPauseCallback
  * ```
  */
 export const onAudioResume = (channelNumber: number, callback: AudioResumeCallback): void => {
+  validateChannelNumber(channelNumber);
+
   if (!audioChannels[channelNumber]) {
-    audioChannels[channelNumber] = { 
+    audioChannels[channelNumber] = {
       audioCompleteCallbacks: new Set(),
       audioErrorCallbacks: new Set(),
       audioPauseCallbacks: new Set(),
@@ -366,7 +465,7 @@ export const onAudioResume = (channelNumber: number, callback: AudioResumeCallba
  */
 export const offAudioPause = (channelNumber: number): void => {
   const channel: ExtendedAudioQueueChannel = audioChannels[channelNumber];
-  if (!channel || !channel.audioPauseCallbacks) return;
+  if (!channel?.audioPauseCallbacks) return;
 
   channel.audioPauseCallbacks.clear();
 };
@@ -381,7 +480,7 @@ export const offAudioPause = (channelNumber: number): void => {
  */
 export const offAudioResume = (channelNumber: number): void => {
   const channel: ExtendedAudioQueueChannel = audioChannels[channelNumber];
-  if (!channel || !channel.audioResumeCallbacks) return;
+  if (!channel?.audioResumeCallbacks) return;
 
   channel.audioResumeCallbacks.clear();
-}; 
+};