audio-channel-queue 1.3.0 → 1.5.0

package/README.md

@@ -1,5 +1,5 @@
-# Audio Queue Package
-The purpose of this package is to help queue audio files so they do not play on top of each other. You can also enqueue audio files to different queues. This allows you to play sounds concurrently, but not have them overlap in their given audio queue.
+# Audio Channel Queue
+The purpose of this package is to help queue audio files so they do not play on top of each other. You can also enqueue audio files to different queues. This allows you to play sounds concurrently, but not have them overlap in their given audio queue. The package also supports real-time audio progress tracking, duration information, and playback metadata! 🎵📊
 
 This package offers TypeScript support 📘, boasts zero dependencies 🚫, and is released under the MIT license 📜. As an added bonus, it's NON-GMO 🌱 and 100% Free Range Organic 🐓.
 
@@ -9,55 +9,291 @@ NPM package can be found [here](https://www.npmjs.com/package/audio-channel-queu
 
 GitHub Repo can be found [here](https://github.com/tonycarpenter21/audio-channel-queue).
 
+## Architecture & Code Organization 🏗️
+
+Modular architecture for maintainability and extensibility:
+
+```
+src/
+├── index.ts     # Main entry point with organized exports
+├── types.ts     # TypeScript interfaces and type definitions  
+├── core.ts      # Core queue management functions
+├── info.ts      # Audio information and progress tracking
+├── events.ts    # Event handling and emission logic
+└── utils.ts     # Helper functions and utilities
+```
+
 ## How To Install This Package:
 Install this package by running either of these commands (typescript packages are included automatically):
 - For npm run `npm install audio-channel-queue`
 - For yarn run `yarn add audio-channel-queue`
 
-### How To Use This Package:
-```queueAudio(audioFileGoesHere);```
+## Basic Queue Management Functions:
+
+### Queue Audio
+```queueAudio(audioFileGoesHere, channelNumber);```
 Use the `queueAudio()` function to add a file to the queue and start playing it automatically. It takes two arguments:
 - The first argument is an imported sound file.
 - The second argument is optional and it allows you to choose a different queue channel. 
 
+### Stop Current Audio
 ```stopCurrentAudioInChannel(queueChannelNumberGoesHere);```
 Use the `stopCurrentAudioInChannel()` function to stop the current playback of a file in a queue and start playing the next one automatically. It takes one argument:
 - The first argument is optional and it allows you to choose a different queue channel. If you are only using the default channel, just use `stopCurrentAudioInChannel()`.
 
+### Stop All Audio in Channel
 ```stopAllAudioInChannel(queueChannelNumberGoesHere);```
 Use the `stopAllAudioInChannel()` function to stop the current playback of all files in a queue and removes all enqueued files. It takes one argument:
 - The first argument is optional and it allows you to choose a different queue channel. If you are only using the default channel, just use `stopAllAudioInChannel()`.
 
-```stopAllAudio(queueChannelNumberGoesHere);```
+### Stop All Audio
+```stopAllAudio();```
 Use the `stopAllAudio()` function to stop the current playback of all files in all queues. It takes no arguments.
 
-If you need to expose the queue array for logging or other purposes, it is available to you as well: `audioChannels`.
+## Audio Information and Progress Tracking:
+
+### AudioInfo Interface
+The package now provides detailed information about audio playback through the `AudioInfo` interface:
+```typescript
+interface AudioInfo {
+  currentTime: number;       // Current position in milliseconds
+  duration: number;          // Total duration in milliseconds
+  fileName: string;          // Extracted filename from URL
+  isPlaying: boolean;        // Whether audio is currently playing
+  progress: number;          // Progress as percentage (0-1)
+  src: string;               // Audio file source URL
+}
+```
 
-### Example Usage in React:
+### Get Current Audio Info
+```getCurrentAudioInfo(channelNumber);```
+Get information about the currently playing audio in a specific channel. Returns `AudioInfo | null`.
+- `channelNumber` (optional): The channel number (defaults to 0)
+- Returns `null` if no audio is currently playing in the channel
 
-`App.tsx`
+### Get All Channels Info
+```getAllChannelsInfo();```
+Get audio information for all channels. Returns an array of `AudioInfo | null` objects.
+- Returns an array where each index corresponds to a channel number
+- `null` values indicate channels with no currently playing audio
+
+### Queue State Management
+```getQueueSnapshot(channelNumber);```
+Get a complete snapshot of the queue state for a specific channel. Returns `QueueSnapshot | null`.
+
+```typescript
+interface QueueSnapshot {
+  channelNumber: number;     // Channel this snapshot represents
+  totalItems: number;        // Total items in queue
+  currentIndex: number;      // Index of currently playing item
+  items: Array<{             // Array of queue items with metadata
+    src: string;
+    fileName: string;
+    duration: number;
+    isCurrentlyPlaying: boolean;
+  }>;
+}
 ```
+
+### Real-time Progress Tracking
+```onAudioProgress(channelNumber, callback);```
+Subscribe to real-time progress updates for a specific channel.
+- `channelNumber`: The channel number to monitor
+- `callback`: Function that receives `AudioInfo` updates
+
+```offAudioProgress(channelNumber);```
+Remove all progress listeners for a specific channel.
+- `channelNumber`: The channel number to stop monitoring
+
+### Queue Change Events
+```onQueueChange(channelNumber, callback);```
+Subscribe to queue change events for visual updates.
+- Triggered when items are added, removed, or when playback moves to next item
+- Perfect for updating UI queue displays
+
+```offQueueChange(channelNumber);```
+Remove queue change listeners for a specific channel.
+
+### Audio Lifecycle Events
+```onAudioStart(channelNumber, callback);```
+Subscribe to audio start events.
+- Triggered when audio begins playing (after metadata loads)
+- Provides duration, filename, and source information
+
+```onAudioComplete(channelNumber, callback);```
+Subscribe to audio completion events.
+- Triggered when audio finishes or is stopped
+- Includes remaining queue count information
+
+### Example Usage with Progress Tracking:
+
+`App.tsx`
+```typescript
 import redTeamWins from './audio/red_team_wins.mp3';
-import { queueAudio } from 'audio-channel-queue';
+import { 
+  queueAudio, 
+  getCurrentAudioInfo, 
+  onAudioProgress, 
+  offAudioProgress,
+  onQueueChange,
+  onAudioStart,
+  onAudioComplete,
+  getQueueSnapshot,
+  AudioInfo,
+  QueueSnapshot 
+} from 'audio-channel-queue';
+import { useState, useEffect } from 'react';
 
 function App(): JSX.Element {
+  const [currentInfo, setCurrentInfo] = useState<AudioInfo | null>(null);
+  const [queueSnapshot, setQueueSnapshot] = useState<QueueSnapshot | null>(null);
+  const [isTracking, setIsTracking] = useState(false);
+
+  const playSound = () => {
+    queueAudio(redTeamWins);
+    
+    // Get initial audio info
+    setTimeout(() => {
+      const info = getCurrentAudioInfo();
+      setCurrentInfo(info);
+    }, 100);
+  };
+
+  const startTracking = () => {
+    setIsTracking(true);
+    
+    // Track real-time progress
+    onAudioProgress(0, (info: AudioInfo) => {
+      setCurrentInfo(info);
+      console.log(`Progress: ${(info.progress * 100).toFixed(1)}%`);
+    });
+
+    // Track queue changes
+    onQueueChange(0, (snapshot: QueueSnapshot) => {
+      setQueueSnapshot(snapshot);
+      console.log(`Queue updated: ${snapshot.totalItems} items`);
+    });
+
+    // Track audio lifecycle
+    onAudioStart(0, (info) => {
+      console.log(`Started playing: ${info.fileName}`);
+    });
+
+    onAudioComplete(0, (info) => {
+      console.log(`Completed: ${info.fileName}, ${info.remainingInQueue} remaining`);
+    });
+  };
+
+  const stopTracking = () => {
+    setIsTracking(false);
+    offAudioProgress(0);
+    offQueueChange(0);
+  };
+
+  const addMoreAudio = () => {
+    queueAudio('./sounds/notification.wav');
+    queueAudio('./sounds/alert.mp3');
+  };
 
   return (
     <div className="App">
-      <button onClick={()=> queueAudio(redTeamWins)}>Play sound</button>
+      <button onClick={playSound}>Play Sound</button>
+      <button onClick={addMoreAudio}>Add More to Queue</button>
+      <button onClick={startTracking} disabled={isTracking}>
+        Start Progress Tracking
+      </button>
+      <button onClick={stopTracking} disabled={!isTracking}>
+        Stop Progress Tracking
+      </button>
+      
+      {currentInfo && (
+        <div>
+          <h3>Now Playing:</h3>
+          <p>File: {currentInfo.fileName}</p>
+          <p>Duration: {(currentInfo.duration / 1000).toFixed(1)}s</p>
+          <p>Current Time: {(currentInfo.currentTime / 1000).toFixed(1)}s</p>
+          <p>Progress: {(currentInfo.progress * 100).toFixed(1)}%</p>
+          <p>Playing: {currentInfo.isPlaying ? 'Yes' : 'No'}</p>
+        </div>
+      )}
+
+      {queueSnapshot && (
+        <div>
+          <h3>Queue Status:</h3>
+          <p>Channel: {queueSnapshot.channelNumber}</p>
+          <p>Total Items: {queueSnapshot.totalItems}</p>
+          <p>Current Index: {queueSnapshot.currentIndex}</p>
+          <ul>
+            {queueSnapshot.items.map((item, index) => (
+              <li key={index} style={{ 
+                fontWeight: item.isCurrentlyPlaying ? 'bold' : 'normal' 
+              }}>
+                {item.fileName} ({(item.duration / 1000).toFixed(1)}s)
+                {item.isCurrentlyPlaying && ' ▶️'}
+              </li>
+            ))}
+          </ul>
+        </div>
+      )}
     </div>
-  )
-};
+  );
+}
 
 export default App;
 ```
 
+### Legacy Access
+If you need to expose the queue array for logging or other purposes, it is available to you as well: `audioChannels`.
+
+### TypeScript Support
 If you cannot import audio files into your app, you may need a `custom.d.ts` file in the root directory. An example of one is shown here:
 
 `custom.d.ts`
-```
+```typescript
 declare module '*.mp3' {
   const src: string;
   export default src;
 }
-```
+```
+
+## Features:
+- ✅ Queue management across multiple channels
+- ✅ Real-time audio progress tracking
+- ✅ Audio duration and metadata extraction
+- ✅ Automatic filename extraction from URLs
+- ✅ Queue state snapshots and change events
+- ✅ Audio lifecycle events (start/complete)
+- ✅ TypeScript support with full type definitions
+- ✅ Modular architecture with clean separation of concerns
+- ✅ Comprehensive JSDoc documentation with examples
+- ✅ Zero dependencies
+- ✅ Backward compatible with existing implementations
+- ✅ Comprehensive error handling
+
+## Development & Contributing 🛠️
+
+The package uses a modular TypeScript architecture that makes it easy to contribute and extend:
+
+### File Structure:
+- **`src/types.ts`** - Interface definitions and type exports
+- **`src/core.ts`** - Main queue management logic
+- **`src/info.ts`** - Audio information and progress tracking
+- **`src/events.ts`** - Event system and callback management
+- **`src/utils.ts`** - Helper functions and utilities
+- **`src/index.ts`** - Public API exports
+
+### Testing:
+The package includes a comprehensive test suite with 64+ tests covering all functionality:
+
+```bash
+# Run tests once
+npm test
+
+# Run tests in watch mode during development
+npm run test:watch
+
+# Run tests with coverage report
+npm run test:coverage
+```
+
+**Test Coverage**: 85%+ code coverage across all modules with realistic HTMLAudioElement mocking using jsdom.

package/dist/core.d.ts

@@ -0,0 +1,53 @@
+/**
+ * @fileoverview Core queue management functions for the audio-channel-queue package
+ */
+/**
+ * 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)
+ * @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
+ * ```
+ */
+export declare const queueAudio: (audioUrl: string, channelNumber?: number) => Promise<void>;
+/**
+ * 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 declare const playAudioQueue: (channelNumber: number) => Promise<void>;
+/**
+ * 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
+ * stopCurrentAudioInChannel(0); // Stop current audio in channel 0
+ * stopCurrentAudioInChannel(); // Stop current audio in default channel
+ * ```
+ */
+export declare const stopCurrentAudioInChannel: (channelNumber?: number) => void;
+/**
+ * Stops all audio in a specific channel and clears the entire queue
+ * @param channelNumber - The channel number (defaults to 0)
+ * @example
+ * ```typescript
+ * stopAllAudioInChannel(0); // Clear all audio in channel 0
+ * stopAllAudioInChannel(); // Clear all audio in default channel
+ * ```
+ */
+export declare const stopAllAudioInChannel: (channelNumber?: number) => void;
+/**
+ * Stops all audio across all channels and clears all queues
+ * @example
+ * ```typescript
+ * stopAllAudio(); // Emergency stop - clears everything
+ * ```
+ */
+export declare const stopAllAudio: () => void;

package/dist/core.js

@@ -0,0 +1,189 @@
+"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.queueAudio = void 0;
+const info_1 = require("./info");
+const utils_1 = require("./utils");
+const events_1 = require("./events");
+/**
+ * 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)
+ * @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
+ * ```
+ */
+const queueAudio = (audioUrl_1, ...args_1) => __awaiter(void 0, [audioUrl_1, ...args_1], void 0, function* (audioUrl, channelNumber = 0) {
+    if (!info_1.audioChannels[channelNumber]) {
+        info_1.audioChannels[channelNumber] = {
+            audioCompleteCallbacks: new Set(),
+            audioStartCallbacks: new Set(),
+            progressCallbacks: new Map(),
+            queue: [],
+            queueChangeCallbacks: new Set()
+        };
+    }
+    const audio = new Audio(audioUrl);
+    info_1.audioChannels[channelNumber].queue.push(audio);
+    (0, events_1.emitQueueChange)(channelNumber, info_1.audioChannels);
+    if (info_1.audioChannels[channelNumber].queue.length === 1) {
+        (0, exports.playAudioQueue)(channelNumber);
+    }
+});
+exports.queueAudio = queueAudio;
+/**
+ * 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.queue.length === 0)
+        return;
+    const currentAudio = channel.queue[0];
+    (0, events_1.setupProgressTracking)(currentAudio, channelNumber, info_1.audioChannels);
+    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);
+            // 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);
+            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
+ * stopCurrentAudioInChannel(0); // Stop current audio in channel 0
+ * stopCurrentAudioInChannel(); // Stop current audio in default channel
+ * ```
+ */
+const stopCurrentAudioInChannel = (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);
+        currentAudio.pause();
+        (0, events_1.cleanupProgressTracking)(currentAudio, channelNumber, info_1.audioChannels);
+        channel.queue.shift();
+        (0, events_1.emitQueueChange)(channelNumber, info_1.audioChannels);
+        (0, exports.playAudioQueue)(channelNumber);
+    }
+};
+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
+ * stopAllAudioInChannel(0); // Clear all audio in channel 0
+ * stopAllAudioInChannel(); // Clear all audio in default channel
+ * ```
+ */
+const stopAllAudioInChannel = (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);
+            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 = [];
+        (0, events_1.emitQueueChange)(channelNumber, info_1.audioChannels);
+    }
+};
+exports.stopAllAudioInChannel = stopAllAudioInChannel;
+/**
+ * Stops all audio across all channels and clears all queues
+ * @example
+ * ```typescript
+ * stopAllAudio(); // Emergency stop - clears everything
+ * ```
+ */
+const stopAllAudio = () => {
+    info_1.audioChannels.forEach((_channel, index) => {
+        (0, exports.stopAllAudioInChannel)(index);
+    });
+};
+exports.stopAllAudio = stopAllAudio;

package/dist/events.d.ts

@@ -0,0 +1,59 @@
+/**
+ * @fileoverview Event handling and emission for the audio-channel-queue package
+ */
+import { AudioStartInfo, AudioCompleteInfo, ExtendedAudioQueueChannel } 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;
+/**
+ * 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;