@zappdev/vite 0.5.0-alpha.0 → 0.5.0-alpha.2

package/dist/index.js

@@ -0,0 +1,200 @@
+import { createRequire } from "node:module";
+var __require = /* @__PURE__ */ createRequire(import.meta.url);
+
+// src/index.ts
+import path from "node:path";
+import { existsSync } from "node:fs";
+import { mkdir, readdir, readFile } from "node:fs/promises";
+var WORKER_PATTERN = /new\s+(?:SharedWorker|Worker)\s*\(\s*(?:new\s+URL\(\s*["'`](.+?)["'`]\s*,\s*import\.meta\.url\s*\)|["'`](.+?)["'`])/g;
+async function scanDir(dir) {
+  const results = [];
+  try {
+    const entries = await readdir(dir, { withFileTypes: true });
+    for (const entry of entries) {
+      if (entry.name.startsWith(".") || entry.name === "node_modules" || entry.name === "zapp")
+        continue;
+      const full = path.join(dir, entry.name);
+      if (entry.isDirectory()) {
+        results.push(...await scanDir(full));
+      } else if (/\.(ts|tsx|js|jsx|mjs)$/.test(entry.name)) {
+        results.push(full);
+      }
+    }
+  } catch {}
+  return results;
+}
+async function discoverWorkers(srcDir) {
+  const files = await scanDir(srcDir);
+  const found = new Map;
+  for (const file of files) {
+    const content = await readFile(file, "utf-8");
+    let match;
+    WORKER_PATTERN.lastIndex = 0;
+    while ((match = WORKER_PATTERN.exec(content)) !== null) {
+      const spec = match[1] || match[2];
+      if (!spec || found.has(spec))
+        continue;
+      const sourcePath = path.resolve(path.dirname(file), spec);
+      const baseName = path.basename(spec).replace(/\.[^.]+$/, "");
+      found.set(spec, {
+        specifier: spec,
+        sourcePath,
+        outputName: `${baseName}.mjs`,
+        outputUrl: `/_workers/${baseName}.mjs`
+      });
+    }
+  }
+  return [...found.values()];
+}
+async function bundleWorker(entry, outDir, aliases) {
+  try {
+    const vite = await import("vite");
+    await vite.build({
+      configFile: false,
+      logLevel: "silent",
+      build: {
+        outDir,
+        emptyOutDir: false,
+        minify: true,
+        rollupOptions: {
+          input: entry.sourcePath,
+          output: {
+            format: "es",
+            entryFileNames: entry.outputName,
+            dir: outDir
+          }
+        }
+      },
+      resolve: { alias: aliases }
+    });
+    return true;
+  } catch (e) {
+    console.error(`[zapp] worker bundle failed: ${entry.specifier}`, e);
+    return false;
+  }
+}
+function zappWorkers(options) {
+  let root = "";
+  let srcDir = "";
+  let workers = [];
+  let backendEntry = null;
+  let aliases = {};
+  let isDev = false;
+  let outDir = "";
+  let backendFromConfig = options?.backend;
+  return {
+    name: "zapp-workers",
+    enforce: "pre",
+    async configResolved(config) {
+      root = config.root;
+      srcDir = path.join(root, "src");
+      outDir = path.join(root, "dist", "_workers");
+      isDev = config.command === "serve";
+      const resolvedAlias = config.resolve?.alias;
+      if (resolvedAlias && typeof resolvedAlias === "object" && !Array.isArray(resolvedAlias)) {
+        aliases = resolvedAlias;
+      }
+      if (!backendFromConfig) {
+        try {
+          const configPath = path.join(root, "zapp.config.ts");
+          const mod = await import(configPath);
+          const zappConfig = typeof mod.default === "function" ? mod.default() : mod.default;
+          if (zappConfig?.backend) {
+            backendFromConfig = zappConfig.backend;
+          }
+        } catch {}
+      }
+    },
+    async buildStart() {
+      workers = await discoverWorkers(srcDir);
+      const backendSrc = backendFromConfig ? path.resolve(root, backendFromConfig) : path.join(srcDir, "backend.ts");
+      if (existsSync(backendSrc)) {
+        backendEntry = {
+          specifier: path.relative(srcDir, backendSrc),
+          sourcePath: backendSrc,
+          outputName: "backend.mjs",
+          outputUrl: "/_workers/backend.mjs"
+        };
+      }
+      if (workers.length > 0) {
+        console.log(`[zapp] discovered ${workers.length} worker(s)`);
+      }
+      if (backendEntry) {
+        console.log(`[zapp] backend worker: ${path.relative(root, backendSrc)}`);
+      }
+    },
+    transform(code, id) {
+      if (!id.endsWith(".ts") && !id.endsWith(".tsx") && !id.endsWith(".js") && !id.endsWith(".jsx"))
+        return null;
+      if (id.includes("node_modules"))
+        return null;
+      let modified = false;
+      let result = code;
+      for (const entry of workers) {
+        const escaped = entry.specifier.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+        const regex = new RegExp(`(new\\s+(?:SharedWorker|Worker)\\s*\\(\\s*["'\`])${escaped}(["'\`])`, "g");
+        const replaced = result.replace(regex, `$1${entry.outputUrl}$2`);
+        if (replaced !== result) {
+          result = replaced;
+          modified = true;
+        }
+      }
+      return modified ? { code: result, map: null } : null;
+    },
+    async configureServer(server) {
+      const devOutDir = path.join(root, ".zapp", "workers");
+      await mkdir(devOutDir, { recursive: true });
+      workers = await discoverWorkers(srcDir);
+      const backendSrc = backendFromConfig ? path.resolve(root, backendFromConfig) : path.join(srcDir, "backend.ts");
+      if (existsSync(backendSrc)) {
+        backendEntry = {
+          specifier: path.relative(srcDir, backendSrc),
+          sourcePath: backendSrc,
+          outputName: "backend.mjs",
+          outputUrl: "/_workers/backend.mjs"
+        };
+      }
+      const allEntries = [...workers];
+      if (backendEntry)
+        allEntries.push(backendEntry);
+      for (const entry of allEntries) {
+        const ok = await bundleWorker(entry, devOutDir, aliases);
+        if (ok)
+          console.log(`[zapp] dev-bundled worker: ${entry.outputName}`);
+      }
+      server.middlewares.use(async (req, res, next) => {
+        if (!req.url?.startsWith("/_workers/"))
+          return next();
+        const fileName = req.url.slice("/_workers/".length);
+        const filePath = path.join(devOutDir, fileName);
+        if (existsSync(filePath)) {
+          const content = await readFile(filePath, "utf-8");
+          res.setHeader("Content-Type", "application/javascript");
+          res.end(content);
+        } else {
+          res.statusCode = 404;
+          res.end("Worker not found");
+        }
+      });
+    },
+    async generateBundle() {
+      if (isDev)
+        return;
+      await mkdir(outDir, { recursive: true });
+      const allEntries = [...workers];
+      if (backendEntry)
+        allEntries.push(backendEntry);
+      for (const entry of allEntries) {
+        const ok = await bundleWorker(entry, outDir, aliases);
+        if (ok) {
+          console.log(`[zapp] bundled worker: ${entry.outputName}`);
+        }
+      }
+    }
+  };
+}
+var src_default = zappWorkers;
+export {
+  zappWorkers,
+  src_default as default
+};

package/package.json

@@ -1,15 +1,20 @@
 {
   "name": "@zappdev/vite",
-  "version": "0.5.0-alpha.0",
+  "version": "0.5.0-alpha.2",
   "type": "module",
-  "main": "src/index.ts",
+  "main": "dist/index.js",
   "types": "src/index.ts",
   "exports": {
-    ".": "./src/index.ts"
+    ".": "./dist/index.js"
   },
   "files": [
+    "dist/",
     "src/"
   ],
+  "scripts": {
+    "build": "bun build src/index.ts --outdir dist --format esm --target node",
+    "prepack": "bun run build"
+  },
   "peerDependencies": {
     "vite": ">=5.0.0"
   }

package/src/index.ts

@@ -104,7 +104,12 @@ async function bundleWorker(entry: WorkerEntry, outDir: string, aliases: Record<
   }
 }
 
-export function zappWorkers(): Plugin {
+interface ZappWorkersOptions {
+  /** Path to backend worker source, relative to project root. Overrides zapp.config.ts. */
+  backend?: string;
+}
+
+export function zappWorkers(options?: ZappWorkersOptions): Plugin {
   let root = "";
   let srcDir = "";
   let workers: WorkerEntry[] = [];
@@ -112,12 +117,13 @@ export function zappWorkers(): Plugin {
   let aliases: Record<string, string> = {};
   let isDev = false;
   let outDir = "";
+  let backendFromConfig = options?.backend;
 
   return {
     name: "zapp-workers",
     enforce: "pre",
 
-    configResolved(config) {
+    async configResolved(config) {
       root = config.root;
       srcDir = path.join(root, "src");
       outDir = path.join(root, "dist", "_workers");
@@ -128,18 +134,34 @@ export function zappWorkers(): Plugin {
       if (resolvedAlias && typeof resolvedAlias === "object" && !Array.isArray(resolvedAlias)) {
         aliases = resolvedAlias as Record<string, string>;
       }
+
+      // Auto-read backend path from zapp.config.ts if not passed as option
+      if (!backendFromConfig) {
+        try {
+          const configPath = path.join(root, "zapp.config.ts");
+          const mod = await import(configPath);
+          const zappConfig = typeof mod.default === "function" ? mod.default() : mod.default;
+          if (zappConfig?.backend) {
+            backendFromConfig = zappConfig.backend;
+          }
+        } catch {
+          // No zapp.config.ts or no backend field — that's fine
+        }
+      }
     },
 
     async buildStart() {
       // Discover workers from source
       workers = await discoverWorkers(srcDir);
 
-      // Check for backend worker (convention: src/backend.ts)
-      const backendPath = path.join(srcDir, "backend.ts");
-      if (existsSync(backendPath)) {
+      // Backend worker — path from config, or fall back to src/backend.ts convention
+      const backendSrc = backendFromConfig
+        ? path.resolve(root, backendFromConfig)
+        : path.join(srcDir, "backend.ts");
+      if (existsSync(backendSrc)) {
         backendEntry = {
-          specifier: "./backend.ts",
-          sourcePath: backendPath,
+          specifier: path.relative(srcDir, backendSrc),
+          sourcePath: backendSrc,
           outputName: "backend.mjs",
           outputUrl: "/_workers/backend.mjs",
         };
@@ -149,7 +171,7 @@ export function zappWorkers(): Plugin {
         console.log(`[zapp] discovered ${workers.length} worker(s)`);
       }
       if (backendEntry) {
-        console.log("[zapp] backend worker: src/backend.ts");
+        console.log(`[zapp] backend worker: ${path.relative(root, backendSrc)}`);
       }
     },
 
@@ -187,11 +209,13 @@ export function zappWorkers(): Plugin {
       await mkdir(devOutDir, { recursive: true });
 
       workers = await discoverWorkers(srcDir);
-      const backendPath = path.join(srcDir, "backend.ts");
-      if (existsSync(backendPath)) {
+      const backendSrc = backendFromConfig
+        ? path.resolve(root, backendFromConfig)
+        : path.join(srcDir, "backend.ts");
+      if (existsSync(backendSrc)) {
         backendEntry = {
-          specifier: "./backend.ts",
-          sourcePath: backendPath,
+          specifier: path.relative(srcDir, backendSrc),
+          sourcePath: backendSrc,
           outputName: "backend.mjs",
           outputUrl: "/_workers/backend.mjs",
         };