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

package/dist/index.js

@@ -0,0 +1,189 @@
+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() {
+  let root = "";
+  let srcDir = "";
+  let workers = [];
+  let backendEntry = null;
+  let aliases = {};
+  let isDev = false;
+  let outDir = "";
+  return {
+    name: "zapp-workers",
+    enforce: "pre",
+    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;
+      }
+    },
+    async buildStart() {
+      workers = await discoverWorkers(srcDir);
+      const backendPath = path.join(srcDir, "backend.ts");
+      if (existsSync(backendPath)) {
+        backendEntry = {
+          specifier: "./backend.ts",
+          sourcePath: backendPath,
+          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: src/backend.ts");
+      }
+    },
+    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 backendPath = path.join(srcDir, "backend.ts");
+      if (existsSync(backendPath)) {
+        backendEntry = {
+          specifier: "./backend.ts",
+          sourcePath: backendPath,
+          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.1",
   "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"
   }