@zappdev/vite 0.1.0 → 0.5.0-alpha.0

package/package.json

@@ -1,23 +1,16 @@
 {
   "name": "@zappdev/vite",
-  "version": "0.1.0",
+  "version": "0.5.0-alpha.0",
   "type": "module",
-  "description": "Vite plugin for Zapp desktop apps",
-  "main": "dist/index.js",
-  "types": "dist/index.d.ts",
+  "main": "src/index.ts",
+  "types": "src/index.ts",
+  "exports": {
+    ".": "./src/index.ts"
+  },
   "files": [
-    "dist/"
+    "src/"
   ],
-  "scripts": {
-    "build": "tsc"
-  },
-  "dependencies": {
-    "esbuild": "^0.25.10"
-  },
-  "devDependencies": {
-    "@types/node": "^22.0.0",
-    "typescript": "^5.0.0",
-    "vite": "^6.0.0"
-  },
-  "license": "MIT"
+  "peerDependencies": {
+    "vite": ">=5.0.0"
+  }
 }

package/src/index.ts

@@ -0,0 +1,246 @@
+/**
+ * Zapp Vite Plugin — bundles workers and backend scripts.
+ *
+ * Discovers `new Worker("./path")` and `new SharedWorker("./path")` patterns,
+ * bundles each as a separate entry, outputs to dist/_workers/.
+ * Also handles the backend worker convention (src/backend.ts).
+ *
+ * @example
+ * ```ts
+ * import { zappWorkers } from "@zappdev/vite";
+ * export default defineConfig({ plugins: [zappWorkers()] });
+ * ```
+ */
+
+import type { Plugin, ViteDevServer } from "vite";
+import path from "node:path";
+import { existsSync } from "node:fs";
+import { mkdir, readdir, stat, readFile } from "node:fs/promises";
+
+const WORKER_PATTERN =
+  /new\s+(?:SharedWorker|Worker)\s*\(\s*(?:new\s+URL\(\s*["'`](.+?)["'`]\s*,\s*import\.meta\.url\s*\)|["'`](.+?)["'`])/g;
+
+interface WorkerEntry {
+  /** Original specifier from source: "./worker.ts" */
+  specifier: string;
+  /** Absolute path to source file */
+  sourcePath: string;
+  /** Output name: "worker.mjs" */
+  outputName: string;
+  /** Output URL path: "/_workers/worker.mjs" */
+  outputUrl: string;
+}
+
+/** Recursively scan for source files. */
+async function scanDir(dir: string): Promise<string[]> {
+  const results: string[] = [];
+  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;
+}
+
+/** Discover worker entries by scanning source files for new Worker() patterns. */
+async function discoverWorkers(srcDir: string): Promise<WorkerEntry[]> {
+  const files = await scanDir(srcDir);
+  const found = new Map<string, WorkerEntry>();
+
+  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()];
+}
+
+/** Bundle a single worker entry using Vite's build API (Rolldown in Vite 8). */
+async function bundleWorker(entry: WorkerEntry, outDir: string, aliases: Record<string, string>): Promise<boolean> {
+  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;
+  }
+}
+
+export function zappWorkers(): Plugin {
+  let root = "";
+  let srcDir = "";
+  let workers: WorkerEntry[] = [];
+  let backendEntry: WorkerEntry | null = null;
+  let aliases: Record<string, string> = {};
+  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";
+
+      // Extract alias paths for worker bundling
+      const resolvedAlias = config.resolve?.alias;
+      if (resolvedAlias && typeof resolvedAlias === "object" && !Array.isArray(resolvedAlias)) {
+        aliases = resolvedAlias as Record<string, string>;
+      }
+    },
+
+    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)) {
+        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");
+      }
+    },
+
+    // Rewrite new Worker("./worker.ts") → new Worker("/_workers/worker.mjs")
+    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) {
+        // Replace the specifier in new Worker("./worker.ts") with the output URL
+        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;
+    },
+
+    // Dev: bundle workers eagerly so they exist on disk before the native
+    // binary launches. The backend worker is loaded directly by native code
+    // and never goes through HTTP, so a lazy-on-request middleware would never
+    // bundle it. Eager bundling also lets native fall back to filesystem.
+    //
+    // configureServer runs before buildStart, so we re-discover workers here
+    // (buildStart's results aren't yet available).
+    async configureServer(server: ViteDevServer) {
+      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}`);
+      }
+
+      // Still expose middleware so WebView fetch of /_workers/<name>.mjs works
+      // (e.g. native engines that pull via dev URL like jsc.m).
+      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");
+        }
+      });
+    },
+
+    // Prod: bundle all workers to dist/_workers/
+    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}`);
+        }
+      }
+    },
+  };
+}
+
+export default zappWorkers;

package/README.md

@@ -1,43 +0,0 @@
-# @zapp/vite
-
-Vite plugin for Zapp desktop apps. Handles worker discovery, source bundling, and output configuration so your Vite-based frontend integrates seamlessly with the Zapp native runtime.
-
-## Install
-
-```sh
-bun add -D @zapp/vite
-```
-
-```sh
-npm install -D @zapp/vite
-```
-
-## Usage
-
-```ts
-// vite.config.ts
-import { defineConfig } from "vite";
-import zapp from "@zapp/vite";
-
-export default defineConfig({
-  plugins: [
-    zapp({
-      outDir: "dist",
-      sourceRoot: "src",
-      minify: true,
-    }),
-  ],
-});
-```
-
-## Options
-
-| Option       | Type      | Description                        |
-| ------------ | --------- | ---------------------------------- |
-| `outDir`     | `string`  | Output directory for bundled files |
-| `sourceRoot` | `string`  | Root directory of source files     |
-| `minify`     | `boolean` | Enable minification                |
-
-## License
-
-MIT

package/dist/index.d.ts

@@ -1,8 +0,0 @@
-import type { Plugin } from "vite";
-export interface ZappOptions {
-    outDir?: string;
-    sourceRoot?: string;
-    minify?: boolean;
-}
-export declare const zapp: (options?: ZappOptions) => Plugin;
-export default zapp;

package/dist/index.js

@@ -1,237 +0,0 @@
-import fs from "node:fs/promises";
-import path from "node:path";
-const WORKER_PATTERN = /new\s+(?:SharedWorker|Worker)\s*\(\s*(?:new\s+URL\(\s*["'`](.+?)["'`]\s*,\s*import\.meta\.url\s*\)|["'`](.+?)["'`])/g;
-const scanSourceFiles = async (rootDir, dir = rootDir, out = []) => {
-    const entries = await fs.readdir(dir, { withFileTypes: true });
-    for (const entry of entries) {
-        if (entry.name.startsWith("."))
-            continue;
-        const full = path.join(dir, entry.name);
-        if (entry.isDirectory()) {
-            if (entry.name === "node_modules")
-                continue;
-            await scanSourceFiles(rootDir, full, out);
-            continue;
-        }
-        if (!/\.(ts|tsx|js|jsx|mjs|cjs)$/.test(entry.name))
-            continue;
-        out.push(full);
-    }
-    return out;
-};
-const discoverWorkerEntries = async (srcRoot) => {
-    const sourceFiles = await scanSourceFiles(srcRoot);
-    const found = new Map();
-    for (const file of sourceFiles) {
-        const content = await fs.readFile(file, "utf8");
-        let match;
-        while ((match = WORKER_PATTERN.exec(content)) != null) {
-            const spec = match[1] ?? match[2];
-            if (!spec || !/\.(ts|tsx|js|jsx|mjs)$/.test(spec))
-                continue;
-            const entryPath = path.resolve(path.dirname(file), spec);
-            found.set(entryPath, spec);
-        }
-    }
-    return [...found.entries()].map(([entryPath, sourceSpec]) => ({ entryPath, sourceSpec }));
-};
-const normalizeOutName = (entryPath, used) => {
-    const stem = path.basename(entryPath).replace(/\.[^.]+$/, "");
-    let candidate = `${stem}.mjs`;
-    let suffix = 1;
-    while (used.has(candidate)) {
-        candidate = `${stem}-${suffix}.mjs`;
-        suffix += 1;
-    }
-    used.add(candidate);
-    return candidate;
-};
-const writeIfChanged = async (filePath, content) => {
-    try {
-        const existing = await fs.readFile(filePath, "utf8");
-        if (existing === content)
-            return false;
-    }
-    catch { }
-    await fs.writeFile(filePath, content);
-    return true;
-};
-export const zapp = (options = {}) => {
-    const configuredOutDir = options.outDir ?? ".zapp/workers";
-    const sourceRoot = options.sourceRoot ?? "src";
-    const minify = options.minify ?? false;
-    let root = process.cwd();
-    let devServer = false;
-    let viteAliases = {};
-    let timer = null;
-    let building = false;
-    const hasBunBuild = typeof globalThis.Bun !== "undefined" &&
-        globalThis.Bun != null &&
-        typeof globalThis.Bun.build === "function";
-    const getOutDir = () => path.resolve(root, configuredOutDir);
-    const bundleWorker = async (entryPath, outFile) => {
-        const tmpFile = outFile + ".tmp";
-        if (hasBunBuild) {
-            const result = await globalThis.Bun.build({
-                entrypoints: [entryPath],
-                outdir: path.dirname(tmpFile),
-                naming: path.basename(tmpFile),
-                target: "browser",
-                format: "esm",
-                sourcemap: devServer ? "inline" : "none",
-                minify: devServer ? false : minify,
-                plugins: [{
-                        name: "zapp-alias",
-                        setup(build) {
-                            for (const [find, replacement] of Object.entries(viteAliases)) {
-                                build.onResolve({ filter: new RegExp(`^${find}$`) }, () => ({ path: replacement }));
-                                build.onResolve({ filter: new RegExp(`^${find}/(.*)`) }, (args) => ({
-                                    path: path.join(replacement, args.path.slice(find.length + 1))
-                                }));
-                            }
-                        }
-                    }],
-            });
-            if (!result.success) {
-                const lines = (result.logs ?? [])
-                    .map((log) => log?.message)
-                    .filter(Boolean)
-                    .join("\n");
-                throw new Error(lines || `bun build failed for ${entryPath}`);
-            }
-        }
-        else {
-            const { build: esbuild } = await import("esbuild");
-            await esbuild({
-                entryPoints: [entryPath],
-                bundle: true,
-                format: "esm",
-                platform: "browser",
-                target: "es2022",
-                sourcemap: devServer ? "inline" : false,
-                minify: devServer ? false : minify,
-                outfile: tmpFile,
-                alias: viteAliases,
-            });
-        }
-        try {
-            const built = await fs.readFile(tmpFile, "utf8");
-            await writeIfChanged(outFile, built);
-        }
-        finally {
-            await fs.unlink(tmpFile).catch(() => { });
-        }
-    };
-    const buildWorkers = async () => {
-        if (building)
-            return;
-        building = true;
-        try {
-            const srcRoot = path.resolve(root, sourceRoot);
-            const outDir = getOutDir();
-            await fs.mkdir(outDir, { recursive: true });
-            const entries = await discoverWorkerEntries(srcRoot);
-            const usedNames = new Set();
-            const manifest = {};
-            for (const { entryPath, sourceSpec } of entries) {
-                const outName = normalizeOutName(entryPath, usedNames);
-                const outFile = path.join(outDir, outName);
-                await bundleWorker(entryPath, outFile);
-                manifest[sourceSpec] = `/zapp-workers/${outName}`;
-                manifest[path.basename(sourceSpec)] = `/zapp-workers/${outName}`;
-            }
-            const manifestContent = JSON.stringify({ v: 1, workers: manifest }, null, 2);
-            await writeIfChanged(path.join(outDir, "manifest.json"), manifestContent);
-            return manifest;
-        }
-        finally {
-            building = false;
-        }
-    };
-    return {
-        name: "zapp-workers",
-        configResolved(config) {
-            root = config.root;
-            devServer = config.command === "serve";
-            if (Array.isArray(config.resolve?.alias)) {
-                for (const a of config.resolve.alias) {
-                    if (typeof a.find === "string" && typeof a.replacement === "string") {
-                        viteAliases[a.find] = a.replacement;
-                    }
-                }
-            }
-            else if (config.resolve?.alias) {
-                Object.assign(viteAliases, config.resolve.alias);
-            }
-        },
-        async buildStart() {
-            await buildWorkers();
-        },
-        async transformIndexHtml(html) {
-            const outDir = getOutDir();
-            const manifestPath = path.join(outDir, "manifest.json");
-            let workers = {};
-            try {
-                const raw = await fs.readFile(manifestPath, "utf8");
-                workers = JSON.parse(raw).workers ?? {};
-            }
-            catch {
-                workers = {};
-            }
-            const serialized = JSON.stringify(workers).replace(/</g, "\\u003c");
-            const script = `<script>(function(){globalThis[Symbol.for('zapp.workerManifest')]=${serialized};})();</script>`;
-            return html.includes("</head>") ? html.replace("</head>", `${script}</head>`) : `${script}${html}`;
-        },
-        configureServer(server) {
-            devServer = true;
-            const outDir = getOutDir();
-            const srcRoot = path.resolve(root, sourceRoot);
-            const srcRootNorm = srcRoot.replace(/\\/g, "/");
-            server.middlewares.use((req, res, next) => {
-                const url = req.url ?? "";
-                if (!url.startsWith("/zapp-workers/"))
-                    return next();
-                const fileName = url.slice("/zapp-workers/".length).split("?")[0];
-                if (!fileName)
-                    return next();
-                const filePath = path.join(outDir, fileName);
-                fs.readFile(filePath, "utf8").then((content) => {
-                    res.setHeader("Content-Type", "application/javascript; charset=utf-8");
-                    res.setHeader("Cache-Control", "no-cache");
-                    res.end(content);
-                }).catch(() => next());
-            });
-            const rebuild = (filePath) => {
-                const norm = path.resolve(filePath).replace(/\\/g, "/");
-                if (!norm.startsWith(srcRootNorm + "/"))
-                    return;
-                if (timer)
-                    clearTimeout(timer);
-                timer = setTimeout(() => {
-                    buildWorkers().catch((error) => {
-                        server.config.logger.error(`[zapp-workers] ${error.message}`);
-                    });
-                }, 200);
-            };
-            server.watcher.on("add", rebuild);
-            server.watcher.on("change", rebuild);
-            server.watcher.on("unlink", rebuild);
-        },
-        async writeBundle(outputOptions) {
-            if (devServer)
-                return;
-            const workerDir = getOutDir();
-            const distDir = outputOptions.dir ?? path.join(root, "dist");
-            const workerDistDir = path.join(distDir, "zapp-workers");
-            await fs.mkdir(workerDistDir, { recursive: true });
-            try {
-                const files = await fs.readdir(workerDir);
-                for (const file of files) {
-                    await fs.copyFile(path.join(workerDir, file), path.join(workerDistDir, file));
-                }
-            }
-            catch { }
-        },
-    };
-};
-export default zapp;