npm - @gallop.software/studio - Versions diffs - 2.3.68 → 2.3.70 - Mend

@gallop.software/studio 2.3.68 → 2.3.70

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-D41DQ8-d.js +80 -0
package/dist/client/assets/index-yYR0IQiU.js +80 -0
package/dist/client/index.html +1 -1
package/dist/server/index.js +184 -21
package/dist/server/index.js.map +1 -1
package/package.json +2 -2

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-BvENFNqZ.js"></script>
+    <script type="module" crossorigin src="/assets/index-yYR0IQiU.js"></script>
   </head>
   <body>
     <div id="root"></div>

package/dist/server/index.js CHANGED Viewed

@@ -141,7 +141,6 @@ function getContentType(filePath) {
 import { promises as fs2 } from "fs";
 import path3 from "path";
 import sharp from "sharp";
-import { encode } from "blurhash";
 var FULL_MAX_WIDTH = 2560;
 var DEFAULT_SIZES = {
   small: { width: 300, suffix: "-sm", key: "sm" },
@@ -201,8 +200,6 @@ async function processImage(buffer, imageKey) {
     }
     entry[key] = { w: maxWidth, h: newHeight };
   }
-  const { data, info } = await sharp(buffer).resize(32, 32, { fit: "inside" }).ensureAlpha().raw().toBuffer({ resolveWithObject: true });
-  entry.b = encode(new Uint8ClampedArray(data), info.width, info.height, 4, 4);
   return entry;
 }
@@ -3314,7 +3311,6 @@ async function handleMoveStream(request) {
 import { promises as fs8 } from "fs";
 import path8 from "path";
 import sharp3 from "sharp";
-import { encode as encode2 } from "blurhash";
 async function handleScanStream() {
   const encoder = new TextEncoder();
   const stream = new ReadableStream({
@@ -3421,16 +3417,13 @@ async function handleScanStream() {
             if (isImage) {
               const ext = path8.extname(relativePath).toLowerCase();
               if (ext === ".svg") {
-                meta[imageKey] = { o: { w: 0, h: 0 }, b: "" };
+                meta[imageKey] = { o: { w: 0, h: 0 } };
               } else {
                 try {
                   const buffer = await fs8.readFile(fullPath);
                   const metadata = await sharp3(buffer).metadata();
-                  const { data, info } = await sharp3(buffer).resize(32, 32, { fit: "inside" }).ensureAlpha().raw().toBuffer({ resolveWithObject: true });
-                  const blurhash = encode2(new Uint8ClampedArray(data), info.width, info.height, 4, 4);
                   meta[imageKey] = {
-                    o: { w: metadata.width || 0, h: metadata.height || 0 },
-                    b: blurhash
+                    o: { w: metadata.width || 0, h: metadata.height || 0 }
                   };
                 } catch {
                   meta[imageKey] = { o: { w: 0, h: 0 } };
@@ -3632,7 +3625,6 @@ async function handleDeleteOrphans(request) {
 // src/handlers/import.ts
 import sharp4 from "sharp";
-import { encode as encode3 } from "blurhash";
 function parseImageUrl(url) {
   const parsed = new URL(url);
   const base = `${parsed.protocol}//${parsed.host}`;
@@ -3646,11 +3638,8 @@ async function processRemoteImage(url) {
   }
   const buffer = Buffer.from(await response.arrayBuffer());
   const metadata = await sharp4(buffer).metadata();
-  const { data, info } = await sharp4(buffer).resize(32, 32, { fit: "inside" }).ensureAlpha().raw().toBuffer({ resolveWithObject: true });
-  const blurhash = encode3(new Uint8ClampedArray(data), info.width, info.height, 4, 4);
   return {
-    o: { w: metadata.width || 0, h: metadata.height || 0 },
-    b: blurhash
+    o: { w: metadata.width || 0, h: metadata.height || 0 }
   };
 }
 async function handleImportUrls(request) {
@@ -3911,6 +3900,152 @@ async function handleGenerateFavicon(request) {
   });
 }
+// src/handlers/featured-image.ts
+import puppeteer from "puppeteer";
+import fs10 from "fs/promises";
+async function handleGenerateFeaturedImage(request) {
+  const encoder = new TextEncoder();
+  let customUrl;
+  try {
+    const body = await request.json();
+    customUrl = body.url;
+  } catch {
+  }
+  const stream = new ReadableStream({
+    async start(controller) {
+      const sendEvent = (data) => {
+        controller.enqueue(encoder.encode(`data: ${JSON.stringify(data)}
+`));
+      };
+      try {
+        const packageJsonPath2 = getWorkspacePath("package.json");
+        let projectName = "featured-image";
+        let homepageUrl = customUrl || process.env.STUDIO_DEV_SITE_URL || "http://localhost:3000";
+        try {
+          const packageJsonContent = await fs10.readFile(packageJsonPath2, "utf8");
+          const packageJson2 = JSON.parse(packageJsonContent);
+          projectName = packageJson2.name || "featured-image";
+          if (!customUrl && packageJson2.homepage) {
+            homepageUrl = packageJson2.homepage;
+          }
+        } catch {
+        }
+        const outputPath = getPublicPath(`${projectName}.jpg`);
+        const relativePath = `public/${projectName}.jpg`;
+        sendEvent({
+          type: "start",
+          total: 3,
+          projectName,
+          url: homepageUrl,
+          output: relativePath
+        });
+        sendEvent({
+          type: "progress",
+          current: 1,
+          total: 3,
+          percent: 33,
+          message: "Launching browser..."
+        });
+        const browser = await puppeteer.launch({
+          headless: true,
+          args: ["--no-sandbox", "--disable-setuid-sandbox"]
+        });
+        try {
+          sendEvent({
+            type: "progress",
+            current: 2,
+            total: 3,
+            percent: 66,
+            message: `Navigating to ${homepageUrl}...`
+          });
+          const page = await browser.newPage();
+          await page.setViewport({
+            width: 2e3,
+            height: 1e3,
+            deviceScaleFactor: 2
+            // Retina display quality
+          });
+          await page.goto(homepageUrl, {
+            waitUntil: "networkidle2",
+            timeout: 3e4
+          });
+          await new Promise((resolve2) => setTimeout(resolve2, 2e3));
+          sendEvent({
+            type: "progress",
+            current: 3,
+            total: 3,
+            percent: 90,
+            message: "Taking screenshot..."
+          });
+          await page.screenshot({
+            path: outputPath,
+            type: "jpeg",
+            quality: 90
+          });
+          sendEvent({
+            type: "complete",
+            processed: 1,
+            errors: 0,
+            outputPath: relativePath,
+            message: `Featured image saved to ${relativePath}`
+          });
+        } finally {
+          await browser.close();
+        }
+        controller.close();
+      } catch (error) {
+        console.error("Featured image generation error:", error);
+        const errorMessage = error instanceof Error ? error.message : "Unknown error";
+        sendEvent({
+          type: "error",
+          message: `Failed to generate featured image: ${errorMessage}`
+        });
+        controller.close();
+      }
+    }
+  });
+  return new Response(stream, {
+    headers: {
+      "Content-Type": "text/event-stream",
+      "Cache-Control": "no-cache",
+      Connection: "keep-alive"
+    }
+  });
+}
+async function handleCheckFeaturedImage() {
+  try {
+    const packageJsonPath2 = getWorkspacePath("package.json");
+    let projectName = "featured-image";
+    try {
+      const packageJsonContent = await fs10.readFile(packageJsonPath2, "utf8");
+      const packageJson2 = JSON.parse(packageJsonContent);
+      projectName = packageJson2.name || "featured-image";
+    } catch {
+    }
+    const expectedFilename = `${projectName}.jpg`;
+    const expectedPath = getPublicPath(expectedFilename);
+    let exists = false;
+    try {
+      await fs10.access(expectedPath);
+      exists = true;
+    } catch {
+      exists = false;
+    }
+    return jsonResponse({
+      filename: expectedFilename,
+      exists,
+      projectName
+    });
+  } catch (error) {
+    console.error("Check featured image error:", error);
+    return jsonResponse(
+      { error: "Failed to check featured image" },
+      { status: 500 }
+    );
+  }
+}
 // src/server/index.ts
 var __filename = fileURLToPath(import.meta.url);
 var __dirname = dirname(__filename);
@@ -3937,7 +4072,9 @@ async function findAvailablePort(startPort, maxAttempts = 10) {
       return port;
     }
   }
-  throw new Error(`No available port found between ${startPort} and ${startPort + maxAttempts - 1}`);
+  throw new Error(
+    `No available port found between ${startPort} and ${startPort + maxAttempts - 1}`
+  );
 }
 async function startServer(options) {
   const { port: requestedPort, workspace, open } = options;
@@ -3971,6 +4108,10 @@ async function startServer(options) {
   app.get("/api/studio/count-images", wrapHandler(handleCountImages));
   app.get("/api/studio/folder-images", wrapHandler(handleFolderImages));
   app.get("/api/studio/cdns", wrapHandler(handleGetCdns));
+  app.get(
+    "/api/studio/check-featured-image",
+    wrapHandler(handleCheckFeaturedImage)
+  );
   app.post("/api/studio/upload", wrapRawHandler(handleUpload));
   app.post("/api/studio/create-folder", wrapHandler(handleCreateFolder));
   app.post("/api/studio/rename", wrapHandler(handleRename));
@@ -3978,17 +4119,39 @@ async function startServer(options) {
   app.post("/api/studio/move", wrapHandler(handleMoveStream, true));
   app.post("/api/studio/sync", wrapHandler(handleSync, true));
   app.post("/api/studio/sync-stream", wrapHandler(handleSyncStream, true));
-  app.post("/api/studio/reprocess-stream", wrapHandler(handleReprocessStream, true));
-  app.post("/api/studio/unprocess-stream", wrapHandler(handleUnprocessStream, true));
-  app.post("/api/studio/download-stream", wrapHandler(handleDownloadStream, true));
-  app.post("/api/studio/push-updates-stream", wrapHandler(handlePushUpdatesStream, true));
+  app.post(
+    "/api/studio/reprocess-stream",
+    wrapHandler(handleReprocessStream, true)
+  );
+  app.post(
+    "/api/studio/unprocess-stream",
+    wrapHandler(handleUnprocessStream, true)
+  );
+  app.post(
+    "/api/studio/download-stream",
+    wrapHandler(handleDownloadStream, true)
+  );
+  app.post(
+    "/api/studio/push-updates-stream",
+    wrapHandler(handlePushUpdatesStream, true)
+  );
   app.post("/api/studio/cancel-updates", wrapHandler(handleCancelUpdates));
-  app.post("/api/studio/cancel-stream", wrapHandler(handleCancelStreamOperation));
+  app.post(
+    "/api/studio/cancel-stream",
+    wrapHandler(handleCancelStreamOperation)
+  );
   app.post("/api/studio/scan", wrapHandler(handleScanStream, true));
   app.post("/api/studio/delete-orphans", wrapHandler(handleDeleteOrphans));
   app.post("/api/studio/import", wrapHandler(handleImportUrls, true));
   app.post("/api/studio/cdns", wrapHandler(handleUpdateCdns));
-  app.post("/api/studio/generate-favicon", wrapHandler(handleGenerateFavicon, true));
+  app.post(
+    "/api/studio/generate-favicon",
+    wrapHandler(handleGenerateFavicon, true)
+  );
+  app.post(
+    "/api/studio/generate-featured-image",
+    wrapHandler(handleGenerateFeaturedImage, true)
+  );
   app.post("/api/studio/delete", wrapHandler(handleDelete));
   app.post("/api/studio/delete-stream", wrapHandler(handleDeleteStream, true));
   app.use(express.static(join(workspace, "public")));