Proper deduplication

Author: NellowTCS

Build/package-lock.json

@@ -488,12 +488,8 @@ export async function extractAudioMetadata(file: File): Promise<AudioMetadata> {
   if (ext === "flo") {
     try {
       const arrayBuffer = await file.arrayBuffer();
-      const {
-        getFloMetadata,
-        getFloCoverArt,
-        getFloSyncedLyrics,
-        getFloInfo
-      } = await import("./floProcessor");
+      const { getFloMetadata, getFloCoverArt, getFloSyncedLyrics, getFloInfo } =
+        await import("./floProcessor");
 
       // Get all flo data in parallel
       const [meta, cover, lyrics, info] = await Promise.all([
@@ -574,10 +570,13 @@ export async function extractAudioMetadata(file: File): Promise<AudioMetadata> {
   }
   // Fallback to original (music-metadata) for all other formats
   let MetadataWorkerType: typeof Worker;
-  if ((typeof __IS_SINGLE_FILE__ !== "undefined") && __IS_SINGLE_FILE__) {
-    MetadataWorkerType = (await import("../workers/metadataWorker.ts?worker&inline")).default;
+  if (typeof __IS_SINGLE_FILE__ !== "undefined" && __IS_SINGLE_FILE__) {
+    MetadataWorkerType = (
+      await import("../workers/metadataWorker.ts?worker&inline")
+    ).default;
   } else {
-    MetadataWorkerType = (await import("../workers/metadataWorker.ts?worker")).default;
+    MetadataWorkerType = (await import("../workers/metadataWorker.ts?worker"))
+      .default;
   }
   const worker = new MetadataWorkerType();
 
@@ -725,7 +724,7 @@ export function setupFileHandler(
     typeof window.launchQueue.setConsumer !== "function"
   ) {
     console.warn("File Handling API not supported in this browser");
-    return () => { }; // Return empty cleanup function
+    return () => {}; // Return empty cleanup function
   }
 
   const consumer = async (launchParams: any) => {
@@ -790,7 +789,7 @@ export function setupFileHandler(
       typeof window.launchQueue.setConsumer === "function"
     ) {
       try {
-        window.launchQueue.setConsumer(() => { });
+        window.launchQueue.setConsumer(() => {});
       } catch (e) {
         console.warn("Could not clear file handler consumer:", e);
       }
@@ -835,7 +834,7 @@ export function handleShareTarget(): ShareTargetResult | null {
 }
 
 export function useShareTarget(
-  onShareReceived: (result: ShareTargetResult) => void
+  onShareReceived: (result: ShareTargetResult) => void,
 ) {
   const hasProcessedRef = useRef(false);
 
@@ -862,12 +861,35 @@ export function useShareTarget(
           }
 
           if (files.length > 0) {
-            hasProcessedRef.current = true;
-            onShareReceived({ files, type: "files" });
-
-            // Cleanup the cache after processing
-            for (const key of keys) {
-              await cache.delete(key);
+            // Filter out already processed files
+            const processedFiles = JSON.parse(
+              sessionStorage.getItem("processedFiles") || "[]",
+            );
+            const newFiles = files.filter((file) => {
+              const fileId = `${file.name}-${file.size}-${file.lastModified}`;
+              return !processedFiles.includes(fileId);
+            });
+
+            if (newFiles.length > 0) {
+              hasProcessedRef.current = true;
+              onShareReceived({ files: newFiles, type: "files" });
+
+              // Mark files as processed
+              const updatedProcessed = [
+                ...processedFiles,
+                ...newFiles.map(
+                  (file) => `${file.name}-${file.size}-${file.lastModified}`,
+                ),
+              ];
+              sessionStorage.setItem(
+                "processedFiles",
+                JSON.stringify(updatedProcessed),
+              );
+
+              // Cleanup the cache after processing
+              for (const key of keys) {
+                await cache.delete(key);
+              }
             }
 
             const cleanUrl = new URL(window.location.href);
@@ -880,7 +902,7 @@ export function useShareTarget(
         }
       }
 
-      // Fallback to text sharing (e.g., query parameters)
+      // Fallback to text sharing
       const shareResult = handleShareTarget();
       if (shareResult) {
         hasProcessedRef.current = true;

Build/src/helpers/filePickerHelper.tsx

@@ -16,34 +16,34 @@ export async function decodeFloToAudioBuffer(
   audioContext: AudioContext,
 ): Promise<AudioBuffer> {
   await ensureFloInitialized();
-  
+
   const uint8Flo = new Uint8Array(floData);
-  
+
   // Decode flo to interleaved Float32Array samples
   const samples = flo.decode(uint8Flo);
-  
+
   // Get file info for audio properties
   const fileInfo = flo.info(uint8Flo);
   const { channels, sample_rate } = fileInfo;
-  
+
   // Calculate number of frames
   const frameCount = samples.length / channels;
-  
+
   // Create AudioBuffer
   const audioBuffer = audioContext.createBuffer(
     channels,
     frameCount,
-    sample_rate
+    sample_rate,
   );
-  
+
   // Deinterleave samples into separate channels
   for (let ch = 0; ch < channels; ch++) {
     const channelData = audioBuffer.getChannelData(ch);
     for (let i = 0; i < frameCount; i++) {
       channelData[i] = samples[i * channels + ch];
     }
   }
-  
+
   return audioBuffer;
 }
 
@@ -69,9 +69,7 @@ export async function validateFlo(floData: ArrayBuffer): Promise<boolean> {
 }
 
 // Extract metadata as JS object (returns null if no metadata)
-export async function getFloMetadata(
-  floData: ArrayBuffer,
-): Promise<{
+export async function getFloMetadata(floData: ArrayBuffer): Promise<{
   title?: string;
   artist?: string;
   album?: string;
@@ -109,4 +107,4 @@ export async function createFloMetadataFromObject(
 }
 
 // Export initialization function
-export { initFlo, ensureFloInitialized };
+export { initFlo, ensureFloInitialized };

Build/src/helpers/floProcessor.ts

@@ -6,7 +6,7 @@ import { setAlbumArtInCache } from "../hooks/useAlbumArt";
 export async function importAudioFiles(
   audioFiles: Array<{ file: File } | File>,
   addSong: (song: Song, file: File) => Promise<void>,
-  t: any,
+  t: any
 ) {
   if (!audioFiles || audioFiles.length === 0) return;
 
@@ -32,31 +32,36 @@ export async function importAudioFiles(
         let processedMimeType = file.type;
 
         const isFlo =
-          file.name.toLowerCase().endsWith('.flo') ||
-          metadata.encoding?.codec === 'flo';
+          file.name.toLowerCase().endsWith(".flo") ||
+          metadata.encoding?.codec === "flo";
 
         if (isFlo) {
           try {
             const arrayBuffer = await file.arrayBuffer();
-            const isSafari = /^((?!chrome|android).)*safari/i.test(navigator.userAgent);
+            const isSafari = /^((?!chrome|android).)*safari/i.test(
+              navigator.userAgent
+            );
 
             if (isSafari) {
               // Safari: Pre-decode to WAV for compatibility
               const { decodeFloToWav } = await import("./refloWavHelper");
               const wavBytes = await decodeFloToWav(arrayBuffer);
-              const wavBlob = new Blob([wavBytes], { type: 'audio/wav' });
+              const wavBlob = new Blob([wavBytes], { type: "audio/wav" });
               processedFile = new File(
                 [wavBlob],
-                file.name.replace(/\.flo$/i, '.wav'),
-                { type: 'audio/wav' }
+                file.name.replace(/\.flo$/i, ".wav"),
+                { type: "audio/wav" }
               );
-              processedMimeType = 'audio/wav';
+              processedMimeType = "audio/wav";
               console.log(`Pre-decoded flo to WAV for Safari: ${file.name}`);
             } else {
               // Non-Safari: Pre-decode to PCM for Web Audio API
               const { decodeFloToAudioBuffer } = await import("./floProcessor");
               const audioContext = new AudioContext();
-              const audioBuffer = await decodeFloToAudioBuffer(arrayBuffer, audioContext);
+              const audioBuffer = await decodeFloToAudioBuffer(
+                arrayBuffer,
+                audioContext
+              );
 
               // Store as interleaved Float32Array PCM
               const frameCount = audioBuffer.length;
@@ -66,25 +71,26 @@ export async function importAudioFiles(
               // Interleave channels
               for (let i = 0; i < frameCount; i++) {
                 for (let ch = 0; ch < channels; ch++) {
-                  pcmData[i * channels + ch] = audioBuffer.getChannelData(ch)[i];
+                  pcmData[i * channels + ch] =
+                    audioBuffer.getChannelData(ch)[i];
                 }
               }
 
-              const pcmBlob = new Blob([pcmData.buffer], { type: 'audio/pcm' });
+              const pcmBlob = new Blob([pcmData.buffer], { type: "audio/pcm" });
               processedFile = new File(
                 [pcmBlob],
-                file.name.replace(/\.flo$/i, '.pcm'),
-                { type: 'audio/pcm' }
+                file.name.replace(/\.flo$/i, ".pcm"),
+                { type: "audio/pcm" }
               );
-              processedMimeType = 'audio/pcm';
+              processedMimeType = "audio/pcm";
 
               // Store AudioBuffer properties for reconstruction
               metadata.encoding = {
                 ...metadata.encoding,
                 sampleRate: audioBuffer.sampleRate,
                 channels: audioBuffer.numberOfChannels,
                 bitsPerSample: 32, // Float32
-                codec: 'pcm-float32',
+                codec: "pcm-float32",
               };
 
               // Close the temporary AudioContext
@@ -93,9 +99,12 @@ export async function importAudioFiles(
               console.log(`Pre-decoded flo to PCM: ${file.name}`);
             }
           } catch (error) {
-            console.warn("Failed to pre-decode flo file, storing original:", error);
+            console.warn(
+              "Failed to pre-decode flo file, storing original:",
+              error
+            );
             // Keep original file if pre-decoding fails
-            processedMimeType = 'audio/x-flo';
+            processedMimeType = "audio/x-flo";
           }
         }
 
@@ -110,7 +119,9 @@ export async function importAudioFiles(
           id: songId,
           title: metadata.title,
           artist: metadata.artist,
-          album: metadata.album || t("songInfo.album", { title: t("common.unknownAlbum") }),
+          album:
+            metadata.album ||
+            t("songInfo.album", { title: t("common.unknownAlbum") }),
           duration: metadata.duration,
           url: "", // Will be set by addSong
           albumArt: metadata.albumArt, // Keep for immediate display

Build/src/helpers/importAudioFiles.tsx

@@ -12,21 +12,21 @@ async function ensureRefloInitialized() {
 /**
  * Decode a .flo file to WAV format using @flo-audio/reflo
  * This is used for Safari which needs standard formats for background playback
- * 
+ *
  * @param floData - ArrayBuffer containing flo audio data
  * @returns Uint8Array containing complete WAV file (headers + audio data)
  */
 export async function decodeFloToWav(
   floData: ArrayBuffer,
 ): Promise<Uint8Array> {
   await ensureRefloInitialized();
-  
+
   const uint8Flo = new Uint8Array(floData);
-  
+
   // reflo.decode_flo_to_wav returns a complete WAV file
   const wavData = reflo.decode_flo_to_wav(uint8Flo);
-  
+
   return wavData;
 }
 
-export { initReflo, ensureRefloInitialized };
+export { initReflo, ensureRefloInitialized };