npm - @gallop.software/studio - Versions diffs - 2.3.135 → 2.3.137 - Mend

@gallop.software/studio 2.3.135 → 2.3.137

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-3VggyaFt.js +94 -0
package/dist/client/assets/index-8i66yX4y.js +105 -0
package/dist/client/index.html +1 -1
package/dist/server/index.js +197 -9
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-CyMBtvIS.js"></script>
+    <script type="module" crossorigin src="/assets/index-3VggyaFt.js"></script>
     <link rel="stylesheet" crossorigin href="/assets/index-DfPQBmNf.css">
   </head>
   <body>

package/dist/server/index.js CHANGED Viewed

@@ -3967,8 +3967,8 @@ import sharp4 from "sharp";
 function parseImageUrl(url) {
   const parsed = new URL(url);
   const base = `${parsed.protocol}//${parsed.host}`;
-  const path11 = parsed.pathname;
-  return { base, path: path11 };
+  const path12 = parsed.pathname;
+  return { base, path: path12 };
 }
 async function processRemoteImage(url) {
   const response = await fetch(url);
@@ -4029,10 +4029,10 @@ async function handleImportUrls(request) {
           const url = urls[i].trim();
           if (!url) continue;
           try {
-            const { base, path: path11 } = parseImageUrl(url);
-            const existingEntry = getMetaEntry(meta, path11);
+            const { base, path: path12 } = parseImageUrl(url);
+            const existingEntry = getMetaEntry(meta, path12);
             if (existingEntry) {
-              skipped.push(path11);
+              skipped.push(path12);
               sendEvent({
                 type: "progress",
                 current: i + 1,
@@ -4045,13 +4045,13 @@ async function handleImportUrls(request) {
             }
             const cdnIndex = getOrAddCdnIndex(meta, base);
             const imageData = await processRemoteImage(url);
-            setMetaEntry(meta, path11, {
+            setMetaEntry(meta, path12, {
               o: imageData.o,
               b: imageData.b,
               c: cdnIndex
             });
             await saveMeta(meta);
-            added.push(path11);
+            added.push(path12);
             sendEvent({
               type: "progress",
               current: i + 1,
@@ -4572,6 +4572,189 @@ async function handleEditImage(request) {
   }
 }
+// src/handlers/fonts.ts
+import { promises as fs12 } from "fs";
+import path11 from "path";
+async function handleFontsList(request) {
+  const searchParams = new URL(request.url).searchParams;
+  const requestedPath = searchParams.get("path") || "_fonts";
+  try {
+    const items = [];
+    let fsPath;
+    let allowedPaths = ["_fonts", "src/fonts", "src"];
+    const isAllowed = allowedPaths.some(
+      (allowed) => requestedPath === allowed || requestedPath.startsWith(allowed + "/")
+    );
+    if (!isAllowed) {
+      return jsonResponse({ items: [], error: "Path not allowed" }, { status: 400 });
+    }
+    if (requestedPath === "src") {
+      const fontsFolderPath = getWorkspacePath("src", "fonts");
+      try {
+        const stat = await fs12.stat(fontsFolderPath);
+        if (stat.isDirectory()) {
+          items.push({
+            name: "fonts",
+            path: "src/fonts",
+            type: "folder"
+          });
+        }
+      } catch {
+      }
+      return jsonResponse({ items, canCreate: true });
+    }
+    fsPath = getWorkspacePath(requestedPath);
+    try {
+      const stat = await fs12.stat(fsPath);
+      if (!stat.isDirectory()) {
+        return jsonResponse({ items: [] });
+      }
+    } catch {
+      return jsonResponse({ items: [], canCreate: true });
+    }
+    const entries = await fs12.readdir(fsPath, { withFileTypes: true });
+    for (const entry of entries) {
+      const itemPath = `${requestedPath}/${entry.name}`;
+      if (entry.isDirectory()) {
+        let fileCount = 0;
+        try {
+          const subEntries = await fs12.readdir(path11.join(fsPath, entry.name));
+          fileCount = subEntries.filter(
+            (f) => f.match(/\.(ttf|woff2?|otf|ts|tsx|js)$/i)
+          ).length;
+        } catch {
+        }
+        items.push({
+          name: entry.name,
+          path: itemPath,
+          type: "folder",
+          fileCount
+        });
+      } else {
+        const ext = path11.extname(entry.name).toLowerCase();
+        const allowedExts = [".ttf", ".woff", ".woff2", ".otf", ".ts", ".tsx", ".js"];
+        if (allowedExts.includes(ext)) {
+          let size = 0;
+          try {
+            const fileStat = await fs12.stat(path11.join(fsPath, entry.name));
+            size = fileStat.size;
+          } catch {
+          }
+          items.push({
+            name: entry.name,
+            path: itemPath,
+            type: "file",
+            size
+          });
+        }
+      }
+    }
+    items.sort((a, b) => {
+      if (a.type === "folder" && b.type !== "folder") return -1;
+      if (a.type !== "folder" && b.type === "folder") return 1;
+      return a.name.localeCompare(b.name);
+    });
+    return jsonResponse({ items });
+  } catch (error) {
+    console.error("Error listing fonts:", error);
+    return jsonResponse({ error: "Failed to list fonts" }, { status: 500 });
+  }
+}
+async function handleFontsUpload(request) {
+  try {
+    const formData = await request.formData();
+    const file = formData.get("file");
+    const targetPath = 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")) {
+      return jsonResponse({ error: "Can only upload to _fonts/" }, { status: 400 });
+    }
+    const bytes = await file.arrayBuffer();
+    const buffer = Buffer.from(bytes);
+    const uploadDir = getWorkspacePath(targetPath);
+    await fs12.mkdir(uploadDir, { recursive: true });
+    const filePath = path11.join(uploadDir, file.name.toLowerCase());
+    await fs12.writeFile(filePath, buffer);
+    return jsonResponse({
+      success: true,
+      path: `${targetPath}/${file.name.toLowerCase()}`
+    });
+  } catch (error) {
+    console.error("Error uploading font:", error);
+    return jsonResponse({ error: "Failed to upload font" }, { status: 500 });
+  }
+}
+async function handleFontsCreateFolder(request) {
+  try {
+    const { path: targetPath, name } = await request.json();
+    if (!targetPath || !name) {
+      return jsonResponse({ error: "Path and name are required" }, { status: 400 });
+    }
+    const allowedPaths = ["_fonts", "src/fonts", "src"];
+    const isAllowed = allowedPaths.some(
+      (allowed) => targetPath === allowed || targetPath.startsWith(allowed + "/")
+    );
+    if (!isAllowed) {
+      return jsonResponse({ error: "Path not allowed" }, { status: 400 });
+    }
+    const folderPath = getWorkspacePath(targetPath, name.toLowerCase());
+    await fs12.mkdir(folderPath, { recursive: true });
+    return jsonResponse({
+      success: true,
+      path: `${targetPath}/${name.toLowerCase()}`
+    });
+  } catch (error) {
+    console.error("Error creating folder:", error);
+    return jsonResponse({ error: "Failed to create folder" }, { status: 500 });
+  }
+}
+async function handleFontsDelete(request) {
+  try {
+    const { paths } = await request.json();
+    if (!paths || !Array.isArray(paths) || paths.length === 0) {
+      return jsonResponse({ error: "Paths are required" }, { status: 400 });
+    }
+    const allowedPaths = ["_fonts", "src/fonts"];
+    for (const p of paths) {
+      const isAllowed = allowedPaths.some(
+        (allowed) => p.startsWith(allowed + "/")
+      );
+      if (!isAllowed) {
+        return jsonResponse({ error: `Path not allowed: ${p}` }, { status: 400 });
+      }
+    }
+    const deleted = [];
+    const errors = [];
+    for (const p of paths) {
+      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"}`);
+      }
+    }
+    return jsonResponse({
+      success: true,
+      deleted,
+      errors: errors.length > 0 ? errors : void 0
+    });
+  } catch (error) {
+    console.error("Error deleting:", error);
+    return jsonResponse({ error: "Failed to delete" }, { status: 500 });
+  }
+}
 // src/server/index.ts
 var __filename = fileURLToPath(import.meta.url);
 var __dirname = dirname(__filename);
@@ -4617,15 +4800,16 @@ async function startServer(options) {
   if (!process.env.STUDIO_DEV_SITE_URL && process.env.NEXT_PUBLIC_PRODUCTION_URL) {
     process.env.STUDIO_DEV_SITE_URL = process.env.NEXT_PUBLIC_PRODUCTION_URL;
   }
+  const rawBodyPaths = ["/api/studio/upload", "/api/studio/fonts/upload"];
   app.use((req, res, next) => {
-    if (req.path === "/api/studio/upload") {
+    if (rawBodyPaths.includes(req.path)) {
       next();
     } else {
       express.json({ limit: "50mb" })(req, res, next);
     }
   });
   app.use((req, res, next) => {
-    if (req.path === "/api/studio/upload") {
+    if (rawBodyPaths.includes(req.path)) {
       next();
     } else {
       express.urlencoded({ extended: true, limit: "50mb" })(req, res, next);
@@ -4645,6 +4829,10 @@ async function startServer(options) {
     "/api/studio/featured-image-options",
     wrapHandler(handleGetFeaturedImageOptions)
   );
+  app.get("/api/studio/fonts/list", wrapHandler(handleFontsList));
+  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/upload", wrapRawHandler(handleUpload));
   app.post("/api/studio/create-folder", wrapHandler(handleCreateFolder));
   app.post("/api/studio/rename", wrapHandler(handleRename));