npm - @gallop.software/studio - Versions diffs - 2.3.158 → 2.3.160 - Mend

@gallop.software/studio 2.3.158 → 2.3.160

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-Ceh3JCXY.js +139 -0
package/dist/client/index.html +1 -1
package/dist/server/index.js +169 -4
package/dist/server/index.js.map +1 -1
package/package.json +1 -1
package/dist/client/assets/index-BhxZZEuV.js +0 -125

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-BhxZZEuV.js"></script>
+    <script type="module" crossorigin src="/assets/index-Ceh3JCXY.js"></script>
     <link rel="stylesheet" crossorigin href="/assets/index-DfPQBmNf.css">
   </head>
   <body>

package/dist/server/index.js CHANGED Viewed

@@ -4693,25 +4693,40 @@ async function handleFontsUpload(request) {
   try {
     const formData = await request.formData();
     const file = formData.get("file");
-    const targetPath = formData.get("path") || "_fonts";
+    const basePath = formData.get("path") || "_fonts";
     if (!file) {
       return jsonResponse({ error: "No file provided" }, { status: 400 });
     }
     if (!file.name.toLowerCase().endsWith(".ttf")) {
       return jsonResponse({ error: "Only TTF files are supported" }, { status: 400 });
     }
-    if (!targetPath.startsWith("_fonts")) {
+    if (!basePath.startsWith("_fonts")) {
       return jsonResponse({ error: "Can only upload to _fonts/" }, { status: 400 });
     }
     const bytes = await file.arrayBuffer();
     const buffer = Buffer.from(bytes);
+    const fileName = file.name.toLowerCase();
+    const dashIndex = fileName.indexOf("-");
+    let folderName;
+    if (dashIndex > 0) {
+      folderName = fileName.substring(0, dashIndex);
+    } else {
+      folderName = fileName.replace(".ttf", "");
+    }
+    let targetPath;
+    if (basePath === "_fonts") {
+      targetPath = `_fonts/${folderName}`;
+    } else {
+      targetPath = basePath;
+    }
     const uploadDir = getWorkspacePath(targetPath);
     await fs12.mkdir(uploadDir, { recursive: true });
-    const filePath = path11.join(uploadDir, file.name.toLowerCase());
+    const filePath = path11.join(uploadDir, fileName);
     await fs12.writeFile(filePath, buffer);
     return jsonResponse({
       success: true,
-      path: `${targetPath}/${file.name.toLowerCase()}`
+      path: `${targetPath}/${fileName}`,
+      folder: targetPath
     });
   } catch (error) {
     console.error("Error uploading font:", error);
@@ -4776,6 +4791,66 @@ async function handleFontsDelete(request) {
     return jsonResponse({ error: "Failed to delete" }, { status: 500 });
   }
 }
+async function handleFontsDeleteStream(request) {
+  try {
+    const { paths } = await request.json();
+    if (!paths || !Array.isArray(paths) || paths.length === 0) {
+      return jsonResponse({ error: "Paths are required" }, { status: 400 });
+    }
+    for (const p of paths) {
+      if (!p.startsWith("_fonts/")) {
+        return jsonResponse({ error: `Path not allowed: ${p}` }, { status: 400 });
+      }
+    }
+    const encoder = new TextEncoder();
+    const stream = new ReadableStream({
+      async start(controller) {
+        const send = (data) => {
+          controller.enqueue(encoder.encode(`data: ${JSON.stringify(data)}
+`));
+        };
+        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));
+          try {
+            const fullPath = getWorkspacePath(p);
+            const stat = await fs12.stat(fullPath);
+            if (stat.isDirectory()) {
+              await fs12.rm(fullPath, { recursive: true });
+            } else {
+              await fs12.unlink(fullPath);
+            }
+            deleted.push(p);
+          } catch (err) {
+            errors.push(`Failed to delete ${p}: ${err instanceof Error ? err.message : "Unknown error"}`);
+          }
+        }
+        send({
+          status: "complete",
+          message: `Deleted ${deleted.length} item${deleted.length !== 1 ? "s" : ""}`,
+          deleted,
+          errors: errors.length > 0 ? errors : void 0
+        });
+        controller.close();
+      }
+    });
+    return new Response(stream, {
+      headers: {
+        "Content-Type": "text/event-stream",
+        "Cache-Control": "no-cache",
+        "Connection": "keep-alive"
+      }
+    });
+  } catch (error) {
+    console.error("Error deleting:", error);
+    return jsonResponse({ error: "Failed to delete" }, { status: 500 });
+  }
+}
 async function handleFontsRename(request) {
   try {
     const { oldPath, newName } = await request.json();
@@ -4835,6 +4910,92 @@ async function handleFontsRename(request) {
     return jsonResponse({ error: "Failed to rename" }, { status: 500 });
   }
 }
+async function handleFontsRenameStream(request) {
+  try {
+    const { oldPath, newName } = await request.json();
+    if (!oldPath || !newName) {
+      return jsonResponse({ error: "oldPath and newName are required" }, { status: 400 });
+    }
+    if (!oldPath.startsWith("_fonts/")) {
+      return jsonResponse({ error: "Can only rename items in _fonts/" }, { status: 400 });
+    }
+    if (newName.includes("/") || newName.includes("\\")) {
+      return jsonResponse({ error: "Invalid folder name" }, { status: 400 });
+    }
+    const oldFullPath = getWorkspacePath(oldPath);
+    const parentDir = path11.dirname(oldPath);
+    const oldFolderName = path11.basename(oldPath).toLowerCase();
+    const newFolderName = newName.toLowerCase();
+    const newPath = `${parentDir}/${newFolderName}`;
+    const newFullPath = getWorkspacePath(newPath);
+    let isDirectory = false;
+    try {
+      const stat = await fs12.stat(oldFullPath);
+      isDirectory = stat.isDirectory();
+    } catch {
+      return jsonResponse({ error: "Path not found" }, { status: 404 });
+    }
+    try {
+      await fs12.stat(newFullPath);
+      return jsonResponse({ error: "A folder with that name already exists" }, { status: 400 });
+    } catch {
+    }
+    const encoder = new TextEncoder();
+    const stream = new ReadableStream({
+      async start(controller) {
+        const send = (data) => {
+          controller.enqueue(encoder.encode(`data: ${JSON.stringify(data)}
+`));
+        };
+        try {
+          send({ status: "progress", message: `Renaming folder to ${newFolderName}...`, current: 0, total: 1 });
+          await new Promise((resolve2) => setTimeout(resolve2, 1e3));
+          await fs12.rename(oldFullPath, newFullPath);
+          if (isDirectory) {
+            const entries = await fs12.readdir(newFullPath);
+            const filesToRename = entries.filter((entry) => {
+              const entryLower = entry.toLowerCase();
+              return entryLower.startsWith(oldFolderName + "-") || entryLower.startsWith(oldFolderName + "_");
+            });
+            let renamed = 0;
+            for (const entry of filesToRename) {
+              const entryLower = entry.toLowerCase();
+              const separator = entryLower.startsWith(oldFolderName + "-") ? "-" : "_";
+              const suffix = entry.substring(oldFolderName.length);
+              const newFileName = newFolderName + suffix.toLowerCase();
+              send({ status: "progress", message: `Renaming ${entry} \u2192 ${newFileName}...`, current: renamed + 1, total: filesToRename.length });
+              await new Promise((resolve2) => setTimeout(resolve2, 1e3));
+              const oldFilePath = path11.join(newFullPath, entry);
+              const newFilePath = path11.join(newFullPath, newFileName);
+              await fs12.rename(oldFilePath, newFilePath);
+              renamed++;
+            }
+          }
+          send({
+            status: "complete",
+            message: `Renamed to ${newFolderName}`,
+            oldPath,
+            newPath
+          });
+        } catch (err) {
+          send({ status: "error", message: String(err) });
+        }
+        controller.close();
+      }
+    });
+    return new Response(stream, {
+      headers: {
+        "Content-Type": "text/event-stream",
+        "Cache-Control": "no-cache",
+        "Connection": "keep-alive"
+      }
+    });
+  } catch (error) {
+    console.error("Error renaming:", error);
+    return jsonResponse({ error: "Failed to rename" }, { status: 500 });
+  }
+}
 async function handleFontsScan(request) {
   try {
     const { folder } = await request.json();
@@ -4988,6 +5149,7 @@ async function handleFontsAssign(request) {
               const baseName = path11.basename(ttfFile, ".ttf");
               const woff2Name = baseName + ".woff2";
               send({ status: "progress", message: `Compressing ${ttfFile}...`, current: i + 1, total: ttfFiles.length, currentFile: ttfFile });
+              await new Promise((resolve2) => setTimeout(resolve2, 1e3));
               try {
                 const ttfPath = path11.join(folderPath, ttfFile);
                 const input = readFileSync(ttfPath);
@@ -5022,6 +5184,7 @@ async function handleFontsAssign(request) {
           for (let i = 0; i < assignments.length; i++) {
             const assignmentName = assignments[i];
             send({ status: "progress", message: `Writing ${assignmentName}.ts...`, current: i + 1, total: assignments.length });
+            await new Promise((resolve2) => setTimeout(resolve2, 1e3));
             try {
               const fileName = `${assignmentName}.ts`;
               const filePath = path11.join(srcFontsPath, fileName);
@@ -5144,7 +5307,9 @@ async function startServer(options) {
   app.post("/api/studio/fonts/upload", wrapRawHandler(handleFontsUpload));
   app.post("/api/studio/fonts/create-folder", wrapHandler(handleFontsCreateFolder));
   app.post("/api/studio/fonts/delete", wrapHandler(handleFontsDelete));
+  app.post("/api/studio/fonts/delete-stream", wrapHandler(handleFontsDeleteStream, true));
   app.post("/api/studio/fonts/rename", wrapHandler(handleFontsRename));
+  app.post("/api/studio/fonts/rename-stream", wrapHandler(handleFontsRenameStream, true));
   app.post("/api/studio/fonts/scan", wrapHandler(handleFontsScan));
   app.get("/api/studio/fonts/assignments", wrapHandler(handleFontsListAssignments));
   app.post("/api/studio/fonts/assign-stream", wrapHandler(handleFontsAssign, true));