@gallop.software/studio 2.3.165 → 2.3.167

package/dist/server/index.js

@@ -2449,11 +2449,51 @@ async function handleDeleteStream(request) {
           return;
         }
         const isCancelled = () => operationId ? isOperationCancelled(operationId) : false;
+        async function countFilesInDir(dirPath) {
+          let count = 0;
+          try {
+            const entries = await fs7.readdir(dirPath, { withFileTypes: true });
+            for (const entry of entries) {
+              if (entry.isDirectory()) {
+                count += await countFilesInDir(path7.join(dirPath, entry.name));
+              } else {
+                count++;
+              }
+            }
+          } catch {
+          }
+          return count;
+        }
+        let totalFiles = 0;
+        for (const itemPath of paths) {
+          if (!itemPath.startsWith("public/")) continue;
+          const absolutePath = getWorkspacePath(itemPath);
+          try {
+            const stats = await fs7.stat(absolutePath);
+            if (stats.isDirectory()) {
+              totalFiles += await countFilesInDir(absolutePath);
+            } else {
+              totalFiles++;
+            }
+          } catch {
+            const imageKey = "/" + itemPath.replace(/^public\//, "");
+            const meta2 = await loadMeta();
+            const prefix = imageKey + "/";
+            let count = 0;
+            for (const key of Object.keys(meta2)) {
+              if (key.startsWith(prefix) || key === imageKey) {
+                count++;
+              }
+            }
+            totalFiles += count || 1;
+          }
+        }
         const meta = await loadMeta();
         const deleted = [];
         const errors = [];
         const sourceFolders = /* @__PURE__ */ new Set();
-        const total = paths.length;
+        const total = totalFiles || paths.length;
+        let currentProgress = 0;
         sendEvent({ type: "start", total });
         for (let i = 0; i < paths.length; i++) {
           if (isCancelled()) {
@@ -2476,12 +2516,13 @@ async function handleDeleteStream(request) {
           try {
             if (!itemPath.startsWith("public/")) {
               errors.push(`Invalid path: ${itemPath}`);
+              currentProgress++;
               sendEvent({
                 type: "progress",
-                current: i + 1,
+                current: currentProgress,
                 total,
                 deleted: deleted.length,
-                percent: Math.round((i + 1) / total * 100),
+                percent: Math.round(currentProgress / total * 100),
                 currentFile: path7.basename(itemPath)
               });
               continue;
@@ -2495,6 +2536,7 @@ async function handleDeleteStream(request) {
             try {
               const stats = await fs7.stat(absolutePath);
               if (stats.isDirectory()) {
+                const filesInDir = await countFilesInDir(absolutePath);
                 await fs7.rm(absolutePath, { recursive: true });
                 const prefix = imageKey + "/";
                 for (const key of Object.keys(meta)) {
@@ -2518,6 +2560,7 @@ async function handleDeleteStream(request) {
                     delete meta[key];
                   }
                 }
+                currentProgress += filesInDir || 1;
               } else {
                 await fs7.unlink(absolutePath);
                 const isInImagesFolder = itemPath.startsWith("public/images/");
@@ -2538,6 +2581,7 @@ async function handleDeleteStream(request) {
                   }
                   delete meta[imageKey];
                 }
+                currentProgress++;
               }
             } catch {
               if (entry) {
@@ -2548,6 +2592,7 @@ async function handleDeleteStream(request) {
                   }
                 }
                 delete meta[imageKey];
+                currentProgress++;
               } else {
                 const prefix = imageKey + "/";
                 let foundAny = false;
@@ -2563,16 +2608,18 @@ async function handleDeleteStream(request) {
                     }
                     delete meta[key];
                     foundAny = true;
+                    currentProgress++;
                   }
                 }
                 if (!foundAny) {
                   errors.push(`Not found: ${itemPath}`);
+                  currentProgress++;
                   sendEvent({
                     type: "progress",
-                    current: i + 1,
+                    current: currentProgress,
                     total,
                     deleted: deleted.length,
-                    percent: Math.round((i + 1) / total * 100),
+                    percent: Math.round(currentProgress / total * 100),
                     currentFile: path7.basename(itemPath)
                   });
                   continue;
@@ -2587,10 +2634,10 @@ async function handleDeleteStream(request) {
           }
           sendEvent({
             type: "progress",
-            current: i + 1,
+            current: currentProgress,
             total,
             deleted: deleted.length,
-            percent: Math.round((i + 1) / total * 100),
+            percent: Math.round(currentProgress / total * 100),
             currentFile: path7.basename(itemPath)
           });
         }
@@ -4794,6 +4841,38 @@ async function handleFontsDeleteStream(request) {
         return jsonResponse({ error: `Path not allowed: ${p}` }, { status: 400 });
       }
     }
+    async function countFilesInDir(dirPath) {
+      let count = 0;
+      try {
+        const entries = await fs12.readdir(dirPath, { withFileTypes: true });
+        for (const entry of entries) {
+          if (entry.isDirectory()) {
+            count += await countFilesInDir(path11.join(dirPath, entry.name));
+          } else {
+            count++;
+          }
+        }
+      } catch {
+      }
+      return count;
+    }
+    async function getFilesInDir(dirPath, basePath) {
+      const files = [];
+      try {
+        const entries = await fs12.readdir(dirPath, { withFileTypes: true });
+        for (const entry of entries) {
+          const fullPath = path11.join(dirPath, entry.name);
+          const relativePath = path11.join(basePath, entry.name);
+          if (entry.isDirectory()) {
+            files.push(...await getFilesInDir(fullPath, relativePath));
+          } else {
+            files.push(relativePath);
+          }
+        }
+      } catch {
+      }
+      return files;
+    }
     const encoder = new TextEncoder();
     const stream = new ReadableStream({
       async start(controller) {
@@ -4802,29 +4881,50 @@ async function handleFontsDeleteStream(request) {
 
 `));
         };
-        const deleted = [];
-        const errors = [];
-        for (let i = 0; i < paths.length; i++) {
-          const p = paths[i];
-          const fileName = p.split("/").pop() || p;
-          send({ status: "progress", message: `Deleting ${fileName}...`, current: i + 1, total: paths.length });
-          await new Promise((resolve2) => setTimeout(resolve2, 1e3));
+        const allFiles = [];
+        const foldersToDelete = [];
+        for (const p of paths) {
+          const fullPath = getWorkspacePath(p);
           try {
-            const fullPath = getWorkspacePath(p);
             const stat = await fs12.stat(fullPath);
             if (stat.isDirectory()) {
-              await fs12.rm(fullPath, { recursive: true });
+              foldersToDelete.push(p);
+              const filesInDir = await getFilesInDir(fullPath, p);
+              for (const f of filesInDir) {
+                allFiles.push({ path: f, isFolder: false, parentFolder: p });
+              }
             } else {
-              await fs12.unlink(fullPath);
+              allFiles.push({ path: p, isFolder: false });
             }
-            deleted.push(p);
+          } catch {
+          }
+        }
+        const total = allFiles.length;
+        const deleted = [];
+        const errors = [];
+        let current = 0;
+        for (const file of allFiles) {
+          current++;
+          const fileName = file.path.split("/").pop() || file.path;
+          send({ status: "progress", message: `Deleting ${fileName}...`, current, total });
+          try {
+            const fullPath = getWorkspacePath(file.path);
+            await fs12.unlink(fullPath);
+            deleted.push(file.path);
           } catch (err) {
-            errors.push(`Failed to delete ${p}: ${err instanceof Error ? err.message : "Unknown error"}`);
+            errors.push(`Failed to delete ${file.path}: ${err instanceof Error ? err.message : "Unknown error"}`);
+          }
+        }
+        for (const folder of foldersToDelete) {
+          try {
+            const fullPath = getWorkspacePath(folder);
+            await fs12.rm(fullPath, { recursive: true });
+          } catch {
           }
         }
         send({
           status: "complete",
-          message: `Deleted ${deleted.length} item${deleted.length !== 1 ? "s" : ""}`,
+          message: `Deleted ${deleted.length} file${deleted.length !== 1 ? "s" : ""}`,
           deleted,
           errors: errors.length > 0 ? errors : void 0
         });