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

@gallop.software/studio 2.3.135 → 2.3.136

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-8i66yX4y.js +105 -0
package/dist/client/index.html +1 -1
package/dist/server/index.js +204 -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-8i66yX4y.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,198 @@ 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;
+    }
+  }
+  if (!isValid) {
+    if (weightPart === "" || weightPart === "regular" || weightPart === "normal") {
+      weight = "regular";
+      isValid = 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 = [];
+    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)
+              )
+            });
+          }
+        }
+      }
+    } catch {
+    }
+    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
+          });
+        }
+      }
+    } catch {
+    }
+    families.sort((a, b) => a.name.localeCompare(b.name));
+    return jsonResponse({ families, configs });
+  } 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 files = formData.getAll("files");
+    const renamesJson = formData.get("renames");
+    if (!files || files.length === 0) {
+      return jsonResponse({ error: "No files provided" }, { status: 400 });
+    }
+    let renames = {};
+    if (renamesJson) {
+      try {
+        renames = JSON.parse(renamesJson);
+      } catch {
+      }
+    }
+    const fontsDir = getWorkspacePath("_fonts");
+    const uploaded = [];
+    const errors = [];
+    for (const file of files) {
+      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();
+        } else {
+          const parsed = parseFontFilename(file.name);
+          basename = parsed.basename;
+          weight = parsed.weight;
+          style = parsed.style;
+        }
+        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}`
+        });
+      } catch (err) {
+        errors.push({
+          file: file.name,
+          error: err instanceof Error ? err.message : "Unknown error"
+        });
+      }
+    }
+    return jsonResponse({
+      success: true,
+      uploaded,
+      errors: errors.length > 0 ? errors : void 0
+    });
+  } catch (error) {
+    console.error("Error uploading fonts:", error);
+    return jsonResponse({ error: "Failed to upload fonts" }, { status: 500 });
+  }
+}
 // src/server/index.ts
 var __filename = fileURLToPath(import.meta.url);
 var __dirname = dirname(__filename);
@@ -4617,15 +4809,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 +4838,8 @@ 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/upload", wrapRawHandler(handleUpload));
   app.post("/api/studio/create-folder", wrapHandler(handleCreateFolder));
   app.post("/api/studio/rename", wrapHandler(handleRename));