Revert "Deduplication"

This reverts commit 00ecba7.

Author: NellowTCS

Build/src/helpers/filePickerHelper.tsx

@@ -834,9 +834,10 @@ export function handleShareTarget(): ShareTargetResult | null {
   return null; // Will be handled in useShareTarget
 }
 
-export function useShareTarget(onShareReceived: (result: ShareTargetResult) => void) {
+export function useShareTarget(
+  onShareReceived: (result: ShareTargetResult) => void
+) {
   const hasProcessedRef = useRef(false);
-  const processedFilesRef = useRef<Set<string>>(new Set()); // Track processed file IDs
 
   useEffect(() => {
     if (hasProcessedRef.current) return;
@@ -854,14 +855,9 @@ export function useShareTarget(onShareReceived: (result: ShareTargetResult) => v
             if (key.url.includes("/shared-file-")) {
               const response = await cache.match(key);
               const blob = await response?.blob();
-              const fileName = response?.headers.get("x-file-name") || "unknown-file";
-
-              // Generate a unique ID for each file (name + size + lastModified)
-              const id = `${fileName}-${blob?.size}`;
-              if (!processedFilesRef.current.has(id)) {
-                processedFilesRef.current.add(id); // Mark as processed
-                files.push(new File([blob!], fileName, { type: blob?.type }));
-              }
+              const fileName =
+                response?.headers.get("x-file-name") || "unknown-file";
+              files.push(new File([blob!], fileName, { type: blob?.type }));
             }
           }
 
@@ -884,6 +880,7 @@ export function useShareTarget(onShareReceived: (result: ShareTargetResult) => v
         }
       }
 
+      // Fallback to text sharing (e.g., query parameters)
       const shareResult = handleShareTarget();
       if (shareResult) {
         hasProcessedRef.current = true;

Build/src/helpers/importAudioFiles.tsx

@@ -6,41 +6,24 @@ 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;
 
   const BATCH_SIZE = 10;
   let successCount = 0;
   let errorCount = 0;
-  let skippedCount = 0; // Count skipped duplicates
   let currentBatch = 1;
   const totalBatches = Math.ceil(audioFiles.length / BATCH_SIZE);
 
-  // Track unique files to avoid duplicate imports in this session
-  const processedFileIds = new Set<string>();
-
   for (let i = 0; i < audioFiles.length; i += BATCH_SIZE) {
     const batch = audioFiles.slice(i, i + BATCH_SIZE);
-    toast.loading(
-      t("batch.processing", { currentBatch, totalBatches, successCount })
-    );
+    toast.loading(t("batch.processing", { currentBatch, totalBatches }));
 
     // Process sequentially to reduce memory pressure
     for (const audioFile of batch) {
       try {
         const file: File = (audioFile as any).file || (audioFile as File);
-
-        // Unique ID based on file metadata (name, size, lastModified)
-        const fileId = `${file.name}-${file.size}-${file.lastModified}`;
-        if (processedFileIds.has(fileId)) {
-          // Skip duplicates detected via unique ID
-          console.log(`Skipping duplicate file: ${file.name}`);
-          skippedCount++;
-          continue;
-        }
-        processedFileIds.add(fileId); // Mark the file as processed
-
         const metadata = await extractAudioMetadata(file);
         const songId = generateUniqueId();
 
@@ -49,36 +32,31 @@ 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;
@@ -88,27 +66,25 @@ 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
@@ -119,27 +95,22 @@ export async function importAudioFiles(
           } catch (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';
           }
         }
 
         // Save album art separately if present
         const hasAlbumArt = !!metadata.albumArt;
         if (hasAlbumArt && metadata.albumArt) {
-          await musicIndexedDbHelper.saveAlbumArt(
-            songId,
-            metadata.albumArt
-          );
+          await musicIndexedDbHelper.saveAlbumArt(songId, metadata.albumArt);
           setAlbumArtInCache(songId, metadata.albumArt);
         }
 
         const song: Song = {
           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
@@ -171,14 +142,8 @@ export async function importAudioFiles(
   }
 
   toast.dismiss();
-  // Show accurate results with skipped files count
   if (successCount > 0) {
-    toast.success(
-      t("filePicker.successImport", {
-        count: successCount,
-        skipped: skippedCount,
-      })
-    );
+    toast.success(t("filePicker.successImport", { count: successCount }));
   }
   if (errorCount > 0) {
     toast.error(t("filePicker.failedImport", { count: errorCount }));

Build/src/workers/sw.ts

@@ -7,47 +7,41 @@ precacheAndRoute(self.__WB_MANIFEST);
 // Handle SPA navigation requests
 const handler = createHandlerBoundToURL("index.html");
 const navigationRoute = new NavigationRoute(handler, {
-    allowlist: [/^\/beta\/HTMLPlayer\//],
+  allowlist: [/^\/beta\/HTMLPlayer\//],
 });
 registerRoute(navigationRoute);
 
 // Handle POST requests for file sharing
 registerRoute(
-    ({ url, request }) => {
-        return url.pathname === "/beta/HTMLPlayer/" && request.method === "POST";
-    },
-    async ({ event }) => {
-        try {
-            const formData = await event.request.formData();
-            const cache = await caches.open("incoming-shares");
+  ({ url, request }) => {
+    return url.pathname === "/beta/HTMLPlayer/" && request.method === "POST";
+  },
+  async ({ event }) => {
+    try {
+      const formData = await event.request.formData();
+      const cache = await caches.open("incoming-shares");
 
-            // Keep track of already cached files during this session
-            const existingKeys = new Set(
-                (await cache.keys()).map((key) => key.url.split("/").pop())
-            );
-
-            const files = [];
-            for (const [value] of formData.entries()) {
-                if (value instanceof File) {
-                    const uniqueKey = `shared-file-${value.name}`;
-                    if (!existingKeys.has(uniqueKey)) {
-                        // Only cache if it's not already cached
-                        await cache.put(uniqueKey, new Response(value, {
-                            headers: { "x-file-name": value.name },
-                        }));
-                        files.push(uniqueKey);
-                    }
-                }
-            }
-
-            const redirectUrl = new URL(
-                `/beta/HTMLPlayer/?share-received=true&files=${files.length}`,
-                self.location.origin
-            );
-            return Response.redirect(redirectUrl.href, 303);
-        } catch (e) {
-            return new Response("Failed to process file share", { status: 400 });
+      // Process all files in the form data
+      const files = [];
+      for (const [key, value] of formData.entries()) {
+        if (value instanceof File) {
+          files.push({ file: value, key });
+          await cache.put(`/shared-file-${value.name}`, new Response(value, {
+            headers: { "x-file-name": value.name, "content-type": value.type },
+          }));
         }
-    },
-    "POST"
+      }
+
+      // Redirect to the app with an indicator for file sharing
+      const redirectUrl = new URL(
+        `/beta/HTMLPlayer/?share-received=true&files=${files.length}`,
+        self.location.origin
+      );
+      return Response.redirect(redirectUrl.href, 303);
+    } catch (e) {
+      // Always return a response even on error
+      return new Response("Failed to process file share", { status: 400 });
+    }
+  },
+  "POST"
 );