audio-channel-queue 1.5.0 → 1.6.0

package/dist/info.js

@@ -3,7 +3,7 @@
  * @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;
+exports.offAudioResume = exports.offAudioPause = exports.onAudioResume = exports.onAudioPause = 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");
 /**
@@ -29,7 +29,7 @@ const getCurrentAudioInfo = (channelNumber = 0) => {
         return null;
     }
     const currentAudio = channel.queue[0];
-    return (0, utils_1.getAudioInfoFromElement)(currentAudio);
+    return (0, utils_1.getAudioInfoFromElement)(currentAudio, channelNumber, exports.audioChannels);
 };
 exports.getCurrentAudioInfo = getCurrentAudioInfo;
 /**
@@ -86,10 +86,14 @@ const onAudioProgress = (channelNumber, callback) => {
     if (!exports.audioChannels[channelNumber]) {
         exports.audioChannels[channelNumber] = {
             audioCompleteCallbacks: new Set(),
+            audioPauseCallbacks: new Set(),
+            audioResumeCallbacks: new Set(),
             audioStartCallbacks: new Set(),
+            isPaused: false,
             progressCallbacks: new Map(),
             queue: [],
-            queueChangeCallbacks: new Set()
+            queueChangeCallbacks: new Set(),
+            volume: 1.0
         };
     }
     const channel = exports.audioChannels[channelNumber];
@@ -150,10 +154,14 @@ const onQueueChange = (channelNumber, callback) => {
     if (!exports.audioChannels[channelNumber]) {
         exports.audioChannels[channelNumber] = {
             audioCompleteCallbacks: new Set(),
+            audioPauseCallbacks: new Set(),
+            audioResumeCallbacks: new Set(),
             audioStartCallbacks: new Set(),
+            isPaused: false,
             progressCallbacks: new Map(),
             queue: [],
-            queueChangeCallbacks: new Set()
+            queueChangeCallbacks: new Set(),
+            volume: 1.0
         };
     }
     const channel = exports.audioChannels[channelNumber];
@@ -194,10 +202,14 @@ const onAudioStart = (channelNumber, callback) => {
     if (!exports.audioChannels[channelNumber]) {
         exports.audioChannels[channelNumber] = {
             audioCompleteCallbacks: new Set(),
+            audioPauseCallbacks: new Set(),
+            audioResumeCallbacks: new Set(),
             audioStartCallbacks: new Set(),
+            isPaused: false,
             progressCallbacks: new Map(),
             queue: [],
-            queueChangeCallbacks: new Set()
+            queueChangeCallbacks: new Set(),
+            volume: 1.0
         };
     }
     const channel = exports.audioChannels[channelNumber];
@@ -225,10 +237,14 @@ const onAudioComplete = (channelNumber, callback) => {
     if (!exports.audioChannels[channelNumber]) {
         exports.audioChannels[channelNumber] = {
             audioCompleteCallbacks: new Set(),
+            audioPauseCallbacks: new Set(),
+            audioResumeCallbacks: new Set(),
             audioStartCallbacks: new Set(),
+            isPaused: false,
             progressCallbacks: new Map(),
             queue: [],
-            queueChangeCallbacks: new Set()
+            queueChangeCallbacks: new Set(),
+            volume: 1.0
         };
     }
     const channel = exports.audioChannels[channelNumber];
@@ -238,3 +254,99 @@ const onAudioComplete = (channelNumber, callback) => {
     channel.audioCompleteCallbacks.add(callback);
 };
 exports.onAudioComplete = onAudioComplete;
+/**
+ * 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
+ * @example
+ * ```typescript
+ * onAudioPause(0, (channelNumber, info) => {
+ *   showPauseIndicator();
+ *   logPauseEvent(info.fileName, info.currentTime);
+ * });
+ * ```
+ */
+const onAudioPause = (channelNumber, callback) => {
+    if (!exports.audioChannels[channelNumber]) {
+        exports.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 channel = exports.audioChannels[channelNumber];
+    if (!channel.audioPauseCallbacks) {
+        channel.audioPauseCallbacks = new Set();
+    }
+    channel.audioPauseCallbacks.add(callback);
+};
+exports.onAudioPause = onAudioPause;
+/**
+ * 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
+ * @example
+ * ```typescript
+ * onAudioResume(0, (channelNumber, info) => {
+ *   hidePauseIndicator();
+ *   logResumeEvent(info.fileName, info.currentTime);
+ * });
+ * ```
+ */
+const onAudioResume = (channelNumber, callback) => {
+    if (!exports.audioChannels[channelNumber]) {
+        exports.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 channel = exports.audioChannels[channelNumber];
+    if (!channel.audioResumeCallbacks) {
+        channel.audioResumeCallbacks = new Set();
+    }
+    channel.audioResumeCallbacks.add(callback);
+};
+exports.onAudioResume = onAudioResume;
+/**
+ * Removes pause event listeners for a specific channel
+ * @param channelNumber - The channel number
+ * @example
+ * ```typescript
+ * offAudioPause(0); // Stop receiving pause notifications for channel 0
+ * ```
+ */
+const offAudioPause = (channelNumber) => {
+    const channel = exports.audioChannels[channelNumber];
+    if (!channel || !channel.audioPauseCallbacks)
+        return;
+    channel.audioPauseCallbacks.clear();
+};
+exports.offAudioPause = offAudioPause;
+/**
+ * Removes resume event listeners for a specific channel
+ * @param channelNumber - The channel number
+ * @example
+ * ```typescript
+ * offAudioResume(0); // Stop receiving resume notifications for channel 0
+ * ```
+ */
+const offAudioResume = (channelNumber) => {
+    const channel = exports.audioChannels[channelNumber];
+    if (!channel || !channel.audioResumeCallbacks)
+        return;
+    channel.audioResumeCallbacks.clear();
+};
+exports.offAudioResume = offAudioResume;

package/dist/pause.d.ts

@@ -0,0 +1,87 @@
+/**
+ * @fileoverview Pause and resume management functions for the audio-channel-queue package
+ */
+/**
+ * Pauses the currently playing audio in a specific channel
+ * @param channelNumber - The channel number to pause (defaults to 0)
+ * @returns Promise that resolves when the audio is paused
+ * @example
+ * ```typescript
+ * await pauseChannel(0); // Pause audio in channel 0
+ * await pauseChannel(); // Pause audio in default channel
+ * ```
+ */
+export declare const pauseChannel: (channelNumber?: number) => Promise<void>;
+/**
+ * Resumes the currently paused audio in a specific channel
+ * @param channelNumber - The channel number to resume (defaults to 0)
+ * @returns Promise that resolves when the audio starts playing
+ * @example
+ * ```typescript
+ * await resumeChannel(0); // Resume audio in channel 0
+ * await resumeChannel(); // Resume audio in default channel
+ * ```
+ */
+export declare const resumeChannel: (channelNumber?: number) => Promise<void>;
+/**
+ * Toggles pause/resume state for a specific channel
+ * @param channelNumber - The channel number to toggle (defaults to 0)
+ * @returns Promise that resolves when the toggle is complete
+ * @example
+ * ```typescript
+ * await togglePauseChannel(0); // Toggle pause state for channel 0
+ * ```
+ */
+export declare const togglePauseChannel: (channelNumber?: number) => Promise<void>;
+/**
+ * Pauses all currently playing audio across all channels
+ * @returns Promise that resolves when all audio is paused
+ * @example
+ * ```typescript
+ * await pauseAllChannels(); // Pause everything
+ * ```
+ */
+export declare const pauseAllChannels: () => Promise<void>;
+/**
+ * Resumes all currently paused audio across all channels
+ * @returns Promise that resolves when all audio is resumed
+ * @example
+ * ```typescript
+ * await resumeAllChannels(); // Resume everything that was paused
+ * ```
+ */
+export declare const resumeAllChannels: () => Promise<void>;
+/**
+ * Checks if a specific channel is currently paused
+ * @param channelNumber - The channel number to check (defaults to 0)
+ * @returns True if the channel is paused, false otherwise
+ * @example
+ * ```typescript
+ * const isPaused = isChannelPaused(0);
+ * console.log(`Channel 0 is ${isPaused ? 'paused' : 'playing'}`);
+ * ```
+ */
+export declare const isChannelPaused: (channelNumber?: number) => boolean;
+/**
+ * Gets the pause state of all channels
+ * @returns Array of boolean values indicating pause state for each channel
+ * @example
+ * ```typescript
+ * const pauseStates = getAllChannelsPauseState();
+ * pauseStates.forEach((isPaused, index) => {
+ *   console.log(`Channel ${index}: ${isPaused ? 'paused' : 'playing'}`);
+ * });
+ * ```
+ */
+export declare const getAllChannelsPauseState: () => boolean[];
+/**
+ * Toggles pause/resume state for all channels globally
+ * If any channels are currently playing, all channels will be paused
+ * If all channels are paused, all channels will be resumed
+ * @returns Promise that resolves when the toggle is complete
+ * @example
+ * ```typescript
+ * await togglePauseAllChannels(); // Pause all if any are playing, resume all if all are paused
+ * ```
+ */
+export declare const togglePauseAllChannels: () => Promise<void>;

package/dist/pause.js

@@ -0,0 +1,186 @@
+"use strict";
+/**
+ * @fileoverview Pause and resume 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.togglePauseAllChannels = exports.getAllChannelsPauseState = exports.isChannelPaused = exports.resumeAllChannels = exports.pauseAllChannels = exports.togglePauseChannel = exports.resumeChannel = exports.pauseChannel = void 0;
+const info_1 = require("./info");
+const utils_1 = require("./utils");
+const events_1 = require("./events");
+/**
+ * Pauses the currently playing audio in a specific channel
+ * @param channelNumber - The channel number to pause (defaults to 0)
+ * @returns Promise that resolves when the audio is paused
+ * @example
+ * ```typescript
+ * await pauseChannel(0); // Pause audio in channel 0
+ * await pauseChannel(); // Pause audio in default channel
+ * ```
+ */
+const pauseChannel = (...args_1) => __awaiter(void 0, [...args_1], void 0, function* (channelNumber = 0) {
+    const channel = info_1.audioChannels[channelNumber];
+    if (channel && channel.queue.length > 0) {
+        const currentAudio = channel.queue[0];
+        if (!currentAudio.paused && !currentAudio.ended) {
+            currentAudio.pause();
+            channel.isPaused = true;
+            const audioInfo = (0, utils_1.getAudioInfoFromElement)(currentAudio, channelNumber, info_1.audioChannels);
+            if (audioInfo) {
+                (0, events_1.emitAudioPause)(channelNumber, audioInfo, info_1.audioChannels);
+            }
+        }
+    }
+});
+exports.pauseChannel = pauseChannel;
+/**
+ * Resumes the currently paused audio in a specific channel
+ * @param channelNumber - The channel number to resume (defaults to 0)
+ * @returns Promise that resolves when the audio starts playing
+ * @example
+ * ```typescript
+ * await resumeChannel(0); // Resume audio in channel 0
+ * await resumeChannel(); // Resume audio in default channel
+ * ```
+ */
+const resumeChannel = (...args_1) => __awaiter(void 0, [...args_1], void 0, function* (channelNumber = 0) {
+    const channel = info_1.audioChannels[channelNumber];
+    if (channel && channel.queue.length > 0) {
+        const currentAudio = channel.queue[0];
+        // Only resume if both the channel is marked as paused AND the audio element is actually paused
+        if (channel.isPaused && currentAudio.paused && !currentAudio.ended) {
+            yield currentAudio.play();
+            channel.isPaused = false;
+            const audioInfo = (0, utils_1.getAudioInfoFromElement)(currentAudio, channelNumber, info_1.audioChannels);
+            if (audioInfo) {
+                (0, events_1.emitAudioResume)(channelNumber, audioInfo, info_1.audioChannels);
+            }
+        }
+    }
+});
+exports.resumeChannel = resumeChannel;
+/**
+ * Toggles pause/resume state for a specific channel
+ * @param channelNumber - The channel number to toggle (defaults to 0)
+ * @returns Promise that resolves when the toggle is complete
+ * @example
+ * ```typescript
+ * await togglePauseChannel(0); // Toggle pause state for channel 0
+ * ```
+ */
+const togglePauseChannel = (...args_1) => __awaiter(void 0, [...args_1], void 0, function* (channelNumber = 0) {
+    const channel = info_1.audioChannels[channelNumber];
+    if (channel && channel.queue.length > 0) {
+        const currentAudio = channel.queue[0];
+        if (currentAudio.paused) {
+            yield (0, exports.resumeChannel)(channelNumber);
+        }
+        else {
+            yield (0, exports.pauseChannel)(channelNumber);
+        }
+    }
+});
+exports.togglePauseChannel = togglePauseChannel;
+/**
+ * Pauses all currently playing audio across all channels
+ * @returns Promise that resolves when all audio is paused
+ * @example
+ * ```typescript
+ * await pauseAllChannels(); // Pause everything
+ * ```
+ */
+const pauseAllChannels = () => __awaiter(void 0, void 0, void 0, function* () {
+    const pausePromises = [];
+    info_1.audioChannels.forEach((_channel, index) => {
+        pausePromises.push((0, exports.pauseChannel)(index));
+    });
+    yield Promise.all(pausePromises);
+});
+exports.pauseAllChannels = pauseAllChannels;
+/**
+ * Resumes all currently paused audio across all channels
+ * @returns Promise that resolves when all audio is resumed
+ * @example
+ * ```typescript
+ * await resumeAllChannels(); // Resume everything that was paused
+ * ```
+ */
+const resumeAllChannels = () => __awaiter(void 0, void 0, void 0, function* () {
+    const resumePromises = [];
+    info_1.audioChannels.forEach((_channel, index) => {
+        resumePromises.push((0, exports.resumeChannel)(index));
+    });
+    yield Promise.all(resumePromises);
+});
+exports.resumeAllChannels = resumeAllChannels;
+/**
+ * Checks if a specific channel is currently paused
+ * @param channelNumber - The channel number to check (defaults to 0)
+ * @returns True if the channel is paused, false otherwise
+ * @example
+ * ```typescript
+ * const isPaused = isChannelPaused(0);
+ * console.log(`Channel 0 is ${isPaused ? 'paused' : 'playing'}`);
+ * ```
+ */
+const isChannelPaused = (channelNumber = 0) => {
+    const channel = info_1.audioChannels[channelNumber];
+    return (channel === null || channel === void 0 ? void 0 : channel.isPaused) || false;
+};
+exports.isChannelPaused = isChannelPaused;
+/**
+ * Gets the pause state of all channels
+ * @returns Array of boolean values indicating pause state for each channel
+ * @example
+ * ```typescript
+ * const pauseStates = getAllChannelsPauseState();
+ * pauseStates.forEach((isPaused, index) => {
+ *   console.log(`Channel ${index}: ${isPaused ? 'paused' : 'playing'}`);
+ * });
+ * ```
+ */
+const getAllChannelsPauseState = () => {
+    return info_1.audioChannels.map((channel) => (channel === null || channel === void 0 ? void 0 : channel.isPaused) || false);
+};
+exports.getAllChannelsPauseState = getAllChannelsPauseState;
+/**
+ * Toggles pause/resume state for all channels globally
+ * If any channels are currently playing, all channels will be paused
+ * If all channels are paused, all channels will be resumed
+ * @returns Promise that resolves when the toggle is complete
+ * @example
+ * ```typescript
+ * await togglePauseAllChannels(); // Pause all if any are playing, resume all if all are paused
+ * ```
+ */
+const togglePauseAllChannels = () => __awaiter(void 0, void 0, void 0, function* () {
+    let hasPlayingChannel = false;
+    // Check if any channel is currently playing
+    for (let i = 0; i < info_1.audioChannels.length; i++) {
+        const channel = info_1.audioChannels[i];
+        if (channel && channel.queue.length > 0) {
+            const currentAudio = channel.queue[0];
+            if (!currentAudio.paused && !currentAudio.ended) {
+                hasPlayingChannel = true;
+                break;
+            }
+        }
+    }
+    // If any channel is playing, pause all channels
+    // If no channels are playing, resume all channels
+    if (hasPlayingChannel) {
+        yield (0, exports.pauseAllChannels)();
+    }
+    else {
+        yield (0, exports.resumeAllChannels)();
+    }
+});
+exports.togglePauseAllChannels = togglePauseAllChannels;

package/dist/types.d.ts

@@ -11,6 +11,36 @@ export type AudioQueue = HTMLAudioElement[];
 export type AudioQueueChannel = {
     queue: AudioQueue;
 };
+/**
+ * Volume ducking configuration for channels
+ */
+export interface VolumeConfig {
+    /** The channel number that should have priority */
+    priorityChannel: number;
+    /** Volume level for the priority channel (0-1) */
+    priorityVolume: number;
+    /** Volume level for all other channels when priority channel is active (0-1) */
+    duckingVolume: number;
+    /** Duration in milliseconds for volume duck transition (defaults to 250ms) */
+    duckTransitionDuration?: number;
+    /** Duration in milliseconds for volume restore transition (defaults to 500ms) */
+    restoreTransitionDuration?: number;
+    /** Easing function for volume transitions (defaults to 'ease-out') */
+    transitionEasing?: 'linear' | 'ease-in' | 'ease-out' | 'ease-in-out';
+}
+/**
+ * Audio file configuration for queueing
+ */
+export interface AudioQueueOptions {
+    /** Whether to add the audio to the front of the queue (defaults to false) */
+    addToFront?: boolean;
+    /** Whether the audio should loop when it finishes */
+    loop?: boolean;
+    /** Whether to add the audio with priority (same as addToFront) */
+    priority?: boolean;
+    /** Volume level for this specific audio file (0-1, defaults to channel volume) */
+    volume?: number;
+}
 /**
  * Comprehensive audio information interface providing metadata about currently playing audio
  */
@@ -21,12 +51,20 @@ export interface AudioInfo {
     duration: number;
     /** Extracted filename from the source URL */
     fileName: string;
+    /** Whether the audio is set to loop */
+    isLooping: boolean;
+    /** Whether the audio is currently paused */
+    isPaused: boolean;
     /** Whether the audio is currently playing */
     isPlaying: boolean;
     /** Playback progress as a decimal (0-1) */
     progress: number;
+    /** Number of audio files remaining in the queue after current */
+    remainingInQueue: number;
     /** Audio file source URL */
     src: string;
+    /** Current volume level (0-1) */
+    volume: number;
 }
 /**
  * Information provided when an audio file completes playback
@@ -64,8 +102,12 @@ export interface QueueItem {
     fileName: string;
     /** Whether this item is currently playing */
     isCurrentlyPlaying: boolean;
+    /** Whether this item is set to loop */
+    isLooping: boolean;
     /** Audio file source URL */
     src: string;
+    /** Volume level for this item (0-1) */
+    volume: number;
 }
 /**
  * Complete snapshot of a queue's current state
@@ -75,10 +117,14 @@ export interface QueueSnapshot {
     channelNumber: number;
     /** Zero-based index of the currently playing item */
     currentIndex: number;
+    /** Whether the current audio is paused */
+    isPaused: boolean;
     /** Array of audio items in the queue with their metadata */
     items: QueueItem[];
     /** Total number of items in the queue */
     totalItems: number;
+    /** Current volume level for the channel (0-1) */
+    volume: number;
 }
 /**
  * Callback function type for audio progress updates
@@ -101,15 +147,37 @@ export type AudioStartCallback = (audioInfo: AudioStartInfo) => void;
  */
 export type AudioCompleteCallback = (audioInfo: AudioCompleteInfo) => void;
 /**
- * Extended audio queue channel with event callback management
+ * Callback function type for audio pause notifications
+ * @param channelNumber Channel that was paused
+ * @param audioInfo Information about the audio that was paused
+ */
+export type AudioPauseCallback = (channelNumber: number, audioInfo: AudioInfo) => void;
+/**
+ * Callback function type for audio resume notifications
+ * @param channelNumber Channel that was resumed
+ * @param audioInfo Information about the audio that was resumed
+ */
+export type AudioResumeCallback = (channelNumber: number, audioInfo: AudioInfo) => void;
+/**
+ * Extended audio queue channel with event callback management and additional features
  */
 export type ExtendedAudioQueueChannel = AudioQueueChannel & {
     /** Set of callbacks for audio completion events */
     audioCompleteCallbacks?: Set<AudioCompleteCallback>;
+    /** Set of callbacks for audio pause events */
+    audioPauseCallbacks?: Set<AudioPauseCallback>;
+    /** Set of callbacks for audio resume events */
+    audioResumeCallbacks?: Set<AudioResumeCallback>;
     /** Set of callbacks for audio start events */
     audioStartCallbacks?: Set<AudioStartCallback>;
+    /** Whether the current audio in this channel is paused */
+    isPaused?: boolean;
     /** Map of audio elements to their progress callback sets */
     progressCallbacks?: Map<HTMLAudioElement, Set<ProgressCallback>>;
     /** Set of callbacks for queue change events */
     queueChangeCallbacks?: Set<QueueChangeCallback>;
+    /** Current volume level for this channel (0-1) */
+    volume?: number;
+    /** Volume ducking configuration for this channel */
+    volumeConfig?: VolumeConfig;
 };

package/dist/utils.d.ts

@@ -16,15 +16,21 @@ export declare const extractFileName: (url: string) => string;
 /**
  * Extracts comprehensive audio information from an HTMLAudioElement
  * @param audio - The HTML audio element to extract information from
+ * @param channelNumber - Optional channel number to include remaining queue info
+ * @param audioChannels - Optional audio channels array to calculate remainingInQueue
  * @returns AudioInfo object with current playback state or null if audio is invalid
  * @example
  * ```typescript
  * const audioElement = new Audio('song.mp3');
  * const info = getAudioInfoFromElement(audioElement);
  * console.log(info?.progress); // Current progress as decimal (0-1)
+ *
+ * // With channel context for remainingInQueue
+ * const infoWithQueue = getAudioInfoFromElement(audioElement, 0, audioChannels);
+ * console.log(infoWithQueue?.remainingInQueue); // Number of items left in queue
  * ```
  */
-export declare const getAudioInfoFromElement: (audio: HTMLAudioElement) => AudioInfo | null;
+export declare const getAudioInfoFromElement: (audio: HTMLAudioElement, channelNumber?: number, audioChannels?: ExtendedAudioQueueChannel[]) => AudioInfo | null;
 /**
  * Creates a complete snapshot of a queue's current state
  * @param channelNumber - The channel number to create a snapshot for

package/dist/utils.js

@@ -33,28 +33,44 @@ exports.extractFileName = extractFileName;
 /**
  * Extracts comprehensive audio information from an HTMLAudioElement
  * @param audio - The HTML audio element to extract information from
+ * @param channelNumber - Optional channel number to include remaining queue info
+ * @param audioChannels - Optional audio channels array to calculate remainingInQueue
  * @returns AudioInfo object with current playback state or null if audio is invalid
  * @example
  * ```typescript
  * const audioElement = new Audio('song.mp3');
  * const info = getAudioInfoFromElement(audioElement);
  * console.log(info?.progress); // Current progress as decimal (0-1)
+ *
+ * // With channel context for remainingInQueue
+ * const infoWithQueue = getAudioInfoFromElement(audioElement, 0, audioChannels);
+ * console.log(infoWithQueue?.remainingInQueue); // Number of items left in queue
  * ```
  */
-const getAudioInfoFromElement = (audio) => {
+const getAudioInfoFromElement = (audio, channelNumber, audioChannels) => {
     if (!audio)
         return null;
     const duration = isNaN(audio.duration) ? 0 : audio.duration * 1000; // Convert to milliseconds
     const currentTime = isNaN(audio.currentTime) ? 0 : audio.currentTime * 1000; // Convert to milliseconds
     const progress = duration > 0 ? Math.min(currentTime / duration, 1) : 0;
     const isPlaying = !audio.paused && !audio.ended && audio.readyState > 2;
+    // Calculate remainingInQueue if channel context is provided
+    let remainingInQueue = 0;
+    if (channelNumber !== undefined && audioChannels && audioChannels[channelNumber]) {
+        const channel = audioChannels[channelNumber];
+        remainingInQueue = Math.max(0, channel.queue.length - 1); // Exclude current playing audio
+    }
     return {
         currentTime,
         duration,
         fileName: (0, exports.extractFileName)(audio.src),
+        isLooping: audio.loop,
+        isPaused: audio.paused && !audio.ended,
         isPlaying,
         progress,
-        src: audio.src
+        remainingInQueue,
+        src: audio.src,
+        volume: audio.volume
     };
 };
 exports.getAudioInfoFromElement = getAudioInfoFromElement;
@@ -77,13 +93,17 @@ const createQueueSnapshot = (channelNumber, audioChannels) => {
         duration: isNaN(audio.duration) ? 0 : audio.duration * 1000,
         fileName: (0, exports.extractFileName)(audio.src),
         isCurrentlyPlaying: index === 0 && !audio.paused && !audio.ended,
-        src: audio.src
+        isLooping: audio.loop,
+        src: audio.src,
+        volume: audio.volume
     }));
     return {
         channelNumber,
         currentIndex: 0, // Current playing is always index 0 in our queue structure
+        isPaused: channel.isPaused || false,
         items,
-        totalItems: channel.queue.length
+        totalItems: channel.queue.length,
+        volume: channel.volume || 1.0
     };
 };
 exports.createQueueSnapshot = createQueueSnapshot;