feat: add fflate library for file decompression and implement file download functionality in BookOfflineButton component

src/components/ui/book-offline-button.tsx

@@ -6,6 +6,7 @@ import { Button } from "./button";
 import { useToast } from "./use-toast";
 import type { KomgaBook } from "@/types/komga";
 import logger from "@/lib/logger";
+import { unzip } from "fflate";
 
 interface BookOfflineButtonProps {
   book: KomgaBook;
@@ -57,92 +58,101 @@ export function BookOfflineButton({ book, className }: BookOfflineButtonProps) {
         // Marque le début du téléchargement
         setBookStatus(book.id, {
           status: "downloading",
-          progress: ((startFromPage - 1) / book.media.pagesCount) * 100,
+          progress: 0,
           timestamp: Date.now(),
-          lastDownloadedPage: startFromPage - 1,
+          lastDownloadedPage: 0,
         });
 
-        // Ajoute le livre au cache si on commence depuis le début
-        if (startFromPage === 1) {
-          const pagesResponse = await fetch(`/api/komga/images/books/${book.id}/pages/1`);
-          if (!pagesResponse.ok) throw new Error("Erreur lors de la récupération des pages");
-          await cache.put(`/api/komga/images/books/${book.id}/pages`, pagesResponse.clone());
+        // Télécharger le fichier complet
+        setDownloadProgress(5);
+        const fileResponse = await fetch(`/api/komga/books/${book.id}/file`);
+        if (!fileResponse.ok) throw new Error("Erreur lors du téléchargement du fichier");
+
+        setDownloadProgress(20);
+        const arrayBuffer = await fileResponse.arrayBuffer();
+
+        setDownloadProgress(30);
+        setBookStatus(book.id, {
+          status: "downloading",
+          progress: 30,
+          timestamp: Date.now(),
+        });
+
+        // Décompresser le fichier
+        const files = await new Promise<Record<string, Uint8Array>>((resolve, reject) => {
+          unzip(new Uint8Array(arrayBuffer), (err, data) => {
+            if (err) reject(err);
+            else resolve(data);
+          });
+        });
+
+        setDownloadProgress(50);
+
+        // Filtrer et trier les images
+        const imageExtensions = /\.(jpg|jpeg|png|webp|gif)$/i;
+        const imageFiles = Object.entries(files)
+          .filter(([name]) => imageExtensions.test(name))
+          .sort(([a], [b]) => a.localeCompare(b, undefined, { numeric: true }));
+
+        if (imageFiles.length === 0) {
+          throw new Error("Aucune image trouvée dans le fichier");
         }
 
-        // Cache chaque page avec retry
-        let failedPages = 0;
-        for (let i = startFromPage; i <= book.media.pagesCount; i++) {
-          let retryCount = 0;
-          const maxRetries = 3;
+        // Cache chaque image
+        for (let i = 0; i < imageFiles.length; i++) {
+          const [fileName, data] = imageFiles[i];
+          const pageNumber = i + 1;
 
-          while (retryCount < maxRetries) {
-            try {
-              const pageResponse = await fetch(`/api/komga/images/books/${book.id}/pages/${i}`);
-              if (!pageResponse.ok) {
-                retryCount++;
-                if (retryCount === maxRetries) {
-                  failedPages++;
-                  logger.error(
-                    `Échec du téléchargement de la page ${i} après ${maxRetries} tentatives`
-                  );
-                }
-                await new Promise((resolve) => setTimeout(resolve, 1000)); // Attendre 1s avant de réessayer
-                continue;
-              }
-              await cache.put(
-                `/api/komga/images/books/${book.id}/pages/${i}`,
-                pageResponse.clone()
-              );
-              break; // Sortir de la boucle si réussi
-            } catch (error) {
-              retryCount++;
-              if (retryCount === maxRetries) {
-                failedPages++;
-                logger.error({ err: error }, `Erreur lors du téléchargement de la page ${i}:`);
-              }
-              await new Promise((resolve) => setTimeout(resolve, 1000));
-            }
-          }
+          // Déterminer le type MIME
+          const ext = fileName.toLowerCase().split(".").pop();
+          const mimeType =
+            ext === "png"
+              ? "image/png"
+              : ext === "webp"
+                ? "image/webp"
+                : ext === "gif"
+                  ? "image/gif"
+                  : "image/jpeg";
+
+          const blob = new Blob([data], { type: mimeType });
+          const fakeResponse = new Response(blob, {
+            headers: {
+              "Content-Type": mimeType,
+              "Content-Length": String(data.length),
+            },
+          });
+
+          await cache.put(`/api/komga/images/books/${book.id}/pages/${pageNumber}`, fakeResponse);
 
           // Mise à jour du statut
-          const progress = (i / book.media.pagesCount) * 100;
+          const progress = 50 + ((i + 1) / imageFiles.length) * 50;
           setDownloadProgress(progress);
           setBookStatus(book.id, {
             status: "downloading",
             progress,
             timestamp: Date.now(),
-            lastDownloadedPage: i,
+            lastDownloadedPage: pageNumber,
           });
 
           // Vérifier si le statut a changé pendant le téléchargement
           const currentStatus = getBookStatus(book.id);
           if (currentStatus.status === "idle") {
-            // Le téléchargement a été annulé
             throw new Error("Téléchargement annulé");
           }
         }
 
-        if (failedPages > 0) {
-          // Si des pages ont échoué, on supprime tout le cache pour ce livre
-          await cache.delete(`/api/komga/images/books/${book.id}/pages`);
-          for (let i = 1; i <= book.media.pagesCount; i++) {
-            await cache.delete(`/api/komga/images/books/${book.id}/pages/${i}`);
-          }
-          setIsAvailableOffline(false);
-          setBookStatus(book.id, { status: "error", progress: 0, timestamp: Date.now() });
-          toast({
-            title: "Erreur",
-            description: `${failedPages} page(s) n'ont pas pu être téléchargées. Le livre ne sera pas disponible hors ligne.`,
-            variant: "destructive",
-          });
-        } else {
-          setIsAvailableOffline(true);
-          setBookStatus(book.id, { status: "available", progress: 100, timestamp: Date.now() });
-          toast({
-            title: "Livre téléchargé",
-            description: "Le livre est maintenant disponible hors ligne",
-          });
-        }
+        // Marquer comme disponible
+        const pagesMetaResponse = new Response(JSON.stringify({ count: imageFiles.length }), {
+          headers: { "Content-Type": "application/json" },
+        });
+        await cache.put(`/api/komga/images/books/${book.id}/pages`, pagesMetaResponse);
+
+        setIsAvailableOffline(true);
+        setBookStatus(book.id, { status: "available", progress: 100, timestamp: Date.now() });
+        toast({
+          title: "Livre téléchargé",
+          description: `${imageFiles.length} pages disponibles hors ligne`,
+        });
       } catch (error) {
         logger.error({ err: error }, "Erreur lors du téléchargement:");
         // Ne pas changer le statut si le téléchargement a été volontairement annulé
@@ -159,7 +169,7 @@ export function BookOfflineButton({ book, className }: BookOfflineButtonProps) {
         setDownloadProgress(0);
       }
     },
-    [book.id, book.media.pagesCount, getBookStatus, setBookStatus, toast]
+    [book.id, getBookStatus, setBookStatus, toast]
   );
 
   const checkOfflineAvailability = useCallback(async () => {