@cloudwerk/vite-plugin 0.8.0 → 0.8.2

package/dist/index.js

@@ -557,6 +557,13 @@ app.use('*', async (c, next) => {
     return
   }
 
+  // Skip static asset serving during SSG \u2014 the ASSETS binding from getPlatformProxy
+  // is not a real Workers Static Assets binding and does not support fetch(Request)
+  if (c.env?.HONO_SSG_CONTEXT) {
+    await next()
+    return
+  }
+
   // Only serve static assets for GET/HEAD requests
   // Other methods (POST, PUT, etc.) should go directly to route handlers
   // to avoid consuming the request body
@@ -567,7 +574,15 @@ app.use('*', async (c, next) => {
   }
 
   // Try to serve the request as a static asset
-  const response = await c.env.ASSETS.fetch(c.req.raw)
+  let response
+  try {
+    response = await c.env.ASSETS.fetch(c.req.raw)
+  } catch {
+    // ASSETS.fetch can fail during SSG or when the binding is a proxy
+    // that doesn't support fetch(Request) \u2014 fall through to routes
+    await next()
+    return
+  }
 
   // If asset found (not 404), return it with cache headers
   if (response.status !== 404) {
@@ -1767,8 +1782,111 @@ function stripServerExports(code) {
     const replacement = removal.replacement ?? "";
     result = result.slice(0, start) + replacement + result.slice(end);
   }
+  result = removeUnusedImports(result);
   return { code: result, stripped };
 }
+function removeUnusedImports(code) {
+  const ast = parseSync2(code, {
+    syntax: "typescript",
+    tsx: true,
+    comments: true
+  });
+  const offset = ast.span.start;
+  const imports = [];
+  for (const node of ast.body) {
+    if (node.type !== "ImportDeclaration") continue;
+    if (node.specifiers.length === 0) continue;
+    const specifiers = [];
+    for (const spec of node.specifiers) {
+      if (spec.type === "ImportSpecifier") {
+        specifiers.push({ localName: spec.local.value });
+      } else if (spec.type === "ImportDefaultSpecifier") {
+        specifiers.push({ localName: spec.local.value });
+      } else if (spec.type === "ImportNamespaceSpecifier") {
+        specifiers.push({ localName: spec.local.value });
+      }
+    }
+    if (specifiers.length > 0) {
+      imports.push({
+        node,
+        start: node.span.start,
+        end: node.span.end,
+        specifiers
+      });
+    }
+  }
+  if (imports.length === 0) return code;
+  const importRanges = imports.map((i) => ({ start: i.start - offset, end: i.end - offset }));
+  let remaining = "";
+  let pos = 0;
+  for (const range of importRanges.sort((a, b) => a.start - b.start)) {
+    remaining += code.slice(pos, range.start);
+    pos = range.end;
+  }
+  remaining += code.slice(pos);
+  const removals = [];
+  for (const imp of imports) {
+    const unusedSpecs = [];
+    const usedSpecs = [];
+    for (const spec of imp.specifiers) {
+      const regex = new RegExp(`\\b${escapeRegExp(spec.localName)}\\b`);
+      if (regex.test(remaining)) {
+        usedSpecs.push(spec);
+      } else {
+        unusedSpecs.push(spec.localName);
+      }
+    }
+    if (unusedSpecs.length === 0) continue;
+    if (usedSpecs.length === 0) {
+      removals.push({ start: imp.start, end: imp.end });
+    } else {
+      const importNode = imp.node;
+      const source = code.slice(
+        importNode.source.span.start - offset,
+        importNode.source.span.end - offset
+      );
+      const typeOnly = importNode.typeOnly ? "type " : "";
+      const keptNamed = [];
+      let keptDefault = null;
+      let keptNamespace = null;
+      for (const spec of importNode.specifiers) {
+        const localName = spec.local.value;
+        if (!usedSpecs.some((u) => u.localName === localName)) continue;
+        if (spec.type === "ImportDefaultSpecifier") {
+          keptDefault = localName;
+        } else if (spec.type === "ImportNamespaceSpecifier") {
+          keptNamespace = localName;
+        } else if (spec.type === "ImportSpecifier") {
+          const imported = spec.imported;
+          if (imported && imported.type === "Identifier" && imported.value !== localName) {
+            keptNamed.push(`${imported.value} as ${localName}`);
+          } else {
+            keptNamed.push(localName);
+          }
+        }
+      }
+      const parts = [];
+      if (keptDefault) parts.push(keptDefault);
+      if (keptNamespace) parts.push(`* as ${keptNamespace}`);
+      if (keptNamed.length > 0) parts.push(`{ ${keptNamed.join(", ")} }`);
+      const replacement = `import ${typeOnly}${parts.join(", ")} from ${source}`;
+      removals.push({ start: imp.start, end: imp.end, replacement });
+    }
+  }
+  if (removals.length === 0) return code;
+  let result = code;
+  removals.sort((a, b) => b.start - a.start);
+  for (const removal of removals) {
+    const start = removal.start - offset;
+    const end = removal.end - offset;
+    const replacement = removal.replacement ?? "";
+    result = result.slice(0, start) + replacement + result.slice(end);
+  }
+  return result;
+}
+function escapeRegExp(s) {
+  return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
 
 // src/wrangler-watcher.ts
 import * as fs from "fs";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cloudwerk/vite-plugin",
-  "version": "0.8.0",
+  "version": "0.8.2",
   "description": "Vite plugin for Cloudwerk file-based routing with virtual entry generation",
   "repository": {
     "type": "git",
@@ -23,7 +23,7 @@
     "@cloudwerk/ui": "^0.15.6"
   },
   "peerDependencies": {
-    "vite": "^5.0.0 || ^6.0.0",
+    "vite": "^5.0.0 || ^6.0.0 || ^7.0.0",
     "@hono/vite-dev-server": ">=0.18.0",
     "hono": "^4.0.0"
   },