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

@gallop.software/studio 2.3.136 → 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 (5) hide show

package/dist/client/assets/index-3VggyaFt.js +94 -0
package/dist/client/index.html +1 -1
package/dist/server/index.js +146 -153
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-8i66yX4y.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

@@ -4575,123 +4575,86 @@ async function handleEditImage(request) {
 // src/handlers/fonts.ts
 import { promises as fs12 } from "fs";
 import path11 from "path";
-var VALID_WEIGHTS = [
-  "thin",
-  "extralight",
-  "light",
-  "regular",
-  "medium",
-  "semibold",
-  "bold",
-  "extrabold",
-  "black"
-];
-function parseFontFilename(filename) {
-  const nameWithoutExt = filename.replace(/\.(ttf|woff2?|otf)$/i, "");
-  const nameLower = nameWithoutExt.toLowerCase();
-  const hasItalic = nameLower.includes("italic");
-  const style = hasItalic ? "italic" : "normal";
-  const parts = nameWithoutExt.split(/[-_]/);
-  if (parts.length === 1) {
-    return {
-      basename: nameLower.replace("italic", "").trim(),
-      weight: "regular",
-      style,
-      isValid: false
-    };
-  }
-  const basename = parts[0].toLowerCase();
-  const weightPart = parts.slice(1).join("").toLowerCase().replace("italic", "");
-  let weight = "regular";
-  let isValid = false;
-  for (const validWeight of VALID_WEIGHTS) {
-    if (weightPart.includes(validWeight)) {
-      weight = validWeight;
-      isValid = true;
-      break;
+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 (!isValid) {
-    if (weightPart === "" || weightPart === "regular" || weightPart === "normal") {
-      weight = "regular";
-      isValid = true;
+    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 });
     }
-  }
-  return { basename, weight, style, isValid };
-}
-function generateFontFilename(basename, weight, style, ext) {
-  const styleSuffix = style === "italic" ? "italic" : "";
-  const weightAndStyle = weight + styleSuffix;
-  return `${basename}-${weightAndStyle}${ext}`.toLowerCase();
-}
-async function handleFontsList() {
-  try {
-    const fontsDir = getWorkspacePath("_fonts");
-    const configDir = getWorkspacePath("src", "fonts");
-    const families = [];
-    const configs = [];
+    fsPath = getWorkspacePath(requestedPath);
     try {
-      const entries = await fs12.readdir(fontsDir, { withFileTypes: true });
-      for (const entry of entries) {
-        if (entry.isDirectory()) {
-          const familyName = entry.name.toLowerCase();
-          const familyPath = path11.join(fontsDir, entry.name);
-          const files = await fs12.readdir(familyPath);
-          const fontFiles = [];
-          const weightsSet = /* @__PURE__ */ new Set();
-          for (const file of files) {
-            if (file.match(/\.(ttf|woff2?)$/i)) {
-              const parsed = parseFontFilename(file);
-              fontFiles.push({
-                name: file,
-                weight: parsed.weight,
-                style: parsed.style,
-                path: `_fonts/${entry.name}/${file}`
-              });
-              weightsSet.add(parsed.weight);
-            }
-          }
-          if (fontFiles.length > 0) {
-            families.push({
-              name: familyName,
-              files: fontFiles.sort((a, b) => {
-                const weightOrder = VALID_WEIGHTS.indexOf(a.weight) - VALID_WEIGHTS.indexOf(b.weight);
-                if (weightOrder !== 0) return weightOrder;
-                return a.style === "normal" ? -1 : 1;
-              }),
-              fileCount: fontFiles.length,
-              weights: Array.from(weightsSet).sort(
-                (a, b) => VALID_WEIGHTS.indexOf(a) - VALID_WEIGHTS.indexOf(b)
-              )
-            });
-          }
-        }
+      const stat = await fs12.stat(fsPath);
+      if (!stat.isDirectory()) {
+        return jsonResponse({ items: [] });
       }
     } catch {
+      return jsonResponse({ items: [], canCreate: true });
     }
-    try {
-      const configFiles = await fs12.readdir(configDir);
-      for (const file of configFiles) {
-        if (file.endsWith(".ts") && !file.startsWith("_")) {
-          const configPath = path11.join(configDir, file);
-          const content = await fs12.readFile(configPath, "utf-8");
-          const exportMatch = content.match(/export\s+const\s+(\w+)\s*=/);
-          const exportName = exportMatch ? exportMatch[1] : file.replace(".ts", "") + "Font";
-          const pathMatch = content.match(/path:\s*['"]\.\.\/\.\.\/\_fonts\/([^\/]+)\//);
-          const family = pathMatch ? pathMatch[1].toLowerCase() : "unknown";
-          const type = file.replace(".ts", "");
-          configs.push({
-            type,
-            family,
-            path: `src/fonts/${file}`,
-            exportName
+    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
           });
         }
       }
-    } catch {
     }
-    families.sort((a, b) => a.name.localeCompare(b.name));
-    return jsonResponse({ families, configs });
+    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 });
@@ -4700,67 +4663,95 @@ async function handleFontsList() {
 async function handleFontsUpload(request) {
   try {
     const formData = await request.formData();
-    const files = formData.getAll("files");
-    const renamesJson = formData.get("renames");
-    if (!files || files.length === 0) {
-      return jsonResponse({ error: "No files provided" }, { status: 400 });
+    const file = formData.get("file");
+    const targetPath = formData.get("path") || "_fonts";
+    if (!file) {
+      return jsonResponse({ error: "No file provided" }, { status: 400 });
     }
-    let renames = {};
-    if (renamesJson) {
-      try {
-        renames = JSON.parse(renamesJson);
-      } catch {
+    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 fontsDir = getWorkspacePath("_fonts");
-    const uploaded = [];
+    const deleted = [];
     const errors = [];
-    for (const file of files) {
+    for (const p of paths) {
       try {
-        if (!file.name.toLowerCase().endsWith(".ttf")) {
-          errors.push({ file: file.name, error: "Only TTF files are supported" });
-          continue;
-        }
-        const bytes = await file.arrayBuffer();
-        const buffer = Buffer.from(bytes);
-        let basename;
-        let weight;
-        let style;
-        if (renames[file.name]) {
-          basename = renames[file.name].basename.toLowerCase();
-          weight = renames[file.name].weight.toLowerCase();
-          style = renames[file.name].style.toLowerCase();
+        const fullPath = getWorkspacePath(p);
+        const stat = await fs12.stat(fullPath);
+        if (stat.isDirectory()) {
+          await fs12.rm(fullPath, { recursive: true });
         } else {
-          const parsed = parseFontFilename(file.name);
-          basename = parsed.basename;
-          weight = parsed.weight;
-          style = parsed.style;
+          await fs12.unlink(fullPath);
         }
-        const newFilename = generateFontFilename(basename, weight, style, ".ttf");
-        const familyDir = path11.join(fontsDir, basename);
-        await fs12.mkdir(familyDir, { recursive: true });
-        const filePath = path11.join(familyDir, newFilename);
-        await fs12.writeFile(filePath, buffer);
-        uploaded.push({
-          original: file.name,
-          saved: newFilename,
-          path: `_fonts/${basename}/${newFilename}`
-        });
+        deleted.push(p);
       } catch (err) {
-        errors.push({
-          file: file.name,
-          error: err instanceof Error ? err.message : "Unknown error"
-        });
+        errors.push(`Failed to delete ${p}: ${err instanceof Error ? err.message : "Unknown error"}`);
       }
     }
     return jsonResponse({
       success: true,
-      uploaded,
+      deleted,
       errors: errors.length > 0 ? errors : void 0
     });
   } catch (error) {
-    console.error("Error uploading fonts:", error);
-    return jsonResponse({ error: "Failed to upload fonts" }, { status: 500 });
+    console.error("Error deleting:", error);
+    return jsonResponse({ error: "Failed to delete" }, { status: 500 });
   }
 }
@@ -4840,6 +4831,8 @@ async function startServer(options) {
   );
   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));