@gallop.software/studio 1.2.0 → 1.2.2

package/dist/handlers/index.mjs

@@ -311,6 +311,22 @@ async function deleteFromCdn(imageKey, hasThumbnails) {
 }
 
 // src/handlers/list.ts
+function getExistingThumbnails(originalPath, entry) {
+  const thumbnails = [];
+  if (entry.f) {
+    thumbnails.push({ path: getThumbnailPath(originalPath, "full"), size: "f" });
+  }
+  if (entry.lg) {
+    thumbnails.push({ path: getThumbnailPath(originalPath, "lg"), size: "lg" });
+  }
+  if (entry.md) {
+    thumbnails.push({ path: getThumbnailPath(originalPath, "md"), size: "md" });
+  }
+  if (entry.sm) {
+    thumbnails.push({ path: getThumbnailPath(originalPath, "sm"), size: "sm" });
+  }
+  return thumbnails;
+}
 async function handleList(request) {
   const searchParams = request.nextUrl.searchParams;
   const requestedPath = searchParams.get("path") || "public";
@@ -325,6 +341,84 @@ async function handleList(request) {
     const seenFolders = /* @__PURE__ */ new Set();
     const metaKeys = fileEntries.map(([key]) => key);
     const isInsideImagesFolder = relativePath === "images" || relativePath.startsWith("images/");
+    if (isInsideImagesFolder) {
+      const imagesSubPath = relativePath.replace(/^images\/?/, "");
+      const imagesPrefix = imagesSubPath ? `/${imagesSubPath}/` : "/";
+      const allThumbnails = [];
+      for (const [key, entry] of fileEntries) {
+        if (isProcessed(entry)) {
+          const thumbnails = getExistingThumbnails(key, entry);
+          for (const thumb of thumbnails) {
+            allThumbnails.push({ ...thumb, originalKey: key });
+          }
+        }
+      }
+      for (const thumb of allThumbnails) {
+        const thumbRelative = thumb.path.replace(/^\/images\/?/, "");
+        if (imagesSubPath === "") {
+          const slashIndex = thumbRelative.indexOf("/");
+          if (slashIndex === -1) {
+            const fileName = thumbRelative;
+            items.push({
+              name: fileName,
+              path: `public/images/${fileName}`,
+              type: "file",
+              thumbnail: thumb.path,
+              hasThumbnail: false,
+              isProtected: true
+            });
+          } else {
+            const folderName = thumbRelative.slice(0, slashIndex);
+            if (!seenFolders.has(folderName)) {
+              seenFolders.add(folderName);
+              const folderPrefix = `/${folderName}/`;
+              const fileCount = allThumbnails.filter(
+                (t) => t.path.replace(/^\/images/, "").startsWith(folderPrefix)
+              ).length;
+              items.push({
+                name: folderName,
+                path: `public/images/${folderName}`,
+                type: "folder",
+                fileCount,
+                isProtected: true
+              });
+            }
+          }
+        } else {
+          if (!thumbRelative.startsWith(imagesSubPath + "/") && thumbRelative !== imagesSubPath) continue;
+          const remaining = thumbRelative.slice(imagesSubPath.length + 1);
+          if (!remaining) continue;
+          const slashIndex = remaining.indexOf("/");
+          if (slashIndex === -1) {
+            items.push({
+              name: remaining,
+              path: `public/images/${imagesSubPath}/${remaining}`,
+              type: "file",
+              thumbnail: thumb.path,
+              hasThumbnail: false,
+              isProtected: true
+            });
+          } else {
+            const folderName = remaining.slice(0, slashIndex);
+            if (!seenFolders.has(folderName)) {
+              seenFolders.add(folderName);
+              const folderPrefix = `${imagesSubPath}/${folderName}/`;
+              const fileCount = allThumbnails.filter(
+                (t) => t.path.replace(/^\/images\//, "").startsWith(folderPrefix)
+              ).length;
+              items.push({
+                name: folderName,
+                path: `public/images/${imagesSubPath}/${folderName}`,
+                type: "folder",
+                fileCount,
+                isProtected: true
+              });
+            }
+          }
+        }
+      }
+      return NextResponse.json({ items });
+    }
     const absoluteDir = path5.join(process.cwd(), requestedPath);
     try {
       const dirEntries = await fs4.readdir(absoluteDir, { withFileTypes: true });
@@ -336,12 +430,11 @@ async function handleList(request) {
             const isImagesFolder = entry.name === "images" && !relativePath;
             const folderPath = relativePath ? `public/${relativePath}/${entry.name}` : `public/${entry.name}`;
             let fileCount = 0;
-            if (isInsideImagesFolder || isImagesFolder) {
-              const subDir = path5.join(absoluteDir, entry.name);
-              try {
-                const subEntries = await fs4.readdir(subDir);
-                fileCount = subEntries.filter((f) => !f.startsWith(".")).length;
-              } catch {
+            if (isImagesFolder) {
+              for (const [key, metaEntry] of fileEntries) {
+                if (isProcessed(metaEntry)) {
+                  fileCount += getExistingThumbnails(key, metaEntry).length;
+                }
               }
             } else {
               const folderPrefix = pathPrefix === "/" ? `/${entry.name}/` : `${pathPrefix}${entry.name}/`;
@@ -354,32 +447,30 @@ async function handleList(request) {
               path: folderPath,
               type: "folder",
               fileCount,
-              isProtected: isImagesFolder || isInsideImagesFolder
+              isProtected: isImagesFolder
             });
           }
-        } else if (isInsideImagesFolder) {
-          const filePath = relativePath ? `public/${relativePath}/${entry.name}` : `public/${entry.name}`;
-          const fullPath = path5.join(absoluteDir, entry.name);
-          let fileSize;
-          try {
-            const stats = await fs4.stat(fullPath);
-            fileSize = stats.size;
-          } catch {
-          }
-          const isImage = isImageFile(entry.name);
-          items.push({
-            name: entry.name,
-            path: filePath,
-            type: "file",
-            size: fileSize,
-            thumbnail: isImage ? `/${relativePath}/${entry.name}` : void 0,
-            hasThumbnail: false,
-            isProtected: true
-          });
         }
       }
     } catch {
     }
+    if (!relativePath && !seenFolders.has("images")) {
+      let thumbnailCount = 0;
+      for (const [key, entry] of fileEntries) {
+        if (isProcessed(entry)) {
+          thumbnailCount += getExistingThumbnails(key, entry).length;
+        }
+      }
+      if (thumbnailCount > 0) {
+        items.push({
+          name: "images",
+          path: "public/images",
+          type: "folder",
+          fileCount: thumbnailCount,
+          isProtected: true
+        });
+      }
+    }
     if (fileEntries.length === 0 && items.length === 0) {
       return NextResponse.json({ items: [], isEmpty: true });
     }
@@ -705,11 +796,10 @@ async function handleUpload(request) {
       try {
         const metadata = await sharp2(buffer).metadata();
         meta[imageKey] = {
-          w: metadata.width || 0,
-          h: metadata.height || 0
+          o: { w: metadata.width || 0, h: metadata.height || 0 }
         };
       } catch {
-        meta[imageKey] = { w: 0, h: 0 };
+        meta[imageKey] = { o: { w: 0, h: 0 } };
       }
     } else {
       meta[imageKey] = {};
@@ -744,7 +834,7 @@ async function handleDelete(request) {
         const absolutePath = path6.join(process.cwd(), itemPath);
         const imageKey = "/" + itemPath.replace(/^public\//, "");
         const entry = meta[imageKey];
-        const isPushedToCloud = entry?.c === 1;
+        const isPushedToCloud = entry?.c !== void 0;
         try {
           const stats = await fs5.stat(absolutePath);
           if (stats.isDirectory()) {
@@ -752,7 +842,8 @@ async function handleDelete(request) {
             const prefix = imageKey + "/";
             for (const key of Object.keys(meta)) {
               if (key.startsWith(prefix) || key === imageKey) {
-                if (!meta[key].c) {
+                const keyEntry = meta[key];
+                if (keyEntry && keyEntry.c === void 0) {
                   for (const thumbPath of getAllThumbnailPaths(key)) {
                     const absoluteThumbPath = path6.join(process.cwd(), "public", thumbPath);
                     try {