audio-channel-queue 1.5.0 → 1.7.0

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,70 @@ export type AudioStartCallback = (audioInfo: AudioStartInfo) => void;
  */
 export type AudioCompleteCallback = (audioInfo: AudioCompleteInfo) => void;
 /**
- * Extended audio queue channel with event callback management
- */
-export type ExtendedAudioQueueChannel = AudioQueueChannel & {
-    /** Set of callbacks for audio completion events */
-    audioCompleteCallbacks?: Set<AudioCompleteCallback>;
-    /** Set of callbacks for audio start events */
-    audioStartCallbacks?: Set<AudioStartCallback>;
-    /** Map of audio elements to their progress callback sets */
-    progressCallbacks?: Map<HTMLAudioElement, Set<ProgressCallback>>;
-    /** Set of callbacks for queue change events */
-    queueChangeCallbacks?: Set<QueueChangeCallback>;
-};
+ * 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;
+/**
+ * Information about an audio error that occurred
+ */
+export interface AudioErrorInfo {
+    channelNumber: number;
+    src: string;
+    fileName: string;
+    error: Error;
+    errorType: 'network' | 'decode' | 'unsupported' | 'permission' | 'abort' | 'timeout' | 'unknown';
+    timestamp: number;
+    retryAttempt?: number;
+    remainingInQueue: number;
+}
+/**
+ * Configuration for automatic retry behavior when audio fails to load or play
+ */
+export interface RetryConfig {
+    enabled: boolean;
+    maxRetries: number;
+    baseDelay: number;
+    exponentialBackoff: boolean;
+    timeoutMs: number;
+    fallbackUrls?: string[];
+    skipOnFailure: boolean;
+}
+/**
+ * Configuration options for error recovery mechanisms
+ */
+export interface ErrorRecoveryOptions {
+    autoRetry: boolean;
+    showUserFeedback: boolean;
+    logErrorsToAnalytics: boolean;
+    preserveQueueOnError: boolean;
+    fallbackToNextTrack: boolean;
+}
+/**
+ * Callback function type for audio error events
+ */
+export type AudioErrorCallback = (errorInfo: AudioErrorInfo) => void;
+/**
+ * Extended audio queue channel with error handling capabilities
+ */
+export interface ExtendedAudioQueueChannel {
+    audioCompleteCallbacks: Set<AudioCompleteCallback>;
+    audioErrorCallbacks: Set<AudioErrorCallback>;
+    audioPauseCallbacks: Set<AudioPauseCallback>;
+    audioResumeCallbacks: Set<AudioResumeCallback>;
+    audioStartCallbacks: Set<AudioStartCallback>;
+    isPaused?: boolean;
+    progressCallbacks: Map<HTMLAudioElement | null, Set<ProgressCallback>>;
+    queue: HTMLAudioElement[];
+    queueChangeCallbacks: Set<QueueChangeCallback>;
+    retryConfig?: RetryConfig;
+    volume?: number;
+    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;

package/dist/volume.d.ts

@@ -0,0 +1,98 @@
+/**
+ * @fileoverview Volume management functions for the audio-channel-queue package
+ */
+import { VolumeConfig } from './types';
+/**
+ * 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
+ * ```
+ */
+export declare const transitionVolume: (channelNumber: number, targetVolume: number, duration?: number, easing?: "linear" | "ease-in" | "ease-out" | "ease-in-out") => Promise<void>;
+/**
+ * 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
+ * ```
+ */
+export declare const setChannelVolume: (channelNumber: number, volume: number, transitionDuration?: number, easing?: "linear" | "ease-in" | "ease-out" | "ease-in-out") => Promise<void>;
+/**
+ * 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}%`);
+ * ```
+ */
+export declare const getChannelVolume: (channelNumber?: number) => number;
+/**
+ * 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}%`);
+ * });
+ * ```
+ */
+export declare const getAllChannelsVolume: () => number[];
+/**
+ * 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
+ * ```
+ */
+export declare const setAllChannelsVolume: (volume: number) => Promise<void>;
+/**
+ * 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
+ * });
+ * ```
+ */
+export declare const setVolumeDucking: (config: VolumeConfig) => void;
+/**
+ * Removes volume ducking configuration from all channels
+ * @example
+ * ```typescript
+ * clearVolumeDucking(); // Remove all volume ducking effects
+ * ```
+ */
+export declare const clearVolumeDucking: () => void;
+/**
+ * Applies volume ducking effects based on current playback state with smooth transitions
+ * @param activeChannelNumber - The channel that just started playing
+ * @internal
+ */
+export declare const applyVolumeDucking: (activeChannelNumber: number) => Promise<void>;
+/**
+ * Restores normal volume levels when priority channel stops with smooth transitions
+ * @param stoppedChannelNumber - The channel that just stopped playing
+ * @internal
+ */
+export declare const restoreVolumeLevels: (stoppedChannelNumber: number) => Promise<void>;

package/dist/volume.js

@@ -0,0 +1,305 @@
+"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(),
+            audioErrorCallbacks: 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(),
+            audioErrorCallbacks: 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(),
+                audioErrorCallbacks: 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,6 +1,6 @@
 {
   "name": "audio-channel-queue",
-  "version": "1.5.0",
+  "version": "1.7.0",
   "description": "Allows you to queue audio files to different playback channels.",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -31,6 +31,9 @@
     "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",