robuild 0.0.5 → 0.0.6

package/README.md

@@ -30,9 +30,12 @@ npx robuild ./src/index.ts
 
 # transform
 npx robuild ./src/runtime/:./dist/runtime
+
+# watch mode - rebuild on file changes
+npx robuild ./src/index.ts --watch
 ```
 
-You can use `--dir` to set the working directory.
+You can use `--dir` to set the working directory and `--watch` to enable watch mode.
 
 If paths end with `/`, robuild uses transpile mode using [oxc-transform](https://www.npmjs.com/package/oxc-transform) instead of bundle mode with [rolldown](https://rolldown.rs/).
 
@@ -85,6 +88,52 @@ export default defineConfig({
 })
 ```
 
+## Watch Mode
+
+For development, robuild provides a watch mode that automatically rebuilds your project when files change.
+
+### CLI Usage
+
+```sh
+# Enable watch mode for any build
+npx robuild ./src/index.ts --watch
+
+# Watch mode with transform
+npx robuild ./src/runtime/:./dist/runtime --watch
+
+# Watch mode with custom working directory
+npx robuild ./src/index.ts --watch --dir ./my-project
+```
+
+### Configuration
+
+You can configure watch behavior in your `build.config.ts`:
+
+```js
+import { defineConfig } from 'robuild'
+
+export default defineConfig({
+  entries: ['./src/index.ts'],
+  watch: {
+    enabled: true, // Enable watch mode by default
+    include: ['src/**/*'], // Files to watch
+    exclude: ['**/*.test.ts'], // Files to ignore
+    delay: 100, // Rebuild delay in ms
+    ignoreInitial: false, // Skip initial build
+    watchNewFiles: true, // Watch for new files
+  },
+})
+```
+
+### Features
+
+- **Real-time rebuilding**: Automatically rebuilds when source files change
+- **Smart file detection**: Automatically determines what files to watch based on your entries
+- **Debounced rebuilds**: Configurable delay to prevent excessive rebuilds
+- **Error recovery**: Continues watching even after build errors
+- **Clear feedback**: Shows file changes and rebuild status
+- **Graceful shutdown**: Clean exit with Ctrl+C
+
 ## Stub Mode
 
 When working on a package locally, it can be tedious to rebuild or run the watch command every time.

package/dist/_chunks/{build-eIjZ3Fk8.mjs → build-DuPhfTzX.mjs}

@@ -16,6 +16,7 @@ import { minify } from "oxc-minify";
 import MagicString from "magic-string";
 import { transform } from "oxc-transform";
 import { glob } from "tinyglobby";
+import { watch } from "chokidar";
 
 //#region src/utils.ts
 function fmtPath(path) {
@@ -325,20 +326,194 @@ async function transformModule(entryPath, entry) {
 	return transformed;
 }
 
+//#endregion
+//#region src/watch.ts
+/**
+* Start watching files and rebuild on changes
+*/
+async function startWatch(config, ctx, buildFn) {
+	const watchOptions = config.watch || {};
+	if (!watchOptions.enabled) throw new Error("Watch mode is not enabled");
+	const watchCtx = {
+		config,
+		ctx,
+		buildFn,
+		isBuilding: false,
+		pendingRebuild: false
+	};
+	const watchPatterns = await getWatchPatterns(config, ctx, watchOptions);
+	const ignorePatterns = getIgnorePatterns(watchOptions);
+	consola.info(`👀 Starting watch mode...`);
+	consola.info(`📁 Watching: ${colors.dim(watchPatterns.join(", "))}`);
+	if (ignorePatterns.length > 0) consola.info(`🚫 Ignoring: ${colors.dim(ignorePatterns.join(", "))}`);
+	const delay = watchOptions.delay ?? 100;
+	if (delay > 0) consola.info(`⏱️  Rebuild delay: ${colors.dim(`${delay}ms`)}`);
+	const watcher = watch(watchPatterns, {
+		ignored: ignorePatterns,
+		ignoreInitial: watchOptions.ignoreInitial ?? false,
+		persistent: true,
+		followSymlinks: false,
+		cwd: ctx.pkgDir
+	});
+	watcher.on("change", (path) => handleFileChange(watchCtx, path, "changed"));
+	watcher.on("add", (path) => {
+		if (watchOptions.watchNewFiles !== false) handleFileChange(watchCtx, path, "added");
+	});
+	watcher.on("unlink", (path) => handleFileChange(watchCtx, path, "removed"));
+	watcher.on("error", (error) => {
+		consola.error("❌ Watch error:", error);
+	});
+	if (process.env.DEBUG) {
+		watcher.on("addDir", (path) => consola.debug(`📁 Directory added: ${path}`));
+		watcher.on("unlinkDir", (path) => consola.debug(`📁 Directory removed: ${path}`));
+	}
+	await new Promise((resolve$1) => {
+		watcher.on("ready", () => {
+			const watchedPaths = watcher.getWatched();
+			const totalFiles = Object.values(watchedPaths).reduce((sum, files) => sum + files.length, 0);
+			consola.success(`🚀 Watch mode ready - watching ${totalFiles} files`);
+			consola.info(`💡 Press ${colors.cyan("Ctrl+C")} to stop watching`);
+			resolve$1();
+		});
+	});
+	return () => {
+		if (watchCtx.rebuildTimer) clearTimeout(watchCtx.rebuildTimer);
+		return watcher.close();
+	};
+}
+/**
+* Handle file change events
+*/
+function handleFileChange(watchCtx, filePath, changeType) {
+	const { config, ctx } = watchCtx;
+	const watchOptions = config.watch || {};
+	const delay = watchOptions.delay ?? 100;
+	const relativePath = relative(ctx.pkgDir, join(ctx.pkgDir, filePath));
+	const formattedPath = fmtPath(relativePath);
+	const changeIcon = changeType === "changed" ? "📝" : changeType === "added" ? "➕" : "➖";
+	consola.info(`${changeIcon} ${colors.cyan(formattedPath)} ${changeType}`);
+	if (watchCtx.rebuildTimer) clearTimeout(watchCtx.rebuildTimer);
+	watchCtx.pendingRebuild = true;
+	watchCtx.rebuildTimer = setTimeout(() => {
+		triggerRebuild(watchCtx);
+	}, delay);
+}
+/**
+* Trigger a rebuild
+*/
+async function triggerRebuild(watchCtx) {
+	const { config, buildFn } = watchCtx;
+	if (watchCtx.isBuilding) return;
+	if (!watchCtx.pendingRebuild) return;
+	watchCtx.isBuilding = true;
+	watchCtx.pendingRebuild = false;
+	try {
+		consola.info(`🔄 Rebuilding...`);
+		const start = Date.now();
+		const buildConfig = {
+			...config,
+			watch: {
+				...config.watch,
+				enabled: false
+			}
+		};
+		await buildFn(buildConfig);
+		const duration = Date.now() - start;
+		consola.success(`✅ Rebuild completed in ${duration}ms`);
+	} catch (error) {
+		consola.error("❌ Rebuild failed:");
+		if (error instanceof Error) {
+			consola.error(`   ${error.message}`);
+			if (process.env.DEBUG && error.stack) consola.debug(error.stack);
+		} else consola.error(`   ${String(error)}`);
+		consola.info("👀 Still watching for changes...");
+	} finally {
+		watchCtx.isBuilding = false;
+		if (watchCtx.pendingRebuild) setTimeout(() => triggerRebuild(watchCtx), watchCtx.config.watch?.delay ?? 100);
+	}
+}
+/**
+* Get patterns for files to watch
+*/
+async function getWatchPatterns(config, ctx, watchOptions) {
+	if (watchOptions.include && watchOptions.include.length > 0) return watchOptions.include;
+	const patterns = [];
+	for (const entry of config.entries || []) if (typeof entry === "string") {
+		const [input] = entry.split(":");
+		if (input.endsWith("/")) patterns.push(`${input}**/*`);
+		else {
+			const inputs = input.split(",");
+			for (const inputFile of inputs) {
+				patterns.push(inputFile);
+				const dir = inputFile.substring(0, inputFile.lastIndexOf("/"));
+				if (dir) patterns.push(`${dir}/**/*`);
+			}
+		}
+	} else if (entry.type === "transform") patterns.push(`${entry.input}/**/*`);
+	else {
+		const inputs = Array.isArray(entry.input) ? entry.input : [entry.input];
+		for (const inputFile of inputs) {
+			patterns.push(inputFile);
+			const dir = inputFile.substring(0, inputFile.lastIndexOf("/"));
+			if (dir) patterns.push(`${dir}/**/*`);
+		}
+	}
+	if (patterns.length === 0) patterns.push("src/**/*", "*.ts", "*.js", "*.mjs", "*.json");
+	return [...new Set(patterns)];
+}
+/**
+* Get patterns for files to ignore
+*/
+function getIgnorePatterns(watchOptions) {
+	const defaultIgnores = [
+		"**/node_modules/**",
+		"**/dist/**",
+		"**/build/**",
+		"**/coverage/**",
+		"**/.git/**",
+		"**/.DS_Store",
+		"**/Thumbs.db",
+		"**/*.log",
+		"**/tmp/**",
+		"**/temp/**"
+	];
+	if (watchOptions.exclude && watchOptions.exclude.length > 0) return [...defaultIgnores, ...watchOptions.exclude];
+	return defaultIgnores;
+}
+
 //#endregion
 //#region src/build.ts
 /**
 * Build dist/ from src/
 */
 async function build(config) {
-	const start = Date.now();
 	const pkgDir = normalizePath(config.cwd);
 	const pkg = await readJSON(join(pkgDir, "package.json")).catch(() => ({}));
 	const ctx = {
 		pkg,
 		pkgDir
 	};
+	if (config.watch?.enabled) {
+		consola.log(`👀 Starting watch mode for \`${ctx.pkg.name || "<no name>"}\` (\`${ctx.pkgDir}\`)`);
+		await performBuild(config, ctx);
+		const stopWatch = await startWatch(config, ctx, build);
+		const cleanup = () => {
+			consola.info("🛑 Stopping watch mode...");
+			stopWatch();
+			process.exit(0);
+		};
+		process.on("SIGINT", cleanup);
+		process.on("SIGTERM", cleanup);
+		return new Promise(() => {});
+	}
 	consola.log(`📦 Building \`${ctx.pkg.name || "<no name>"}\` (\`${ctx.pkgDir}\`)`);
+	await performBuild(config, ctx);
+}
+/**
+* Perform the actual build process
+*/
+async function performBuild(config, ctx) {
+	const start = Date.now();
 	const hooks = config.hooks || {};
 	await hooks.start?.(ctx);
 	const entries = (config.entries || []).map((rawEntry) => {
@@ -357,8 +532,8 @@ async function build(config) {
 		} else entry = rawEntry;
 		if (!entry.input) throw new Error(`Build entry missing \`input\`: ${JSON.stringify(entry, null, 2)}`);
 		entry = { ...entry };
-		entry.outDir = normalizePath(entry.outDir || "dist", pkgDir);
-		entry.input = Array.isArray(entry.input) ? entry.input.map((p) => normalizePath(p, pkgDir)) : normalizePath(entry.input, pkgDir);
+		entry.outDir = normalizePath(entry.outDir || "dist", ctx.pkgDir);
+		entry.input = Array.isArray(entry.input) ? entry.input.map((p) => normalizePath(p, ctx.pkgDir)) : normalizePath(entry.input, ctx.pkgDir);
 		return entry;
 	});
 	await hooks.entries?.(entries, ctx);

package/dist/_chunks/{config-DxLkhDt6.d.mts → config-BZW4dLYD.d.mts}

@@ -87,10 +87,49 @@ interface BuildHooks {
   rolldownConfig?: (cfg: InputOptions, ctx: BuildContext) => void | Promise<void>;
   rolldownOutput?: (cfg: OutputOptions, res: RolldownBuild, ctx: BuildContext) => void | Promise<void>;
 }
+interface WatchOptions {
+  /**
+  * Enable watch mode.
+  *
+  * Defaults to `false` if not provided.
+  */
+  enabled?: boolean;
+  /**
+  * Glob patterns for files to watch.
+  *
+  * Defaults to watching all source files if not provided.
+  */
+  include?: string[];
+  /**
+  * Glob patterns for files to ignore.
+  *
+  * Defaults to common ignore patterns if not provided.
+  */
+  exclude?: string[];
+  /**
+  * Delay in milliseconds before rebuilding after a file change.
+  *
+  * Defaults to `100` if not provided.
+  */
+  delay?: number;
+  /**
+  * Whether to ignore the initial build when starting watch mode.
+  *
+  * Defaults to `false` if not provided.
+  */
+  ignoreInitial?: boolean;
+  /**
+  * Whether to watch for new files being added.
+  *
+  * Defaults to `true` if not provided.
+  */
+  watchNewFiles?: boolean;
+}
 interface BuildConfig {
   cwd?: string | URL;
   entries?: (BuildEntry | string)[];
   hooks?: BuildHooks;
+  watch?: WatchOptions;
 }
 //#endregion
 //#region src/config.d.ts

package/dist/cli.mjs

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-import { build } from "./_chunks/build-eIjZ3Fk8.mjs";
+import { build } from "./_chunks/build-DuPhfTzX.mjs";
 import { consola } from "consola";
 import { parseArgs } from "node:util";
 import { loadConfig } from "c12";
@@ -16,6 +16,11 @@ const args = parseArgs({
 		stub: {
 			type: "boolean",
 			default: false
+		},
+		watch: {
+			type: "boolean",
+			default: false,
+			short: "w"
 		}
 	}
 });
@@ -48,7 +53,11 @@ if (rawEntries.length === 0) {
 await build({
 	cwd: args.values.dir,
 	...config,
-	entries
+	entries,
+	watch: args.values.watch ? {
+		enabled: true,
+		...config.watch
+	} : config.watch
 });
 
 //#endregion

package/dist/config.d.mts

@@ -1,2 +1,2 @@
-import { defineConfig } from "./_chunks/config-DxLkhDt6.mjs";
+import { defineConfig } from "./_chunks/config-BZW4dLYD.mjs";
 export { defineConfig };

package/dist/index.d.mts

@@ -1,4 +1,4 @@
-import { BuildConfig, BuildEntry, BundleEntry, TransformEntry, defineConfig } from "./_chunks/config-DxLkhDt6.mjs";
+import { BuildConfig, BuildEntry, BundleEntry, TransformEntry, defineConfig } from "./_chunks/config-BZW4dLYD.mjs";
 
 //#region src/build.d.ts
 

package/dist/index.mjs

@@ -1,4 +1,4 @@
-import { build } from "./_chunks/build-eIjZ3Fk8.mjs";
+import { build } from "./_chunks/build-DuPhfTzX.mjs";
 import { defineConfig } from "./_chunks/config-B_2eqpNJ.mjs";
 
 export { build, defineConfig };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "robuild",
   "type": "module",
-  "version": "0.0.5",
+  "version": "0.0.6",
   "packageManager": "pnpm@10.11.1",
   "description": "Zero-config ESM/TS package builder. Powered by Rolldown and Oxc",
   "license": "MIT",
@@ -32,6 +32,7 @@
   },
   "dependencies": {
     "c12": "^3.0.4",
+    "chokidar": "^4.0.3",
     "consola": "^3.4.2",
     "defu": "^6.1.4",
     "exsolve": "^1.0.5",