@gallop.software/studio 2.3.39 → 2.3.41

package/dist/server/index.js

@@ -1725,26 +1725,134 @@ async function handleMoveStream(request) {
         const moved = [];
         const errors = [];
         const sourceFolders = /* @__PURE__ */ new Set();
-        const total = paths.length;
-        sendEvent({ type: "start", total });
-        for (let i = 0; i < paths.length; i++) {
-          const itemPath = paths[i];
+        let totalFiles = 0;
+        const expandedItems = [];
+        for (const itemPath of paths) {
           const safePath = itemPath.replace(/\.\./g, "");
           const itemName = path6.basename(safePath);
-          const newAbsolutePath = path6.join(absoluteDestination, itemName);
           const oldRelativePath = safePath.replace(/^public\/?/, "");
           const destWithoutPublic = safeDestination.replace(/^public\/?/, "");
           const newRelativePath = destWithoutPublic ? path6.join(destWithoutPublic, itemName) : itemName;
           const oldKey = "/" + oldRelativePath;
           const newKey = "/" + newRelativePath;
+          const newAbsolutePath = path6.join(absoluteDestination, itemName);
+          const absolutePath = getWorkspacePath(safePath);
+          let hasLocalItem = false;
+          let isDirectory = false;
+          try {
+            const stats = await fs6.stat(absolutePath);
+            hasLocalItem = true;
+            isDirectory = stats.isDirectory();
+          } catch {
+          }
+          if (hasLocalItem && isDirectory) {
+            const countFilesRecursive = async (dir) => {
+              let count = 0;
+              const entries = await fs6.readdir(dir, { withFileTypes: true });
+              for (const entry of entries) {
+                if (entry.isDirectory()) {
+                  count += await countFilesRecursive(path6.join(dir, entry.name));
+                } else {
+                  count++;
+                }
+              }
+              return count;
+            };
+            totalFiles += await countFilesRecursive(absolutePath);
+            expandedItems.push({ itemPath, safePath, itemName, oldKey, newKey, newAbsolutePath, isVirtualFolder: false });
+          } else if (!hasLocalItem) {
+            const folderPrefix = oldKey + "/";
+            const virtualItems = [];
+            for (const [key, metaEntry] of Object.entries(meta)) {
+              if (key.startsWith(folderPrefix) && metaEntry && typeof metaEntry === "object") {
+                const relativePath = key.slice(folderPrefix.length);
+                const destNewKey = newKey + "/" + relativePath;
+                virtualItems.push({ oldKey: key, newKey: destNewKey, entry: metaEntry });
+              }
+            }
+            if (virtualItems.length > 0) {
+              totalFiles += virtualItems.length;
+              expandedItems.push({ itemPath, safePath, itemName, oldKey, newKey, newAbsolutePath, isVirtualFolder: true, virtualFolderItems: virtualItems });
+              sourceFolders.add(absolutePath);
+            } else {
+              totalFiles++;
+              expandedItems.push({ itemPath, safePath, itemName, oldKey, newKey, newAbsolutePath, isVirtualFolder: false });
+            }
+          } else {
+            totalFiles++;
+            expandedItems.push({ itemPath, safePath, itemName, oldKey, newKey, newAbsolutePath, isVirtualFolder: false });
+          }
+        }
+        sendEvent({ type: "start", total: totalFiles });
+        let processedFiles = 0;
+        for (const expandedItem of expandedItems) {
+          const { itemPath, safePath, itemName, oldKey, newKey, newAbsolutePath, isVirtualFolder, virtualFolderItems } = expandedItem;
+          if (isVirtualFolder && virtualFolderItems) {
+            for (const vItem of virtualFolderItems) {
+              const itemEntry = vItem.entry;
+              const isItemInCloud = itemEntry.c !== void 0;
+              const itemCdnUrl = isItemInCloud ? cdnUrls[itemEntry.c] : void 0;
+              const isItemInR2 = isItemInCloud && itemCdnUrl === r2PublicUrl;
+              const itemHasThumbnails = isProcessed(itemEntry);
+              if (isItemInR2) {
+                try {
+                  const itemLocalPath = getPublicPath(vItem.newKey);
+                  const buffer = await downloadFromCdn(vItem.oldKey);
+                  await fs6.mkdir(path6.dirname(itemLocalPath), { recursive: true });
+                  await fs6.writeFile(itemLocalPath, buffer);
+                  if (itemHasThumbnails) {
+                    const oldThumbPaths = getAllThumbnailPaths(vItem.oldKey);
+                    const newThumbPaths = getAllThumbnailPaths(vItem.newKey);
+                    for (let t = 0; t < oldThumbPaths.length; t++) {
+                      try {
+                        const thumbBuffer = await downloadFromCdn(oldThumbPaths[t]);
+                        const newThumbLocalPath = getPublicPath(newThumbPaths[t]);
+                        await fs6.mkdir(path6.dirname(newThumbLocalPath), { recursive: true });
+                        await fs6.writeFile(newThumbLocalPath, thumbBuffer);
+                      } catch {
+                      }
+                    }
+                  }
+                  await deleteFromCdn(vItem.oldKey, itemHasThumbnails);
+                  await uploadOriginalToCdn(vItem.newKey);
+                  if (itemHasThumbnails) {
+                    await uploadToCdn(vItem.newKey);
+                  }
+                  try {
+                    await fs6.unlink(itemLocalPath);
+                  } catch {
+                  }
+                  if (itemHasThumbnails) {
+                    await deleteLocalThumbnails(vItem.newKey);
+                  }
+                } catch (err) {
+                  console.error(`Failed to move cloud item ${vItem.oldKey}:`, err);
+                }
+              }
+              delete meta[vItem.oldKey];
+              meta[vItem.newKey] = itemEntry;
+              processedFiles++;
+              sendEvent({
+                type: "progress",
+                current: processedFiles,
+                total: totalFiles,
+                moved: moved.length,
+                percent: Math.round(processedFiles / totalFiles * 100),
+                currentFile: path6.basename(vItem.newKey)
+              });
+            }
+            moved.push(itemPath);
+            continue;
+          }
           if (meta[newKey]) {
             errors.push(`${itemName} already exists in destination`);
+            processedFiles++;
             sendEvent({
               type: "progress",
-              current: i + 1,
-              total,
+              current: processedFiles,
+              total: totalFiles,
               moved: moved.length,
-              percent: Math.round((i + 1) / total * 100),
+              percent: Math.round(processedFiles / totalFiles * 100),
               currentFile: itemName
             });
             continue;
@@ -1771,12 +1879,13 @@ async function handleMoveStream(request) {
               delete meta[oldKey];
               meta[newKey] = newEntry;
               moved.push(itemPath);
+              processedFiles++;
               sendEvent({
                 type: "progress",
-                current: i + 1,
-                total,
+                current: processedFiles,
+                total: totalFiles,
                 moved: moved.length,
-                percent: Math.round((i + 1) / total * 100),
+                percent: Math.round(processedFiles / totalFiles * 100),
                 currentFile: itemName
               });
             } else if (isPushedToR2 && isImage) {
@@ -1807,24 +1916,26 @@ async function handleMoveStream(request) {
               delete meta[oldKey];
               meta[newKey] = newEntry;
               moved.push(itemPath);
+              processedFiles++;
               sendEvent({
                 type: "progress",
-                current: i + 1,
-                total,
+                current: processedFiles,
+                total: totalFiles,
                 moved: moved.length,
-                percent: Math.round((i + 1) / total * 100),
+                percent: Math.round(processedFiles / totalFiles * 100),
                 currentFile: itemName
               });
             } else {
               const absolutePath = getWorkspacePath(safePath);
               if (absoluteDestination.startsWith(absolutePath + path6.sep)) {
                 errors.push(`Cannot move ${itemName} into itself`);
+                processedFiles++;
                 sendEvent({
                   type: "progress",
-                  current: i + 1,
-                  total,
+                  current: processedFiles,
+                  total: totalFiles,
                   moved: moved.length,
-                  percent: Math.round((i + 1) / total * 100),
+                  percent: Math.round(processedFiles / totalFiles * 100),
                   currentFile: itemName
                 });
                 continue;
@@ -1833,12 +1944,13 @@ async function handleMoveStream(request) {
                 await fs6.access(absolutePath);
               } catch {
                 errors.push(`${itemName} not found`);
+                processedFiles++;
                 sendEvent({
                   type: "progress",
-                  current: i + 1,
-                  total,
+                  current: processedFiles,
+                  total: totalFiles,
                   moved: moved.length,
-                  percent: Math.round((i + 1) / total * 100),
+                  percent: Math.round(processedFiles / totalFiles * 100),
                   currentFile: itemName
                 });
                 continue;
@@ -1846,12 +1958,13 @@ async function handleMoveStream(request) {
               try {
                 await fs6.access(newAbsolutePath);
                 errors.push(`${itemName} already exists in destination`);
+                processedFiles++;
                 sendEvent({
                   type: "progress",
-                  current: i + 1,
-                  total,
+                  current: processedFiles,
+                  total: totalFiles,
                   moved: moved.length,
-                  percent: Math.round((i + 1) / total * 100),
+                  percent: Math.round(processedFiles / totalFiles * 100),
                   currentFile: itemName
                 });
                 continue;
@@ -1887,24 +2000,43 @@ async function handleMoveStream(request) {
                 }
               }
               moved.push(itemPath);
+              if (stats.isDirectory()) {
+                const countFilesInDir = async (dir) => {
+                  let count = 0;
+                  const entries = await fs6.readdir(dir, { withFileTypes: true });
+                  for (const entry2 of entries) {
+                    if (entry2.isDirectory()) {
+                      count += await countFilesInDir(path6.join(dir, entry2.name));
+                    } else {
+                      count++;
+                    }
+                  }
+                  return count;
+                };
+                const filesInDir = await countFilesInDir(newAbsolutePath);
+                processedFiles += filesInDir;
+              } else {
+                processedFiles++;
+              }
               sendEvent({
                 type: "progress",
-                current: i + 1,
-                total,
+                current: processedFiles,
+                total: totalFiles,
                 moved: moved.length,
-                percent: Math.round((i + 1) / total * 100),
+                percent: Math.round(processedFiles / totalFiles * 100),
                 currentFile: itemName
               });
             }
           } catch (err) {
             console.error(`Failed to move ${itemName}:`, err);
             errors.push(`Failed to move ${itemName}`);
+            processedFiles++;
             sendEvent({
               type: "progress",
-              current: i + 1,
-              total,
+              current: processedFiles,
+              total: totalFiles,
               moved: moved.length,
-              percent: Math.round((i + 1) / total * 100),
+              percent: Math.round(processedFiles / totalFiles * 100),
               currentFile: itemName
             });
           }