@gallop.software/studio 0.1.24 → 0.1.26

package/dist/handlers.js

@@ -22,8 +22,8 @@ async function GET(request) {
   if (route === "scan") {
     return handleScan();
   }
-  if (route === "count-unprocessed") {
-    return handleCountUnprocessed();
+  if (route === "count-images") {
+    return handleCountImages();
   }
   return _server.NextResponse.json({ error: "Not found" }, { status: 404 });
 }
@@ -46,7 +46,7 @@ async function POST(request) {
     return handleReprocess(request);
   }
   if (route === "process-all") {
-    return handleProcessAll();
+    return handleProcessAllStream();
   }
   return _server.NextResponse.json({ error: "Not found" }, { status: 404 });
 }
@@ -494,10 +494,9 @@ async function handleReprocess(request) {
     return _server.NextResponse.json({ error: "Failed to reprocess images" }, { status: 500 });
   }
 }
-async function handleCountUnprocessed() {
+async function handleCountImages() {
   try {
-    const meta = await loadMeta();
-    const unprocessedImages = [];
+    const allImages = [];
     async function scanPublicFolder(dir, relativePath = "") {
       try {
         const entries = await _fs.promises.readdir(dir, { withFileTypes: true });
@@ -509,9 +508,7 @@ async function handleCountUnprocessed() {
           if (entry.isDirectory()) {
             await scanPublicFolder(fullPath, relPath);
           } else if (isImageFile(entry.name)) {
-            if (!meta.images[relPath]) {
-              unprocessedImages.push(relPath);
-            }
+            allImages.push(relPath);
           }
         }
       } catch (e7) {
@@ -520,163 +517,192 @@ async function handleCountUnprocessed() {
     const publicDir = _path2.default.join(process.cwd(), "public");
     await scanPublicFolder(publicDir);
     return _server.NextResponse.json({
-      count: unprocessedImages.length,
-      images: unprocessedImages
+      count: allImages.length,
+      images: allImages
     });
   } catch (error) {
-    console.error("Failed to count unprocessed images:", error);
-    return _server.NextResponse.json({ error: "Failed to count unprocessed images" }, { status: 500 });
+    console.error("Failed to count images:", error);
+    return _server.NextResponse.json({ error: "Failed to count images" }, { status: 500 });
   }
 }
-async function handleProcessAll() {
-  try {
-    const meta = await loadMeta();
-    const processed = [];
-    const errors = [];
-    const orphansRemoved = [];
-    const unprocessedImages = [];
-    async function scanPublicFolder(dir, relativePath = "") {
+async function handleProcessAllStream() {
+  const encoder = new TextEncoder();
+  const stream = new ReadableStream({
+    async start(controller) {
+      const sendEvent = (data) => {
+        controller.enqueue(encoder.encode(`data: ${JSON.stringify(data)}
+
+`));
+      };
       try {
-        const entries = await _fs.promises.readdir(dir, { withFileTypes: true });
-        for (const entry of entries) {
-          if (entry.name.startsWith(".")) continue;
-          const fullPath = _path2.default.join(dir, entry.name);
-          const relPath = relativePath ? `${relativePath}/${entry.name}` : entry.name;
-          if (relPath === "images" || relPath.startsWith("images/")) continue;
-          if (entry.isDirectory()) {
-            await scanPublicFolder(fullPath, relPath);
-          } else if (isImageFile(entry.name)) {
-            if (!meta.images[relPath]) {
-              unprocessedImages.push({ key: relPath, fullPath });
+        const meta = await loadMeta();
+        const processed = [];
+        const errors = [];
+        const orphansRemoved = [];
+        const allImages = [];
+        async function scanPublicFolder(dir, relativePath = "") {
+          try {
+            const entries = await _fs.promises.readdir(dir, { withFileTypes: true });
+            for (const entry of entries) {
+              if (entry.name.startsWith(".")) continue;
+              const fullPath = _path2.default.join(dir, entry.name);
+              const relPath = relativePath ? `${relativePath}/${entry.name}` : entry.name;
+              if (relPath === "images" || relPath.startsWith("images/")) continue;
+              if (entry.isDirectory()) {
+                await scanPublicFolder(fullPath, relPath);
+              } else if (isImageFile(entry.name)) {
+                allImages.push({ key: relPath, fullPath });
+              }
             }
+          } catch (e8) {
           }
         }
-      } catch (e8) {
-      }
-    }
-    const publicDir = _path2.default.join(process.cwd(), "public");
-    await scanPublicFolder(publicDir);
-    for (const { key, fullPath } of unprocessedImages) {
-      try {
-        const buffer = await _fs.promises.readFile(fullPath);
-        const ext = _path2.default.extname(key).toLowerCase();
-        const isSvg = ext === ".svg";
-        if (isSvg) {
-          const imageDir = _path2.default.dirname(key);
-          const imagesPath = _path2.default.join(process.cwd(), "public", "images", imageDir === "." ? "" : imageDir);
-          await _fs.promises.mkdir(imagesPath, { recursive: true });
-          const fileName = _path2.default.basename(key);
-          const destPath = _path2.default.join(imagesPath, fileName);
-          await _fs.promises.writeFile(destPath, buffer);
-          const sizePath = `/images/${imageDir === "." ? "" : imageDir + "/"}${fileName}`;
-          meta.images[key] = {
-            original: {
-              path: `/${key}`,
-              width: 0,
-              height: 0,
-              fileSize: buffer.length
-            },
-            sizes: {
-              full: { path: sizePath, width: 0, height: 0 },
-              large: { path: sizePath, width: 0, height: 0 },
-              medium: { path: sizePath, width: 0, height: 0 },
-              small: { path: sizePath, width: 0, height: 0 }
-            },
-            blurhash: "",
-            dominantColor: "#888888",
-            cdn: null
-          };
-        } else {
-          const dummyEntry = {
-            original: {
-              path: `/${key}`,
-              width: 0,
-              height: 0,
-              fileSize: buffer.length
-            },
-            sizes: {
-              full: { path: "", width: 0, height: 0 },
-              large: { path: "", width: 0, height: 0 },
-              medium: { path: "", width: 0, height: 0 },
-              small: { path: "", width: 0, height: 0 }
-            },
-            blurhash: "",
-            dominantColor: "#888888",
-            cdn: null
-          };
-          const processedEntry = await processImage(buffer, dummyEntry, key);
-          meta.images[key] = processedEntry;
+        const publicDir = _path2.default.join(process.cwd(), "public");
+        await scanPublicFolder(publicDir);
+        const total = allImages.length;
+        sendEvent({ type: "start", total });
+        for (let i = 0; i < allImages.length; i++) {
+          const { key, fullPath } = allImages[i];
+          sendEvent({
+            type: "progress",
+            current: i + 1,
+            total,
+            percent: Math.round((i + 1) / total * 100),
+            currentFile: key
+          });
+          try {
+            const buffer = await _fs.promises.readFile(fullPath);
+            const ext = _path2.default.extname(key).toLowerCase();
+            const isSvg = ext === ".svg";
+            if (isSvg) {
+              const imageDir = _path2.default.dirname(key);
+              const imagesPath = _path2.default.join(process.cwd(), "public", "images", imageDir === "." ? "" : imageDir);
+              await _fs.promises.mkdir(imagesPath, { recursive: true });
+              const fileName = _path2.default.basename(key);
+              const destPath = _path2.default.join(imagesPath, fileName);
+              await _fs.promises.writeFile(destPath, buffer);
+              const sizePath = `/images/${imageDir === "." ? "" : imageDir + "/"}${fileName}`;
+              meta.images[key] = {
+                original: {
+                  path: `/${key}`,
+                  width: 0,
+                  height: 0,
+                  fileSize: buffer.length
+                },
+                sizes: {
+                  full: { path: sizePath, width: 0, height: 0 },
+                  large: { path: sizePath, width: 0, height: 0 },
+                  medium: { path: sizePath, width: 0, height: 0 },
+                  small: { path: sizePath, width: 0, height: 0 }
+                },
+                blurhash: "",
+                dominantColor: "#888888",
+                cdn: null
+              };
+            } else {
+              const existingEntry = meta.images[key];
+              const baseEntry = existingEntry || {
+                original: {
+                  path: `/${key}`,
+                  width: 0,
+                  height: 0,
+                  fileSize: buffer.length
+                },
+                sizes: {
+                  full: { path: "", width: 0, height: 0 },
+                  large: { path: "", width: 0, height: 0 },
+                  medium: { path: "", width: 0, height: 0 },
+                  small: { path: "", width: 0, height: 0 }
+                },
+                blurhash: "",
+                dominantColor: "#888888",
+                cdn: null
+              };
+              const processedEntry = await processImage(buffer, baseEntry, key);
+              meta.images[key] = processedEntry;
+            }
+            processed.push(key);
+          } catch (error) {
+            console.error(`Failed to process ${key}:`, error);
+            errors.push(key);
+          }
         }
-        processed.push(key);
-      } catch (error) {
-        console.error(`Failed to process ${key}:`, error);
-        errors.push(key);
-      }
-    }
-    const trackedPaths = /* @__PURE__ */ new Set();
-    for (const entry of Object.values(meta.images)) {
-      for (const sizeData of Object.values(entry.sizes)) {
-        trackedPaths.add(sizeData.path);
-      }
-    }
-    async function findOrphans(dir, relativePath = "") {
-      try {
-        const entries = await _fs.promises.readdir(dir, { withFileTypes: true });
-        for (const entry of entries) {
-          if (entry.name.startsWith(".")) continue;
-          const fullPath = _path2.default.join(dir, entry.name);
-          const relPath = relativePath ? `${relativePath}/${entry.name}` : entry.name;
-          if (entry.isDirectory()) {
-            await findOrphans(fullPath, relPath);
-          } else if (isImageFile(entry.name)) {
-            const publicPath = `/images/${relPath}`;
-            if (!trackedPaths.has(publicPath)) {
-              try {
-                await _fs.promises.unlink(fullPath);
-                orphansRemoved.push(publicPath);
-              } catch (err) {
-                console.error(`Failed to remove orphan ${publicPath}:`, err);
+        sendEvent({ type: "cleanup", message: "Removing orphaned thumbnails..." });
+        const trackedPaths = /* @__PURE__ */ new Set();
+        for (const entry of Object.values(meta.images)) {
+          for (const sizeData of Object.values(entry.sizes)) {
+            trackedPaths.add(sizeData.path);
+          }
+        }
+        async function findOrphans(dir, relativePath = "") {
+          try {
+            const entries = await _fs.promises.readdir(dir, { withFileTypes: true });
+            for (const entry of entries) {
+              if (entry.name.startsWith(".")) continue;
+              const fullPath = _path2.default.join(dir, entry.name);
+              const relPath = relativePath ? `${relativePath}/${entry.name}` : entry.name;
+              if (entry.isDirectory()) {
+                await findOrphans(fullPath, relPath);
+              } else if (isImageFile(entry.name)) {
+                const publicPath = `/images/${relPath}`;
+                if (!trackedPaths.has(publicPath)) {
+                  try {
+                    await _fs.promises.unlink(fullPath);
+                    orphansRemoved.push(publicPath);
+                  } catch (err) {
+                    console.error(`Failed to remove orphan ${publicPath}:`, err);
+                  }
+                }
               }
             }
+          } catch (e9) {
           }
         }
-      } catch (e9) {
-      }
-    }
-    const imagesDir = _path2.default.join(process.cwd(), "public", "images");
-    await findOrphans(imagesDir);
-    async function removeEmptyDirs(dir) {
-      try {
-        const entries = await _fs.promises.readdir(dir, { withFileTypes: true });
-        let isEmpty = true;
-        for (const entry of entries) {
-          if (entry.isDirectory()) {
-            const subDirEmpty = await removeEmptyDirs(_path2.default.join(dir, entry.name));
-            if (!subDirEmpty) isEmpty = false;
-          } else {
-            isEmpty = false;
+        const imagesDir = _path2.default.join(process.cwd(), "public", "images");
+        await findOrphans(imagesDir);
+        async function removeEmptyDirs(dir) {
+          try {
+            const entries = await _fs.promises.readdir(dir, { withFileTypes: true });
+            let isEmpty = true;
+            for (const entry of entries) {
+              if (entry.isDirectory()) {
+                const subDirEmpty = await removeEmptyDirs(_path2.default.join(dir, entry.name));
+                if (!subDirEmpty) isEmpty = false;
+              } else {
+                isEmpty = false;
+              }
+            }
+            if (isEmpty && dir !== imagesDir) {
+              await _fs.promises.rmdir(dir);
+            }
+            return isEmpty;
+          } catch (e10) {
+            return true;
           }
         }
-        if (isEmpty && dir !== imagesDir) {
-          await _fs.promises.rmdir(dir);
-        }
-        return isEmpty;
-      } catch (e10) {
-        return true;
+        await removeEmptyDirs(imagesDir);
+        await saveMeta(meta);
+        sendEvent({
+          type: "complete",
+          processed: processed.length,
+          orphansRemoved: orphansRemoved.length,
+          errors: errors.length
+        });
+      } catch (error) {
+        console.error("Failed to process all:", error);
+        sendEvent({ type: "error", message: "Failed to process images" });
+      } finally {
+        controller.close();
       }
     }
-    await removeEmptyDirs(imagesDir);
-    await saveMeta(meta);
-    return _server.NextResponse.json({
-      success: true,
-      processed,
-      orphansRemoved,
-      errors: errors.length > 0 ? errors : void 0
-    });
-  } catch (error) {
-    console.error("Failed to process all:", error);
-    return _server.NextResponse.json({ error: "Failed to process all images" }, { status: 500 });
-  }
+  });
+  return new Response(stream, {
+    headers: {
+      "Content-Type": "text/event-stream",
+      "Cache-Control": "no-cache",
+      "Connection": "keep-alive"
+    }
+  });
 }
 async function loadMeta() {
   const metaPath = _path2.default.join(process.cwd(), "_data", "_meta.json");