npm - @gallop.software/studio - Versions diffs - 2.3.32 → 2.3.34 - Mend

@gallop.software/studio 2.3.32 → 2.3.34

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (6) hide show

package/dist/client/assets/index-C5ADoI0T.js +85 -0
package/dist/client/assets/index-DZ7F7UJh.js +85 -0
package/dist/client/index.html +1 -1
package/dist/server/index.js +265 -0
package/dist/server/index.js.map +1 -1
package/package.json +1 -1

package/dist/client/index.html CHANGED Viewed

@@ -11,7 +11,7 @@
         font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, 'Helvetica Neue', Arial, sans-serif;
       }
     </style>
-    <script type="module" crossorigin src="/assets/index-Botbd74C.js"></script>
+    <script type="module" crossorigin src="/assets/index-DZ7F7UJh.js"></script>
   </head>
   <body>
     <div id="root"></div>

package/dist/server/index.js CHANGED Viewed

@@ -412,6 +412,18 @@ function jsonResponse(data, init) {
     headers
   });
 }
+function streamResponse(stream, init) {
+  const headers = new Headers({
+    "Content-Type": "text/event-stream",
+    "Cache-Control": "no-cache",
+    Connection: "keep-alive",
+    ...init?.headers
+  });
+  return new Response(stream, {
+    status: 200,
+    headers
+  });
+}
 // src/handlers/list.ts
 function getExistingThumbnails(originalPath, entry) {
@@ -1395,6 +1407,258 @@ async function handleRename(request) {
     return jsonResponse({ error: "Failed to rename" }, { status: 500 });
   }
 }
+async function handleRenameStream(request) {
+  const encoder = new TextEncoder();
+  const publicUrl = process.env.CLOUDFLARE_R2_PUBLIC_URL?.replace(/\/$/, "");
+  const stream = new ReadableStream({
+    async start(controller) {
+      const sendEvent = (data) => {
+        controller.enqueue(encoder.encode(`data: ${JSON.stringify(data)}
+`));
+      };
+      try {
+        const { oldPath, newName } = await request.json();
+        if (!oldPath || !newName) {
+          sendEvent({ type: "error", message: "Path and new name are required" });
+          controller.close();
+          return;
+        }
+        const safePath = oldPath.replace(/\.\./g, "");
+        const absoluteOldPath = getWorkspacePath(safePath);
+        if (!absoluteOldPath.startsWith(getPublicPath())) {
+          sendEvent({ type: "error", message: "Invalid path" });
+          controller.close();
+          return;
+        }
+        const oldRelativePath = safePath.replace(/^public\//, "");
+        const isImagePath = isImageFile(path6.basename(oldPath));
+        let hasLocalItem = false;
+        let isFile = true;
+        try {
+          const stats = await fs6.stat(absoluteOldPath);
+          hasLocalItem = true;
+          isFile = stats.isFile();
+        } catch {
+          const meta2 = await loadMeta();
+          const oldKey2 = "/" + oldRelativePath;
+          const entry2 = meta2[oldKey2];
+          if (!entry2) {
+            sendEvent({ type: "error", message: "File or folder not found" });
+            controller.close();
+            return;
+          }
+          isFile = true;
+        }
+        const sanitizedName = isFile ? slugifyFilename(newName) : slugifyFolderName(newName);
+        if (!sanitizedName) {
+          sendEvent({ type: "error", message: "Invalid name" });
+          controller.close();
+          return;
+        }
+        const parentDir = path6.dirname(absoluteOldPath);
+        const absoluteNewPath = path6.join(parentDir, sanitizedName);
+        const newRelativePath = path6.join(path6.dirname(oldRelativePath), sanitizedName);
+        const newPath = path6.join(path6.dirname(safePath), sanitizedName);
+        const meta = await loadMeta();
+        const cdnUrls = getCdnUrls(meta);
+        if (isFile) {
+          const newKey2 = "/" + newRelativePath;
+          if (meta[newKey2]) {
+            sendEvent({ type: "error", message: "An item with this name already exists" });
+            controller.close();
+            return;
+          }
+        }
+        try {
+          await fs6.access(absoluteNewPath);
+          sendEvent({ type: "error", message: "An item with this name already exists" });
+          controller.close();
+          return;
+        } catch {
+        }
+        if (!isFile) {
+          const oldPrefix = "/" + oldRelativePath + "/";
+          const newPrefix = "/" + newRelativePath + "/";
+          const itemsToUpdate = [];
+          for (const [key, entry2] of Object.entries(meta)) {
+            if (key.startsWith(oldPrefix) && entry2 && typeof entry2 === "object") {
+              const newKey2 = key.replace(oldPrefix, newPrefix);
+              itemsToUpdate.push({ oldKey: key, newKey: newKey2, entry: entry2 });
+            }
+          }
+          const total = itemsToUpdate.length + 1;
+          sendEvent({ type: "start", total, message: `Renaming folder with ${itemsToUpdate.length} item(s)...` });
+          if (hasLocalItem) {
+            await fs6.rename(absoluteOldPath, absoluteNewPath);
+          }
+          sendEvent({ type: "progress", current: 1, total, renamed: 1, message: "Renamed folder" });
+          let renamed = 1;
+          for (const item of itemsToUpdate) {
+            const { oldKey: oldKey2, newKey: newKey2, entry: entry2 } = item;
+            const isInCloud2 = entry2.c !== void 0;
+            const fileCdnUrl2 = isInCloud2 ? cdnUrls[entry2.c] : void 0;
+            const isInOurR22 = isInCloud2 && fileCdnUrl2 === publicUrl;
+            const hasThumbnails2 = isProcessed(entry2);
+            if (isInOurR22) {
+              const localFilePath = getPublicPath(newKey2);
+              let hasLocalFile = false;
+              try {
+                await fs6.access(localFilePath);
+                hasLocalFile = true;
+              } catch {
+              }
+              if (hasLocalFile) {
+                await deleteFromCdn(oldKey2, hasThumbnails2);
+                await uploadOriginalToCdn(newKey2);
+                if (hasThumbnails2) {
+                  await uploadToCdn(newKey2);
+                }
+                try {
+                  await fs6.unlink(localFilePath);
+                } catch {
+                }
+                if (hasThumbnails2) {
+                  await deleteLocalThumbnails(newKey2);
+                }
+              } else {
+                try {
+                  const buffer = await downloadFromCdn(oldKey2);
+                  await fs6.mkdir(path6.dirname(localFilePath), { recursive: true });
+                  await fs6.writeFile(localFilePath, buffer);
+                  if (hasThumbnails2) {
+                    const oldThumbPaths = getAllThumbnailPaths(oldKey2);
+                    const newThumbPaths = getAllThumbnailPaths(newKey2);
+                    for (let i = 0; i < oldThumbPaths.length; i++) {
+                      try {
+                        const thumbBuffer = await downloadFromCdn(oldThumbPaths[i]);
+                        const newThumbLocalPath = getPublicPath(newThumbPaths[i]);
+                        await fs6.mkdir(path6.dirname(newThumbLocalPath), { recursive: true });
+                        await fs6.writeFile(newThumbLocalPath, thumbBuffer);
+                      } catch {
+                      }
+                    }
+                  }
+                  await deleteFromCdn(oldKey2, hasThumbnails2);
+                  await uploadOriginalToCdn(newKey2);
+                  if (hasThumbnails2) {
+                    await uploadToCdn(newKey2);
+                  }
+                  try {
+                    await fs6.unlink(localFilePath);
+                  } catch {
+                  }
+                  if (hasThumbnails2) {
+                    await deleteLocalThumbnails(newKey2);
+                  }
+                } catch (err) {
+                  console.error(`Failed to re-upload ${oldKey2}:`, err);
+                }
+              }
+            }
+            delete meta[oldKey2];
+            meta[newKey2] = entry2;
+            renamed++;
+            sendEvent({
+              type: "progress",
+              current: renamed,
+              total,
+              renamed,
+              message: `Renamed ${path6.basename(newKey2)}`
+            });
+          }
+          await saveMeta(meta);
+          await deleteEmptyFolders(getPublicPath());
+          sendEvent({ type: "complete", renamed, newPath });
+          controller.close();
+          return;
+        }
+        const oldKey = "/" + oldRelativePath;
+        const newKey = "/" + newRelativePath;
+        const entry = meta[oldKey];
+        const isInCloud = entry?.c !== void 0;
+        const fileCdnUrl = isInCloud && entry?.c !== void 0 ? cdnUrls[entry.c] : void 0;
+        const isInOurR2 = isInCloud && fileCdnUrl === publicUrl;
+        const hasThumbnails = entry ? isProcessed(entry) : false;
+        sendEvent({ type: "start", total: 1, message: "Renaming file..." });
+        if (isInOurR2 && !hasLocalItem && isImagePath) {
+          const buffer = await downloadFromCdn(oldKey);
+          await fs6.mkdir(path6.dirname(absoluteNewPath), { recursive: true });
+          await fs6.writeFile(absoluteNewPath, buffer);
+          if (hasThumbnails) {
+            const newThumbPaths = getAllThumbnailPaths(newKey);
+            const oldThumbPaths = getAllThumbnailPaths(oldKey);
+            for (let i = 0; i < oldThumbPaths.length; i++) {
+              try {
+                const thumbBuffer = await downloadFromCdn(oldThumbPaths[i]);
+                const newThumbLocalPath = getPublicPath(newThumbPaths[i]);
+                await fs6.mkdir(path6.dirname(newThumbLocalPath), { recursive: true });
+                await fs6.writeFile(newThumbLocalPath, thumbBuffer);
+              } catch {
+              }
+            }
+          }
+          await deleteFromCdn(oldKey, hasThumbnails);
+          await uploadOriginalToCdn(newKey);
+          if (hasThumbnails) {
+            await uploadToCdn(newKey);
+          }
+          try {
+            await fs6.unlink(absoluteNewPath);
+          } catch {
+          }
+          if (hasThumbnails) {
+            await deleteLocalThumbnails(newKey);
+          }
+          delete meta[oldKey];
+          if (entry) meta[newKey] = entry;
+          await saveMeta(meta);
+          sendEvent({ type: "complete", renamed: 1, newPath });
+          controller.close();
+          return;
+        }
+        if (hasLocalItem) {
+          await fs6.rename(absoluteOldPath, absoluteNewPath);
+        }
+        if (isImagePath && entry) {
+          const oldThumbPaths = getAllThumbnailPaths(oldKey);
+          const newThumbPaths = getAllThumbnailPaths(newKey);
+          for (let i = 0; i < oldThumbPaths.length; i++) {
+            const oldThumbPath = getPublicPath(oldThumbPaths[i]);
+            const newThumbPath = getPublicPath(newThumbPaths[i]);
+            await fs6.mkdir(path6.dirname(newThumbPath), { recursive: true });
+            try {
+              await fs6.rename(oldThumbPath, newThumbPath);
+            } catch {
+            }
+          }
+          if (isInOurR2) {
+            await deleteFromCdn(oldKey, hasThumbnails);
+            await uploadOriginalToCdn(newKey);
+            if (hasThumbnails) {
+              await uploadToCdn(newKey);
+            }
+            try {
+              await fs6.unlink(absoluteNewPath);
+            } catch {
+            }
+            await deleteLocalThumbnails(newKey);
+          }
+          delete meta[oldKey];
+          meta[newKey] = entry;
+          await saveMeta(meta);
+        }
+        sendEvent({ type: "complete", renamed: 1, newPath });
+        controller.close();
+      } catch (error) {
+        console.error("Rename stream error:", error);
+        sendEvent({ type: "error", message: "Failed to rename" });
+        controller.close();
+      }
+    }
+  });
+  return streamResponse(stream);
+}
 async function handleMoveStream(request) {
   const encoder = new TextEncoder();
   const stream = new ReadableStream({
@@ -2996,6 +3260,7 @@ async function startServer(options) {
   app.post("/api/studio/upload", wrapRawHandler(handleUpload));
   app.post("/api/studio/create-folder", wrapHandler(handleCreateFolder));
   app.post("/api/studio/rename", wrapHandler(handleRename));
+  app.post("/api/studio/rename-stream", wrapHandler(handleRenameStream, true));
   app.post("/api/studio/move", wrapHandler(handleMoveStream, true));
   app.post("/api/studio/sync", wrapHandler(handleSync, true));
   app.post("/api/studio/reprocess-stream", wrapHandler(handleReprocessStream, true));