@rolldown/browser 1.0.0-beta.9-commit.0ec9e7d → 1.0.0-rc.2

package/dist/shared/utils-CqMTwlsR.d.mts

@@ -0,0 +1,22 @@
+import { BindingBuiltinPluginName } from "../binding.cjs";
+
+//#region src/types/utils.d.ts
+type MaybePromise<T> = T | Promise<T>;
+/** @inline */
+type NullValue<T = void> = T | undefined | null | void;
+type PartialNull<T> = { [P in keyof T]: T[P] | null };
+type MakeAsync<Function_> = Function_ extends ((this: infer This, ...parameters: infer Arguments) => infer Return) ? (this: This, ...parameters: Arguments) => Return | Promise<Return> : never;
+type MaybeArray<T> = T | T[];
+/** @inline */
+type StringOrRegExp = string | RegExp;
+//#endregion
+//#region src/builtin-plugin/utils.d.ts
+declare class BuiltinPlugin {
+  name: BindingBuiltinPluginName;
+  _options?: unknown;
+  /** Vite-specific option to control plugin ordering */
+  enforce?: "pre" | "post";
+  constructor(name: BindingBuiltinPluginName, _options?: unknown);
+}
+//#endregion
+export { NullValue as a, MaybePromise as i, MakeAsync as n, PartialNull as o, MaybeArray as r, StringOrRegExp as s, BuiltinPlugin as t };

package/dist/shared/watch-BsneBCNP.mjs

@@ -0,0 +1,378 @@
+import { o as logMultiplyNotifyOption } from "./logs-B2CASPcx.mjs";
+import { a as aggregateBindingErrorsIntoJsError, b as LOG_LEVEL_WARN } from "./bindingify-input-options-CObJx_Uj.mjs";
+import { h as arraify } from "./composable-filters-CIxSuZSM.mjs";
+import { l as PluginDriver, n as createBundlerOptions } from "./rolldown-build-Do6WlRGM.mjs";
+import { BindingWatcher, shutdownAsyncRuntime } from "../rolldown-binding.wasi.cjs";
+
+//#region ../../node_modules/.pnpm/signal-exit@4.1.0/node_modules/signal-exit/dist/mjs/signals.js
+/**
+* This is not the set of all possible signals.
+*
+* It IS, however, the set of all signals that trigger
+* an exit on either Linux or BSD systems.  Linux is a
+* superset of the signal names supported on BSD, and
+* the unknown signals just fail to register, so we can
+* catch that easily enough.
+*
+* Windows signals are a different set, since there are
+* signals that terminate Windows processes, but don't
+* terminate (or don't even exist) on Posix systems.
+*
+* Don't bother with SIGKILL.  It's uncatchable, which
+* means that we can't fire any callbacks anyway.
+*
+* If a user does happen to register a handler on a non-
+* fatal signal like SIGWINCH or something, and then
+* exit, it'll end up firing `process.emit('exit')`, so
+* the handler will be fired anyway.
+*
+* SIGBUS, SIGFPE, SIGSEGV and SIGILL, when not raised
+* artificially, inherently leave the process in a
+* state from which it is not safe to try and enter JS
+* listeners.
+*/
+const signals = [];
+signals.push("SIGHUP", "SIGINT", "SIGTERM");
+if (process.platform !== "win32") signals.push("SIGALRM", "SIGABRT", "SIGVTALRM", "SIGXCPU", "SIGXFSZ", "SIGUSR2", "SIGTRAP", "SIGSYS", "SIGQUIT", "SIGIOT");
+if (process.platform === "linux") signals.push("SIGIO", "SIGPOLL", "SIGPWR", "SIGSTKFLT");
+
+//#endregion
+//#region ../../node_modules/.pnpm/signal-exit@4.1.0/node_modules/signal-exit/dist/mjs/index.js
+const processOk = (process) => !!process && typeof process === "object" && typeof process.removeListener === "function" && typeof process.emit === "function" && typeof process.reallyExit === "function" && typeof process.listeners === "function" && typeof process.kill === "function" && typeof process.pid === "number" && typeof process.on === "function";
+const kExitEmitter = Symbol.for("signal-exit emitter");
+const global = globalThis;
+const ObjectDefineProperty = Object.defineProperty.bind(Object);
+var Emitter = class {
+	emitted = {
+		afterExit: false,
+		exit: false
+	};
+	listeners = {
+		afterExit: [],
+		exit: []
+	};
+	count = 0;
+	id = Math.random();
+	constructor() {
+		if (global[kExitEmitter]) return global[kExitEmitter];
+		ObjectDefineProperty(global, kExitEmitter, {
+			value: this,
+			writable: false,
+			enumerable: false,
+			configurable: false
+		});
+	}
+	on(ev, fn) {
+		this.listeners[ev].push(fn);
+	}
+	removeListener(ev, fn) {
+		const list = this.listeners[ev];
+		const i = list.indexOf(fn);
+		/* c8 ignore start */
+		if (i === -1) return;
+		/* c8 ignore stop */
+		if (i === 0 && list.length === 1) list.length = 0;
+		else list.splice(i, 1);
+	}
+	emit(ev, code, signal) {
+		if (this.emitted[ev]) return false;
+		this.emitted[ev] = true;
+		let ret = false;
+		for (const fn of this.listeners[ev]) ret = fn(code, signal) === true || ret;
+		if (ev === "exit") ret = this.emit("afterExit", code, signal) || ret;
+		return ret;
+	}
+};
+var SignalExitBase = class {};
+const signalExitWrap = (handler) => {
+	return {
+		onExit(cb, opts) {
+			return handler.onExit(cb, opts);
+		},
+		load() {
+			return handler.load();
+		},
+		unload() {
+			return handler.unload();
+		}
+	};
+};
+var SignalExitFallback = class extends SignalExitBase {
+	onExit() {
+		return () => {};
+	}
+	load() {}
+	unload() {}
+};
+var SignalExit = class extends SignalExitBase {
+	/* c8 ignore start */
+	#hupSig = process$1.platform === "win32" ? "SIGINT" : "SIGHUP";
+	/* c8 ignore stop */
+	#emitter = new Emitter();
+	#process;
+	#originalProcessEmit;
+	#originalProcessReallyExit;
+	#sigListeners = {};
+	#loaded = false;
+	constructor(process) {
+		super();
+		this.#process = process;
+		this.#sigListeners = {};
+		for (const sig of signals) this.#sigListeners[sig] = () => {
+			const listeners = this.#process.listeners(sig);
+			let { count } = this.#emitter;
+			/* c8 ignore start */
+			const p = process;
+			if (typeof p.__signal_exit_emitter__ === "object" && typeof p.__signal_exit_emitter__.count === "number") count += p.__signal_exit_emitter__.count;
+			/* c8 ignore stop */
+			if (listeners.length === count) {
+				this.unload();
+				const ret = this.#emitter.emit("exit", null, sig);
+				/* c8 ignore start */
+				const s = sig === "SIGHUP" ? this.#hupSig : sig;
+				if (!ret) process.kill(process.pid, s);
+			}
+		};
+		this.#originalProcessReallyExit = process.reallyExit;
+		this.#originalProcessEmit = process.emit;
+	}
+	onExit(cb, opts) {
+		/* c8 ignore start */
+		if (!processOk(this.#process)) return () => {};
+		/* c8 ignore stop */
+		if (this.#loaded === false) this.load();
+		const ev = opts?.alwaysLast ? "afterExit" : "exit";
+		this.#emitter.on(ev, cb);
+		return () => {
+			this.#emitter.removeListener(ev, cb);
+			if (this.#emitter.listeners["exit"].length === 0 && this.#emitter.listeners["afterExit"].length === 0) this.unload();
+		};
+	}
+	load() {
+		if (this.#loaded) return;
+		this.#loaded = true;
+		this.#emitter.count += 1;
+		for (const sig of signals) try {
+			const fn = this.#sigListeners[sig];
+			if (fn) this.#process.on(sig, fn);
+		} catch (_) {}
+		this.#process.emit = (ev, ...a) => {
+			return this.#processEmit(ev, ...a);
+		};
+		this.#process.reallyExit = (code) => {
+			return this.#processReallyExit(code);
+		};
+	}
+	unload() {
+		if (!this.#loaded) return;
+		this.#loaded = false;
+		signals.forEach((sig) => {
+			const listener = this.#sigListeners[sig];
+			/* c8 ignore start */
+			if (!listener) throw new Error("Listener not defined for signal: " + sig);
+			/* c8 ignore stop */
+			try {
+				this.#process.removeListener(sig, listener);
+			} catch (_) {}
+			/* c8 ignore stop */
+		});
+		this.#process.emit = this.#originalProcessEmit;
+		this.#process.reallyExit = this.#originalProcessReallyExit;
+		this.#emitter.count -= 1;
+	}
+	#processReallyExit(code) {
+		/* c8 ignore start */
+		if (!processOk(this.#process)) return 0;
+		this.#process.exitCode = code || 0;
+		/* c8 ignore stop */
+		this.#emitter.emit("exit", this.#process.exitCode, null);
+		return this.#originalProcessReallyExit.call(this.#process, this.#process.exitCode);
+	}
+	#processEmit(ev, ...args) {
+		const og = this.#originalProcessEmit;
+		if (ev === "exit" && processOk(this.#process)) {
+			if (typeof args[0] === "number") this.#process.exitCode = args[0];
+			/* c8 ignore start */
+			const ret = og.call(this.#process, ev, ...args);
+			/* c8 ignore start */
+			this.#emitter.emit("exit", this.#process.exitCode, null);
+			/* c8 ignore stop */
+			return ret;
+		} else return og.call(this.#process, ev, ...args);
+	}
+};
+const process$1 = globalThis.process;
+const { onExit: onExit$1, load, unload } = signalExitWrap(processOk(process$1) ? new SignalExit(process$1) : new SignalExitFallback());
+
+//#endregion
+//#region src/utils/signal-exit.ts
+function onExit(...args) {
+	if (typeof process === "object" && process.versions.webcontainer) {
+		process.on("exit", (code) => {
+			args[0](code, null);
+		});
+		return;
+	}
+	onExit$1(...args);
+}
+
+//#endregion
+//#region src/api/watch/watch-emitter.ts
+var WatcherEmitter = class {
+	listeners = /* @__PURE__ */ new Map();
+	timer;
+	constructor() {
+		this.timer = setInterval(() => {}, 1e9);
+	}
+	on(event, listener) {
+		const listeners = this.listeners.get(event);
+		if (listeners) listeners.push(listener);
+		else this.listeners.set(event, [listener]);
+		return this;
+	}
+	off(event, listener) {
+		const listeners = this.listeners.get(event);
+		if (listeners) {
+			const index = listeners.indexOf(listener);
+			if (index !== -1) listeners.splice(index, 1);
+		}
+		return this;
+	}
+	clear(event) {
+		if (this.listeners.has(event)) this.listeners.delete(event);
+	}
+	async onEvent(event) {
+		const listeners = this.listeners.get(event.eventKind());
+		if (listeners) switch (event.eventKind()) {
+			case "close":
+			case "restart":
+				for (const listener of listeners) await listener();
+				break;
+			case "event":
+				for (const listener of listeners) {
+					const code = event.bundleEventKind();
+					switch (code) {
+						case "BUNDLE_END":
+							const { duration, output, result } = event.bundleEndData();
+							await listener({
+								code: "BUNDLE_END",
+								duration,
+								output: [output],
+								result
+							});
+							break;
+						case "ERROR":
+							const data = event.bundleErrorData();
+							await listener({
+								code: "ERROR",
+								error: aggregateBindingErrorsIntoJsError(data.error),
+								result: data.result
+							});
+							break;
+						default:
+							await listener({ code });
+							break;
+					}
+				}
+				break;
+			case "change":
+				for (const listener of listeners) {
+					const { path, kind } = event.watchChangeData();
+					await listener(path, { event: kind });
+				}
+				break;
+			default: throw new Error(`Unknown event: ${event}`);
+		}
+	}
+	async close() {
+		clearInterval(this.timer);
+	}
+};
+
+//#endregion
+//#region src/api/watch/watcher.ts
+var Watcher = class {
+	closed;
+	inner;
+	emitter;
+	stopWorkers;
+	constructor(emitter, inner, stopWorkers) {
+		this.closed = false;
+		this.inner = inner;
+		this.emitter = emitter;
+		const originClose = emitter.close.bind(emitter);
+		emitter.close = async () => {
+			await this.close();
+			originClose();
+		};
+		this.stopWorkers = stopWorkers;
+	}
+	async close() {
+		if (this.closed) return;
+		this.closed = true;
+		for (const stop of this.stopWorkers) await stop?.();
+		await this.inner.close();
+		shutdownAsyncRuntime();
+	}
+	start() {
+		process.nextTick(() => this.inner.start(this.emitter.onEvent.bind(this.emitter)));
+	}
+};
+async function createWatcher(emitter, input) {
+	const options = arraify(input);
+	const bundlerOptions = await Promise.all(options.map((option) => arraify(option.output || {}).map(async (output) => {
+		return createBundlerOptions(await PluginDriver.callOptionsHook(option, true), output, true);
+	})).flat());
+	const notifyOptions = getValidNotifyOption(bundlerOptions);
+	new Watcher(emitter, new BindingWatcher(bundlerOptions.map((option) => option.bundlerOptions), notifyOptions), bundlerOptions.map((option) => option.stopWorkers)).start();
+}
+function getValidNotifyOption(bundlerOptions) {
+	let result;
+	for (const option of bundlerOptions) if (option.inputOptions.watch) {
+		const notifyOption = option.inputOptions.watch.notify;
+		if (notifyOption) if (result) {
+			option.onLog(LOG_LEVEL_WARN, logMultiplyNotifyOption());
+			return result;
+		} else result = notifyOption;
+	}
+}
+
+//#endregion
+//#region src/api/watch/index.ts
+/**
+* The API compatible with Rollup's `watch` function.
+*
+* This function will rebuild the bundle when it detects that the individual modules have changed on disk.
+*
+* Note that when using this function, it is your responsibility to call `event.result.close()` in response to the `BUNDLE_END` event to avoid resource leaks.
+*
+* @param input The watch options object or the list of them.
+* @returns A watcher object.
+*
+* @example
+* ```js
+* import { watch } from 'rolldown';
+*
+* const watcher = watch({ /* ... *\/ });
+* watcher.on('event', (event) => {
+*   if (event.code === 'BUNDLE_END') {
+*     console.log(event.duration);
+*     event.result.close();
+*   }
+* });
+*
+* // Stop watching
+* watcher.close();
+* ```
+*
+* @experimental
+* @category Programmatic APIs
+*/
+function watch(input) {
+	const emitter = new WatcherEmitter();
+	createWatcher(emitter, input);
+	return emitter;
+}
+
+//#endregion
+export { onExit as n, watch as t };

package/package.json

@@ -1,71 +1,66 @@
 {
   "name": "@rolldown/browser",
-  "version": "1.0.0-beta.9-commit.0ec9e7d",
+  "version": "1.0.0-rc.2",
   "description": "Fast JavaScript/TypeScript bundler in Rust with Rollup-compatible API.",
+  "keywords": [
+    "bundler",
+    "esbuild",
+    "parcel",
+    "rolldown",
+    "rollup",
+    "webpack"
+  ],
   "homepage": "https://rolldown.rs/",
-  "type": "module",
+  "license": "MIT",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/rolldown/rolldown.git",
     "directory": "packages/browser"
   },
-  "license": "MIT",
-  "keywords": [
-    "webpack",
-    "parcel",
-    "esbuild",
-    "rollup",
-    "bundler",
-    "rolldown"
-  ],
+  "bin": {
+    "rolldown": "./bin/cli.mjs"
+  },
   "files": [
     "bin",
     "dist",
     "!*/.tsbuildinfo"
   ],
-  "bin": {
-    "rolldown": "./bin/cli.mjs"
-  },
-  "main": "./dist/index.cjs",
+  "type": "module",
+  "main": "./dist/index.mjs",
   "module": "./dist/index.mjs",
-  "types": "./dist/index.d.cts",
+  "types": "./dist/index.d.mts",
   "exports": {
     ".": {
       "browser": "./dist/index.browser.mjs",
-      "require": "./dist/index.cjs",
-      "import": "./dist/index.mjs"
+      "default": "./dist/index.mjs"
     },
+    "./config": "./dist/config.mjs",
     "./experimental": {
       "browser": "./dist/experimental-index.browser.mjs",
-      "require": "./dist/experimental-index.cjs",
-      "import": "./dist/experimental-index.mjs"
-    },
-    "./parallel-plugin": {
-      "require": "./dist/parallel-plugin.cjs",
-      "import": "./dist/parallel-plugin.mjs"
+      "default": "./dist/experimental-index.mjs"
     },
-    "./parseAst": {
-      "require": "./dist/parse-ast-index.cjs",
-      "import": "./dist/parse-ast-index.mjs"
+    "./plugins": {
+      "browser": "./dist/plugins-index.browser.mjs",
+      "default": "./dist/plugins-index.mjs"
     },
+    "./filter": "./dist/filter-index.mjs",
+    "./parallelPlugin": "./dist/parallel-plugin.mjs",
+    "./parseAst": "./dist/parse-ast-index.mjs",
     "./package.json": "./package.json"
   },
   "publishConfig": {
-    "registry": "https://registry.npmjs.org/",
-    "access": "public"
+    "access": "public",
+    "registry": "https://registry.npmjs.org/"
   },
   "dependencies": {
-    "@napi-rs/wasm-runtime": "^0.2.8",
-    "@oxc-project/runtime": "0.72.0",
-    "@oxc-project/types": "0.72.0",
-    "ansis": "^4.0.0",
-    "pathe": "^2.0.3"
+    "@napi-rs/wasm-runtime": "^1.0.0"
   },
   "scripts": {
     "build": "pnpm run build:debug",
-    "build:debug": "pnpm run --filter rolldown build-browser:debug",
-    "build:release": "pnpm run --filter rolldown build-browser:release",
-    "build-node": "BROWSER_PKG=1 pnpm run --filter rolldown build-node",
-    "preinstall": "npx only-allow pnpm"
+    "build:debug": "pnpm run --filter rolldown build-browser-pkg:debug",
+    "build:release": "pnpm run --filter rolldown build-browser-pkg:release",
+    "build-node": "TARGET='browser' pnpm run --filter rolldown build-node",
+    "preinstall": "npx only-allow pnpm",
+    "publint": "publint ."
   }
 }