audio-channel-queue 1.8.0 → 1.10.0

package/src/queue-manipulation.ts

@@ -0,0 +1,378 @@
+/**
+ * @fileoverview Queue manipulation functions for the audio-channel-queue package
+ * Provides advanced queue management including item removal, reordering, and clearing
+ */
+
+import {
+  ExtendedAudioQueueChannel,
+  QueueManipulationResult,
+  QueueSnapshot,
+  QueueItem
+} from './types';
+import { audioChannels } from './info';
+import { emitQueueChange } from './events';
+import { cleanupProgressTracking } from './events';
+import { createQueueSnapshot, getAudioInfoFromElement } from './utils';
+
+/**
+ * Removes a specific item from the queue by its slot number (0-based index)
+ * Cannot remove the currently playing item (index 0) - use stopCurrentAudioInChannel instead
+ * @param queuedSlotNumber - Zero-based index of the item to remove (must be > 0)
+ * @param channelNumber - The channel number (defaults to 0)
+ * @returns Promise resolving to operation result with success status and updated queue
+ * @throws Error if trying to remove currently playing item or invalid slot number
+ * @example
+ * ```typescript
+ * // Remove the second item in queue (index 1)
+ * const result = await removeQueuedItem(1, 0);
+ * if (result.success) {
+ *   console.log(`Removed item, queue now has ${result.updatedQueue.totalItems} items`);
+ * }
+ *
+ * // Remove the third item from channel 1
+ * await removeQueuedItem(2, 1);
+ * ```
+ */
+export const removeQueuedItem = async (
+  queuedSlotNumber: number,
+  channelNumber: number = 0
+): Promise<QueueManipulationResult> => {
+  const channel: ExtendedAudioQueueChannel = audioChannels[channelNumber];
+
+  if (!channel) {
+    return {
+      error: `Channel ${channelNumber} does not exist`,
+      success: false
+    };
+  }
+
+  if (queuedSlotNumber < 0 || queuedSlotNumber >= channel.queue.length) {
+    return {
+      error:
+        `Invalid slot number ${queuedSlotNumber}. Queue has ${channel.queue.length} items ` +
+        `(indices 0-${channel.queue.length - 1})`,
+      success: false
+    };
+  }
+
+  if (queuedSlotNumber === 0) {
+    return {
+      error:
+        'Cannot remove currently playing item (index 0). ' +
+        'Use stopCurrentAudioInChannel() instead',
+      success: false
+    };
+  }
+
+  // Remove the audio element from the queue
+  const removedAudio: HTMLAudioElement = channel.queue.splice(queuedSlotNumber, 1)[0];
+
+  // Clean up any progress tracking for the removed audio
+  cleanupProgressTracking(removedAudio, channelNumber, audioChannels);
+
+  // Emit queue change event
+  emitQueueChange(channelNumber, audioChannels);
+
+  const updatedQueue: QueueSnapshot | null = createQueueSnapshot(channelNumber, audioChannels);
+
+  return {
+    success: true,
+    updatedQueue: updatedQueue ?? undefined
+  };
+};
+
+/**
+ * Reorders a queue item by moving it from one position to another
+ * Cannot reorder the currently playing item (index 0)
+ * @param currentQueuedSlotNumber - Current zero-based index of the item to move (must be > 0)
+ * @param newQueuedSlotNumber - New zero-based index where the item should be placed (must be > 0)
+ * @param channelNumber - The channel number (defaults to 0)
+ * @returns Promise resolving to operation result with success status and updated queue
+ * @throws Error if trying to reorder currently playing item or invalid slot numbers
+ * @example
+ * ```typescript
+ * // Move item from position 2 to position 1 (make it play next)
+ * const result = await reorderQueue(2, 1, 0);
+ * if (result.success) {
+ *   console.log('Item moved successfully');
+ * }
+ *
+ * // Move item from position 1 to end of queue
+ * await reorderQueue(1, 4, 0); // Assuming queue has 5+ items
+ * ```
+ */
+export const reorderQueue = async (
+  currentQueuedSlotNumber: number,
+  newQueuedSlotNumber: number,
+  channelNumber: number = 0
+): Promise<QueueManipulationResult> => {
+  const channel: ExtendedAudioQueueChannel = audioChannels[channelNumber];
+
+  if (!channel) {
+    return {
+      error: `Channel ${channelNumber} does not exist`,
+      success: false
+    };
+  }
+
+  if (currentQueuedSlotNumber < 0 || currentQueuedSlotNumber >= channel.queue.length) {
+    return {
+      error:
+        `Invalid current slot number ${currentQueuedSlotNumber}. Queue has ` +
+        `${channel.queue.length} items (indices 0-${channel.queue.length - 1})`,
+      success: false
+    };
+  }
+
+  if (newQueuedSlotNumber < 0 || newQueuedSlotNumber >= channel.queue.length) {
+    return {
+      error:
+        `Invalid new slot number ${newQueuedSlotNumber}. Queue has ` +
+        `${channel.queue.length} items (indices 0-${channel.queue.length - 1})`,
+      success: false
+    };
+  }
+
+  if (currentQueuedSlotNumber === 0) {
+    return {
+      error:
+        'Cannot reorder currently playing item (index 0). ' + 'Stop current audio first if needed',
+      success: false
+    };
+  }
+
+  if (newQueuedSlotNumber === 0) {
+    return {
+      error:
+        'Cannot move item to currently playing position (index 0). ' +
+        'Use queueAudioPriority() to add items to front of queue',
+      success: false
+    };
+  }
+
+  if (currentQueuedSlotNumber === newQueuedSlotNumber) {
+    // No change needed, but return success
+    const updatedQueue: QueueSnapshot | null = createQueueSnapshot(channelNumber, audioChannels);
+    return {
+      success: true,
+      updatedQueue: updatedQueue ?? undefined
+    };
+  }
+
+  // Remove the item from its current position
+  const audioToMove: HTMLAudioElement = channel.queue.splice(currentQueuedSlotNumber, 1)[0];
+
+  // Insert it at the new position
+  channel.queue.splice(newQueuedSlotNumber, 0, audioToMove);
+
+  // Emit queue change event
+  emitQueueChange(channelNumber, audioChannels);
+
+  const updatedQueue: QueueSnapshot | null = createQueueSnapshot(channelNumber, audioChannels);
+
+  return {
+    success: true,
+    updatedQueue: updatedQueue ?? undefined
+  };
+};
+
+/**
+ * Clears all queued audio items after the currently playing item
+ * The current audio will continue playing but nothing will follow it
+ * @param channelNumber - The channel number (defaults to 0)
+ * @returns Promise resolving to operation result with success status and updated queue
+ * @example
+ * ```typescript
+ * // Let current song finish but clear everything after it
+ * const result = await clearQueueAfterCurrent(0);
+ * if (result.success) {
+ *   console.log(`Cleared queue, current audio will be the last to play`);
+ * }
+ * ```
+ */
+export const clearQueueAfterCurrent = async (
+  channelNumber: number = 0
+): Promise<QueueManipulationResult> => {
+  const channel: ExtendedAudioQueueChannel = audioChannels[channelNumber];
+
+  if (!channel) {
+    // For empty/non-existent channels, we can consider this a successful no-op
+    // since there's nothing to clear anyway
+    return {
+      success: true,
+      updatedQueue: {
+        channelNumber,
+        currentIndex: -1,
+        isPaused: false,
+        items: [],
+        totalItems: 0,
+        volume: 1.0
+      }
+    };
+  }
+
+  if (channel.queue.length <= 1) {
+    // Nothing to clear - either empty queue or only current audio
+    const updatedQueue: QueueSnapshot | null = createQueueSnapshot(channelNumber, audioChannels);
+    return {
+      success: true,
+      updatedQueue: updatedQueue ?? undefined
+    };
+  }
+
+  // Clean up progress tracking for all items except the current one
+  for (let i: number = 1; i < channel.queue.length; i++) {
+    cleanupProgressTracking(channel.queue[i], channelNumber, audioChannels);
+  }
+
+  // Keep only the currently playing audio (index 0)
+  channel.queue = channel.queue.slice(0, 1);
+
+  // Emit queue change event
+  emitQueueChange(channelNumber, audioChannels);
+
+  const updatedQueue: QueueSnapshot | null = createQueueSnapshot(channelNumber, audioChannels);
+
+  return {
+    success: true,
+    updatedQueue: updatedQueue ?? undefined
+  };
+};
+
+/**
+ * Gets information about a specific queue item by its slot number
+ * @param queueSlotNumber - Zero-based index of the queue item
+ * @param channelNumber - The channel number (defaults to 0)
+ * @returns QueueItem information or null if slot doesn't exist
+ * @example
+ * ```typescript
+ * const itemInfo = getQueueItemInfo(1, 0);
+ * if (itemInfo) {
+ *   console.log(`Next to play: ${itemInfo.fileName}`);
+ *   console.log(`Duration: ${itemInfo.duration}ms`);
+ * }
+ * ```
+ */
+export const getQueueItemInfo = (
+  queueSlotNumber: number,
+  channelNumber: number = 0
+): QueueItem | null => {
+  const channel: ExtendedAudioQueueChannel = audioChannels[channelNumber];
+
+  if (!channel || queueSlotNumber < 0 || queueSlotNumber >= channel.queue.length) {
+    return null;
+  }
+
+  const audio: HTMLAudioElement = channel.queue[queueSlotNumber];
+  const audioInfo = getAudioInfoFromElement(audio, channelNumber, audioChannels);
+
+  if (!audioInfo) {
+    return null;
+  }
+
+  const { duration, fileName, isLooping, isPlaying, src, volume } = audioInfo;
+
+  return {
+    duration,
+    fileName,
+    isCurrentlyPlaying: queueSlotNumber === 0 && isPlaying,
+    isLooping,
+    src,
+    volume
+  };
+};
+
+/**
+ * Gets the current queue length for a specific channel
+ * @param channelNumber - The channel number (defaults to 0)
+ * @returns Number of items in the queue, or 0 if channel doesn't exist
+ * @example
+ * ```typescript
+ * const queueSize = getQueueLength(0);
+ * console.log(`Channel 0 has ${queueSize} items in queue`);
+ * ```
+ */
+export const getQueueLength = (channelNumber: number = 0): number => {
+  const channel: ExtendedAudioQueueChannel = audioChannels[channelNumber];
+  return channel ? channel.queue.length : 0;
+};
+
+/**
+ * Swaps the positions of two queue items
+ * Cannot swap with the currently playing item (index 0)
+ * @param slotA - Zero-based index of first item to swap (must be > 0)
+ * @param slotB - Zero-based index of second item to swap (must be > 0)
+ * @param channelNumber - The channel number (defaults to 0)
+ * @returns Promise resolving to operation result with success status and updated queue
+ * @example
+ * ```typescript
+ * // Swap the second and third items in queue
+ * const result = await swapQueueItems(1, 2, 0);
+ * if (result.success) {
+ *   console.log('Items swapped successfully');
+ * }
+ * ```
+ */
+export const swapQueueItems = async (
+  slotA: number,
+  slotB: number,
+  channelNumber: number = 0
+): Promise<QueueManipulationResult> => {
+  const channel: ExtendedAudioQueueChannel = audioChannels[channelNumber];
+
+  if (!channel) {
+    return {
+      error: `Channel ${channelNumber} does not exist`,
+      success: false
+    };
+  }
+
+  if (slotA < 0 || slotA >= channel.queue.length) {
+    return {
+      error:
+        `Invalid slot A ${slotA}. Queue has ${channel.queue.length} items ` +
+        `(indices 0-${channel.queue.length - 1})`,
+      success: false
+    };
+  }
+
+  if (slotB < 0 || slotB >= channel.queue.length) {
+    return {
+      error:
+        `Invalid slot B ${slotB}. Queue has ${channel.queue.length} items ` +
+        `(indices 0-${channel.queue.length - 1})`,
+      success: false
+    };
+  }
+
+  if (slotA === 0 || slotB === 0) {
+    return {
+      error: 'Cannot swap with currently playing item (index 0)',
+      success: false
+    };
+  }
+
+  if (slotA === slotB) {
+    // No change needed, but return success
+    const updatedQueue: QueueSnapshot | null = createQueueSnapshot(channelNumber, audioChannels);
+    return {
+      success: true,
+      updatedQueue: updatedQueue ?? undefined
+    };
+  }
+
+  // Swap the audio elements
+  const temp: HTMLAudioElement = channel.queue[slotA];
+  channel.queue[slotA] = channel.queue[slotB];
+  channel.queue[slotB] = temp;
+
+  // Emit queue change event
+  emitQueueChange(channelNumber, audioChannels);
+
+  const updatedQueue: QueueSnapshot | null = createQueueSnapshot(channelNumber, audioChannels);
+
+  return {
+    success: true,
+    updatedQueue: updatedQueue ?? undefined
+  };
+};

package/src/types.ts

@@ -2,6 +2,17 @@
  * @fileoverview Type definitions for the audio-channel-queue package
  */
 
+/**
+ * Maximum number of audio channels allowed to prevent memory exhaustion
+ */
+export const MAX_CHANNELS: number = 64;
+
+/**
+ * Symbol used as a key for global (channel-wide) progress callbacks
+ * This avoids the need for `null as any` type assertions
+ */
+export const GLOBAL_PROGRESS_KEY: unique symbol = Symbol('global-progress-callbacks');
+
 /**
  * Array of HTMLAudioElement objects representing an audio queue
  */
@@ -10,7 +21,7 @@ export type AudioQueue = HTMLAudioElement[];
 /**
  * Basic audio queue channel structure
  */
-export type AudioQueueChannel = {
+export interface AudioQueueChannel {
   queue: AudioQueue;
 }
 
@@ -33,19 +44,33 @@ export interface VolumeConfig {
 }
 
 /**
- * Audio file configuration for queueing
+ * Configuration options for queuing audio
  */
 export interface AudioQueueOptions {
-  /** Whether to add the audio to the front of the queue (defaults to false) */
+  /** Whether to add this audio to the front of the queue (after currently playing) */
   addToFront?: boolean;
   /** Whether the audio should loop when it finishes */
   loop?: boolean;
-  /** Whether to add the audio with priority (same as addToFront) */
+  /** Maximum number of items allowed in the queue (defaults to unlimited) */
+  maxQueueSize?: number;
+  /** @deprecated Use addToFront instead. Legacy support for priority queuing */
   priority?: boolean;
-  /** Volume level for this specific audio file (0-1, defaults to channel volume) */
+  /** Volume level for this specific audio (0-1) */
   volume?: number;
 }
 
+/**
+ * Global queue configuration options
+ */
+export interface QueueConfig {
+  /** Default maximum queue size across all channels (defaults to unlimited) */
+  defaultMaxQueueSize?: number;
+  /** Whether to drop oldest items when queue is full (defaults to false - reject new items) */
+  dropOldestWhenFull?: boolean;
+  /** Whether to show warnings when queue limits are reached (defaults to true) */
+  showQueueWarnings?: boolean;
+}
+
 /**
  * Comprehensive audio information interface providing metadata about currently playing audio
  */
@@ -136,6 +161,18 @@ export interface QueueSnapshot {
   volume: number;
 }
 
+/**
+ * Information about a queue manipulation operation result
+ */
+export interface QueueManipulationResult {
+  /** Error message if operation failed */
+  error?: string;
+  /** Whether the operation was successful */
+  success: boolean;
+  /** The queue snapshot after the operation (if successful) */
+  updatedQueue?: QueueSnapshot;
+}
+
 /**
  * Callback function type for audio progress updates
  * @param info Current audio information
@@ -218,7 +255,7 @@ export interface ErrorRecoveryOptions {
 export type AudioErrorCallback = (errorInfo: AudioErrorInfo) => void;
 
 /**
- * Extended audio queue channel with error handling capabilities
+ * Extended audio channel with queue management and callback support
  */
 export interface ExtendedAudioQueueChannel {
   audioCompleteCallbacks: Set<AudioCompleteCallback>;
@@ -227,13 +264,16 @@ export interface ExtendedAudioQueueChannel {
   audioResumeCallbacks: Set<AudioResumeCallback>;
   audioStartCallbacks: Set<AudioStartCallback>;
   fadeState?: ChannelFadeState;
-  isPaused?: boolean;
-  progressCallbacks: Map<HTMLAudioElement | null, Set<ProgressCallback>>;
+  isPaused: boolean;
+  /** Active operation lock to prevent race conditions */
+  isLocked?: boolean;
+  /** Maximum allowed queue size for this channel */
+  maxQueueSize?: number;
+  progressCallbacks: Map<HTMLAudioElement | typeof GLOBAL_PROGRESS_KEY, Set<ProgressCallback>>;
   queue: HTMLAudioElement[];
   queueChangeCallbacks: Set<QueueChangeCallback>;
   retryConfig?: RetryConfig;
-  volume?: number;
-  volumeConfig?: VolumeConfig;
+  volume: number;
 }
 
 /**
@@ -255,6 +295,14 @@ export enum FadeType {
   Dramatic = 'dramatic'
 }
 
+/**
+ * Timer types for volume transitions to ensure proper cleanup
+ */
+export enum TimerType {
+  RequestAnimationFrame = 'raf',
+  Timeout = 'timeout'
+}
+
 /**
  * Configuration for fade transitions
  */
@@ -277,4 +325,8 @@ export interface ChannelFadeState {
   fadeType: FadeType;
   /** Whether the channel is currently paused due to fade */
   isPaused: boolean;
-} 
+  /** Custom duration in milliseconds if specified (overrides fade type default) */
+  customDuration?: number;
+  /** Whether the channel is currently transitioning (during any fade operation) to prevent capturing intermediate volumes during rapid pause/resume toggles */
+  isTransitioning?: boolean;
+}

package/src/utils.ts

@@ -4,6 +4,101 @@
 
 import { AudioInfo, QueueSnapshot, ExtendedAudioQueueChannel, QueueItem } from './types';
 
+/**
+ * Validates an audio URL for security and correctness
+ * @param url - The URL to validate
+ * @returns The validated URL
+ * @throws Error if the URL is invalid or potentially malicious
+ * @example
+ * ```typescript
+ * validateAudioUrl('https://example.com/audio.mp3'); // Valid
+ * validateAudioUrl('./sounds/local.wav'); // Valid relative path
+ * validateAudioUrl('javascript:alert("XSS")'); // Throws error
+ * validateAudioUrl('data:text/html,<script>alert("XSS")</script>'); // Throws error
+ * ```
+ */
+export const validateAudioUrl = (url: string): string => {
+  if (!url || typeof url !== 'string') {
+    throw new Error('Audio URL must be a non-empty string');
+  }
+
+  // Trim whitespace
+  const trimmedUrl: string = url.trim();
+
+  // Check for dangerous protocols
+  const dangerousProtocols: string[] = [
+    'javascript:',
+    'data:',
+    'vbscript:',
+    'file:',
+    'about:',
+    'chrome:',
+    'chrome-extension:'
+  ];
+
+  const lowerUrl: string = trimmedUrl.toLowerCase();
+  for (const protocol of dangerousProtocols) {
+    if (lowerUrl.startsWith(protocol)) {
+      throw new Error(`Invalid audio URL: dangerous protocol "${protocol}" is not allowed`);
+    }
+  }
+
+  // Check for path traversal attempts
+  if (trimmedUrl.includes('../') || trimmedUrl.includes('..\\')) {
+    throw new Error('Invalid audio URL: path traversal attempts are not allowed');
+  }
+
+  // For relative URLs, ensure they don't start with dangerous characters
+  if (!trimmedUrl.startsWith('http://') && !trimmedUrl.startsWith('https://')) {
+    // Check for protocol-less URLs that might be interpreted as protocols
+    if (trimmedUrl.includes(':') && !trimmedUrl.startsWith('//')) {
+      const colonIndex: number = trimmedUrl.indexOf(':');
+      const beforeColon: string = trimmedUrl.substring(0, colonIndex);
+      // Allow only if it looks like a Windows drive letter (e.g., C:)
+      if (!/^[a-zA-Z]$/.test(beforeColon)) {
+        throw new Error('Invalid audio URL: suspicious protocol-like pattern detected');
+      }
+    }
+  }
+
+  // Validate common audio file extensions (warning, not error)
+  const hasAudioExtension: boolean = /\.(mp3|wav|ogg|m4a|webm|aac|flac|opus|weba|mp4)$/i.test(
+    trimmedUrl
+  );
+  if (!hasAudioExtension && !trimmedUrl.includes('?')) {
+    // Log warning but don't throw - some valid URLs might not have extensions
+    // eslint-disable-next-line no-console
+    console.warn(`Audio URL "${trimmedUrl}" does not have a recognized audio file extension`);
+  }
+
+  return trimmedUrl;
+};
+
+/**
+ * Sanitizes a string for safe display in HTML contexts
+ * @param text - The text to sanitize
+ * @returns The sanitized text safe for display
+ * @example
+ * ```typescript
+ * sanitizeForDisplay('<script>alert("XSS")</script>'); // Returns: '&lt;script&gt;alert("XSS")&lt;/script&gt;'
+ * sanitizeForDisplay('normal-file.mp3'); // Returns: 'normal-file.mp3'
+ * ```
+ */
+export const sanitizeForDisplay = (text: string): string => {
+  if (!text || typeof text !== 'string') {
+    return '';
+  }
+
+  // Replace HTML special characters
+  return text
+    .replace(/&/g, '&amp;')
+    .replace(/</g, '&lt;')
+    .replace(/>/g, '&gt;')
+    .replace(/"/g, '&quot;')
+    .replace(/'/g, '&#x27;')
+    .replace(/\//g, '&#x2F;');
+};
+
 /**
  * Extracts the filename from a URL string
  * @param url - The URL to extract the filename from
@@ -15,17 +110,23 @@ import { AudioInfo, QueueSnapshot, ExtendedAudioQueueChannel, QueueItem } from '
  * ```
  */
 export const extractFileName = (url: string): string => {
+  if (!url || typeof url !== 'string') {
+    return sanitizeForDisplay('unknown');
+  }
+
+  // Always use simple string manipulation for consistency
+  const segments: string[] = url.split('/');
+  const lastSegment: string = segments[segments.length - 1] || '';
+
+  // Remove query parameters and hash
+  const fileName: string = lastSegment.split('?')[0].split('#')[0];
+
+  // Decode URI components and sanitize
   try {
-    const urlObj: URL = new URL(url);
-    const pathname: string = urlObj.pathname;
-    const segments: string[] = pathname.split('/');
-    const fileName: string = segments[segments.length - 1];
-    return fileName || 'unknown';
+    return sanitizeForDisplay(decodeURIComponent(fileName || 'unknown'));
   } catch {
-    // If URL parsing fails, try simple string manipulation
-    const segments: string[] = url.split('/');
-    const fileName: string = segments[segments.length - 1];
-    return fileName || 'unknown';
+    // If decoding fails, return the sanitized raw filename
+    return sanitizeForDisplay(fileName || 'unknown');
   }
 };
 
@@ -40,14 +141,14 @@ export const extractFileName = (url: string): string => {
  * 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 const getAudioInfoFromElement = (
-  audio: HTMLAudioElement, 
+  audio: HTMLAudioElement,
   channelNumber?: number,
   audioChannels?: ExtendedAudioQueueChannel[]
 ): AudioInfo | null => {
@@ -60,7 +161,7 @@ export const getAudioInfoFromElement = (
 
   // Calculate remainingInQueue if channel context is provided
   let remainingInQueue: number = 0;
-  if (channelNumber !== undefined && audioChannels && audioChannels[channelNumber]) {
+  if (channelNumber !== undefined && audioChannels?.[channelNumber]) {
     const channel = audioChannels[channelNumber];
     remainingInQueue = Math.max(0, channel.queue.length - 1); // Exclude current playing audio
   }
@@ -91,7 +192,7 @@ export const getAudioInfoFromElement = (
  * ```
  */
 export const createQueueSnapshot = (
-  channelNumber: number, 
+  channelNumber: number,
   audioChannels: ExtendedAudioQueueChannel[]
 ): QueueSnapshot | null => {
   const channel: ExtendedAudioQueueChannel = audioChannels[channelNumber];
@@ -109,10 +210,10 @@ export const createQueueSnapshot = (
   return {
     channelNumber,
     currentIndex: 0, // Current playing is always index 0 in our queue structure
-    isPaused: channel.isPaused || false,
+    isPaused: channel.isPaused ?? false,
     items,
     totalItems: channel.queue.length,
-    volume: channel.volume || 1.0
+    volume: channel.volume ?? 1.0
   };
 };
 
@@ -131,4 +232,4 @@ export const createQueueSnapshot = (
 export const cleanWebpackFilename = (fileName: string): string => {
   // Remove webpack hash pattern: filename.hash.ext → filename.ext
   return fileName.replace(/\.[a-f0-9]{8,}\./i, '.');
-}; 
+};