rollipop 1.0.0-alpha.21 → 1.0.0-alpha.23

package/dist/utils/dev-server.js

@@ -0,0 +1,51 @@
+import { logger } from "../server/logger.js";
+import http from "node:http";
+//#region src/utils/dev-server.ts
+async function assertDevServerStatus(options) {
+	const { devServerUrl, projectRoot, port } = options;
+	const status = await getDevServerStatus(devServerUrl, projectRoot);
+	let shouldExit = false;
+	switch (status) {
+		case 1:
+			logger.warn(`A dev server is already running for this project on port ${port}. Exiting.`);
+			shouldExit = true;
+			break;
+		case 2:
+			logger.error(`Another process is running on port ${port}. Please terminate this process and try again, or use another port with "--port".`);
+			shouldExit = true;
+			break;
+	}
+	if (shouldExit) process.exit(1);
+}
+async function getDevServerStatus(devServerUrl, projectRoot) {
+	const { hostname, port } = new URL(devServerUrl);
+	try {
+		if (!await isPortOccupied(hostname, port)) return 0;
+		const statusResponse = await fetch(`${devServerUrl}/status`);
+		return await statusResponse.text() === "packager-status:running" && statusResponse.headers.get("X-React-Native-Project-Root") === projectRoot ? 1 : 2;
+	} catch {
+		return 3;
+	}
+}
+async function isPortOccupied(host, port) {
+	let result = false;
+	const server = http.createServer();
+	return new Promise((resolve, reject) => {
+		server.once("error", (error) => {
+			server.close();
+			if (error.code === "EADDRINUSE") result = true;
+			else reject(error);
+		});
+		server.once("listening", () => {
+			result = false;
+			server.close();
+		});
+		server.once("close", () => resolve(result));
+		server.listen({
+			host,
+			port
+		});
+	});
+}
+//#endregion
+export { assertDevServerStatus };

package/dist/utils/env.js

@@ -0,0 +1,7 @@
+import { asLiteral } from "../common/code.js";
+//#region src/utils/env.ts
+function defineEnvFromObject(env) {
+	return Object.fromEntries(Object.entries(env).map(([key, value]) => [`import.meta.env.${key}`, asLiteral(value)]));
+}
+//#endregion
+export { defineEnvFromObject };

package/dist/utils/errors.js

@@ -0,0 +1,9 @@
+import stripAnsi from "strip-ansi";
+//#region src/utils/errors.ts
+function normalizeRolldownError(error) {
+	const normalizedError = new Error(stripAnsi(error.message));
+	normalizedError.stack = error.stack;
+	return normalizedError;
+}
+//#endregion
+export { normalizeRolldownError };

package/dist/utils/hash.js

@@ -0,0 +1,8 @@
+import crypto from "node:crypto";
+import "@node-rs/xxhash";
+//#region src/utils/hash.ts
+function md5(data) {
+	return crypto.createHash("md5").update(data).digest("hex");
+}
+//#endregion
+export { md5 };

package/dist/utils/id.js

@@ -0,0 +1,28 @@
+import { ROLLIPOP_VERSION } from "../constants.js";
+import { md5 } from "./hash.js";
+import { serialize } from "./serialize.js";
+import { pick } from "es-toolkit";
+//#region src/utils/id.ts
+function createId(config, buildOptions) {
+	return md5(serialize([
+		ROLLIPOP_VERSION,
+		filterTransformAffectedOptions(buildOptions),
+		filterTransformAffectedConfig(config)
+	]));
+}
+function filterTransformAffectedOptions(buildOptions) {
+	return pick(buildOptions, ["platform", "dev"]);
+}
+function filterTransformAffectedConfig(config) {
+	const { transformer, serializer, reactNative, devMode, plugins = [] } = config;
+	return [
+		transformer,
+		serializer.polyfills,
+		serializer.prelude,
+		reactNative.assetRegistryPath,
+		devMode,
+		plugins.map((plugin, index) => `${plugin.name}#${index}`)
+	];
+}
+//#endregion
+export { createId };

package/dist/utils/node-resolve.js

@@ -0,0 +1,42 @@
+import { __require } from "../_virtual/_rolldown/runtime.js";
+import fs from "node:fs";
+import path from "node:path";
+//#region src/utils/node-resolve.ts
+function resolveFrom(basePath, lookupPath) {
+	if (path.isAbsolute(lookupPath)) return lookupPath;
+	return __require.resolve(lookupPath, { paths: [basePath] });
+}
+function resolvePackagePath(basePath, packageName) {
+	let packagePath = null;
+	try {
+		packagePath = resolvePackagePathWithNodeRequire(basePath, packageName, "package.json");
+		if (packagePath) return packagePath;
+	} catch {}
+	try {
+		packagePath = resolvePackagePathWithNodeRequire(basePath, packageName);
+		if (packagePath) return packagePath;
+	} catch {}
+	throw new Error(`Failed to resolve package path for '${packageName}'`);
+}
+function resolvePackageJson(basePath, packageName) {
+	try {
+		const packagePath = resolvePackagePath(basePath, packageName);
+		const packageJsonPath = path.join(packagePath, "package.json");
+		const rawPackageJson = fs.readFileSync(packageJsonPath, "utf-8");
+		return JSON.parse(rawPackageJson);
+	} catch {
+		return null;
+	}
+}
+function resolvePackagePathWithNodeRequire(basePath, packageName, subpath) {
+	const resolvedPath = __require.resolve(subpath ? `${packageName}/${subpath}` : packageName, { paths: [basePath] });
+	const root = path.parse(resolvedPath).root;
+	let currentPath = path.dirname(resolvedPath);
+	while (currentPath !== root) {
+		if (fs.existsSync(path.join(currentPath, "package.json"))) return currentPath;
+		currentPath = path.dirname(currentPath);
+	}
+	return null;
+}
+//#endregion
+export { resolveFrom, resolvePackageJson, resolvePackagePath };

package/dist/utils/promise.js

@@ -0,0 +1,15 @@
+//#region src/utils/promise.ts
+function taskHandler() {
+	let resolver;
+	let rejector;
+	return {
+		task: new Promise((resolve, reject) => {
+			resolver = resolve;
+			rejector = reject;
+		}),
+		resolve: () => resolver?.(void 0),
+		reject: (reason) => rejector?.(reason)
+	};
+}
+//#endregion
+export { taskHandler };

package/dist/utils/reporters.js

@@ -0,0 +1,120 @@
+import { Logger } from "../common/logger.js";
+import { ProgressBarRenderManager } from "../common/progress-bar.js";
+import { logger } from "../logger.js";
+import path from "node:path";
+import chalk from "chalk";
+//#region src/utils/reporters.ts
+function mergeReporters(reporters) {
+	return { update(event) {
+		reporters.forEach((reporter) => reporter.update(event));
+	} };
+}
+var ClientLogReporter = class {
+	logger = new Logger("app");
+	update(event) {
+		if (event.type === "client_log") {
+			if (event.level === "group" || event.level === "groupCollapsed") {
+				this.logger.info(...event.data);
+				return;
+			} else if (event.level === "groupEnd") return;
+			this.logger[event.level](...event.data);
+		}
+	}
+};
+var ProgressBarStatusReporter = class {
+	root;
+	renderManager = ProgressBarRenderManager.getInstance();
+	progressBar;
+	flags = 0;
+	progressVisible = false;
+	lastBuildTotalModules;
+	hmrUpdateCount = 0;
+	constructor(root, id, label, initialTotalModules) {
+		this.root = root;
+		this.lastBuildTotalModules = initialTotalModules;
+		this.progressBar = this.renderManager.register(id, {
+			label,
+			total: initialTotalModules
+		});
+	}
+	renderProgress(id, totalModules, transformedModules) {
+		const isHmrProgress = (this.flags & 1) === 0 && (this.flags & 2) !== 0;
+		if (isHmrProgress) this.progressBar.setCurrent(0).setTotal(0).start();
+		const shouldStartProgress = !this.progressVisible;
+		if (shouldStartProgress) this.progressVisible = true;
+		if (totalModules != null) this.progressBar.setTotal(totalModules);
+		const displayId = this.getDisplayPath(id);
+		this.progressBar.setCurrent(transformedModules).setModuleId(displayId);
+		if (shouldStartProgress) this.renderManager.start();
+		else this.renderManager.render();
+		if (isHmrProgress) {
+			this.flags = 0;
+			this.hmrUpdateCount++;
+			this.progressBar.completeHmr(displayId, this.hmrUpdateCount);
+			this.renderManager.release();
+			this.progressVisible = false;
+		}
+	}
+	getCompletedBuildCurrent(event) {
+		const processedModules = event.transformedModules + event.cacheHitModules;
+		return processedModules === 0 && event.totalModules > 0 ? event.totalModules : processedModules;
+	}
+	getDisplayPath(id) {
+		const relativePath = path.relative(this.root, id);
+		if (relativePath !== "" && !relativePath.startsWith("..") && !path.isAbsolute(relativePath)) return relativePath;
+		return id;
+	}
+	update(event) {
+		switch (event.type) {
+			case "bundle_build_started":
+				this.progressBar.setCurrent(0).setTotal(this.lastBuildTotalModules);
+				this.flags |= 1;
+				this.progressBar.start();
+				if ((this.flags & 2) !== 0) {
+					this.progressVisible = true;
+					this.renderManager.start();
+				}
+				break;
+			case "bundle_build_failed":
+				this.flags = 0;
+				this.progressBar.complete(0, true);
+				this.renderManager.release();
+				this.progressVisible = false;
+				break;
+			case "bundle_build_done":
+				this.flags = 0;
+				this.lastBuildTotalModules = event.totalModules;
+				this.progressBar.setCurrent(this.getCompletedBuildCurrent(event)).setTotal(event.totalModules).complete(event.duration, false);
+				this.renderManager.release();
+				this.progressVisible = false;
+				break;
+			case "transform":
+				const { id, totalModules, transformedModules } = event;
+				this.renderProgress(id, totalModules, transformedModules);
+				break;
+			case "watch_change":
+				this.flags |= 2;
+				break;
+		}
+	}
+};
+var CompatStatusReporter = class {
+	update(event) {
+		switch (event.type) {
+			case "bundle_build_started":
+				logger.info("Build started...");
+				break;
+			case "bundle_build_failed":
+				logger.error(`Build failed`);
+				break;
+			case "bundle_build_done":
+				const { duration, totalModules } = event;
+				const time = chalk.blue(`${duration.toFixed(2)}ms`);
+				const modules = chalk.blue(`(${totalModules} modules)`);
+				logger.info(`Build completed in ${time} ${modules}`);
+				break;
+		}
+	}
+};
+//#endregion
+export { ClientLogReporter, CompatStatusReporter, ProgressBarStatusReporter, mergeReporters };

package/dist/utils/reset-cache.d.ts

@@ -0,0 +1,8 @@
+//#region src/utils/reset-cache.d.ts
+/**
+ * Remove the entire build cache directory for the given project root.
+ * Backs the `reset_cache` MCP tool and the `--reset-cache` CLI flag.
+ */
+declare function resetCache(projectRoot: string): void;
+//#endregion
+export { resetCache };

package/dist/utils/reset-cache.js

@@ -0,0 +1,25 @@
+import { getSharedDataPath } from "../core/fs/data.js";
+import fs from "node:fs";
+import path from "node:path";
+//#region src/utils/reset-cache.ts
+/**
+* Resolve the build cache directory for the given project root. The cache
+* itself is owned by rolldown's native implementation; we keep the path
+* here only because `resetCache` — and any tooling that wants to inspect
+* the on-disk layout — needs to know where to look.
+*/
+function getCacheDirectory(projectRoot) {
+	return path.join(getSharedDataPath(projectRoot), "cache");
+}
+/**
+* Remove the entire build cache directory for the given project root.
+* Backs the `reset_cache` MCP tool and the `--reset-cache` CLI flag.
+*/
+function resetCache(projectRoot) {
+	fs.rmSync(getCacheDirectory(projectRoot), {
+		recursive: true,
+		force: true
+	});
+}
+//#endregion
+export { resetCache };

package/dist/utils/response.js

@@ -0,0 +1,91 @@
+//#region src/utils/response.ts
+var BundleResponse = class BundleResponse {
+	reply;
+	static CRLF = "\r\n";
+	static THROTTLE_DELAY = 10;
+	done = 0;
+	total = 0;
+	boundary;
+	throttleTimer = null;
+	constructor(reply) {
+		this.reply = reply;
+		const boundary = performance.now().toString();
+		this.boundary = boundary;
+		this.reply.raw.writeHead(200, { "Content-Type": `multipart/mixed; boundary="${boundary}"` });
+	}
+	writeChunk(data, headers, end = false) {
+		if (this.reply.raw.writableEnded) return;
+		const CRLF = BundleResponse.CRLF;
+		this.reply.raw.write(`${CRLF}--${this.boundary}${CRLF}`);
+		this.reply.raw.write(Object.entries(headers).map(([key, value]) => `${key}: ${value}`).join(CRLF) + CRLF + CRLF);
+		if (data) this.reply.raw.write(data);
+		if (end) {
+			this.reply.raw.write(`${CRLF}--${this.boundary}--${CRLF}`);
+			this.reply.raw.end();
+		}
+	}
+	/**
+	* Sample
+	*
+	* ```
+	* --boundary
+	*
+	* Content-Type: application/json
+	*
+	* {"done":10,"total":100}
+	* ```
+	*/
+	writeBundleState(done, total) {
+		const previousProgress = this.done / this.total;
+		const currentProgress = done / total;
+		this.done = done;
+		this.total = total;
+		if (total < 10 || this.throttleTimer != null || previousProgress >= currentProgress) return;
+		this.writeChunk(JSON.stringify({
+			done,
+			total
+		}), { "Content-Type": "application/json" });
+		this.throttleTimer = setTimeout(() => {
+			this.throttleTimer = null;
+		}, BundleResponse.THROTTLE_DELAY);
+	}
+	/**
+	* Sample
+	*
+	* ```
+	* --boundary
+	*
+	* X-Metro-Files-Changed-Count: 0
+	* Content-Type: application/json
+	* Content-Length: 100
+	* Last-Modified: Thu, 10 Aug 2023 12:00:00 GMT
+	*
+	* <bundle result>
+	* ```
+	*/
+	endWithBundle(bundle) {
+		this.writeChunk(JSON.stringify({
+			done: this.total,
+			total: this.total
+		}), { "Content-Type": "application/json" });
+		this.writeChunk(bundle, {
+			"X-Metro-Files-Changed-Count": String(0),
+			"Content-Type": "application/javascript; charset=UTF-8",
+			"Content-Length": String(Buffer.byteLength(bundle)),
+			"Last-Modified": (/* @__PURE__ */ new Date()).toUTCString()
+		}, true);
+	}
+	endWithError(error) {
+		const errorData = JSON.stringify({
+			type: error?.name ?? "InternalError",
+			message: error?.message ?? "internal error",
+			errors: []
+		});
+		this.writeChunk(errorData, {
+			"Content-Type": "application/json",
+			"X-Http-Status": "500"
+		}, true);
+	}
+};
+//#endregion
+export { BundleResponse };

package/dist/utils/run-build.d.ts

@@ -0,0 +1,8 @@
+import { BuildOptions } from "../core/types.js";
+import { ResolvedConfig } from "../config/defaults.js";
+import * as rolldown from "@rollipop/rolldown";
+
+//#region src/utils/run-build.d.ts
+declare function runBuild(config: ResolvedConfig, options: BuildOptions): Promise<rolldown.OutputChunk>;
+//#endregion
+export { runBuild };

package/dist/utils/run-build.js

@@ -0,0 +1,7 @@
+import { Bundler } from "../core/bundler.js";
+//#region src/utils/run-build.ts
+async function runBuild(config, options) {
+	return await new Bundler(config).build(options);
+}
+//#endregion
+export { runBuild };

package/dist/utils/run-server.d.ts

@@ -0,0 +1,6 @@
+import { DevServer, ServerOptions } from "../server/types.js";
+import { ResolvedConfig } from "../config/defaults.js";
+//#region src/utils/run-server.d.ts
+declare function runServer(config: ResolvedConfig, options: ServerOptions): Promise<DevServer>;
+//#endregion
+export { runServer };

package/dist/utils/run-server.js

@@ -0,0 +1,20 @@
+import { logger } from "../server/logger.js";
+import { DEFAULT_HOST, DEFAULT_PORT } from "../server/constants.js";
+import { createDevServer } from "../server/create-dev-server.js";
+import "../server/index.js";
+//#region src/utils/run-server.ts
+async function runServer(config, options) {
+	const { port = DEFAULT_PORT, host = DEFAULT_HOST, https = false } = options;
+	const devServer = await createDevServer(config, options);
+	await devServer.instance.listen({
+		port,
+		host
+	});
+	if (options.mcp === true) {
+		const protocol = https ? "https" : "http";
+		logger.info(`MCP server listening at ${protocol}://${host}:${port}/mcp`);
+	}
+	return devServer;
+}
+//#endregion
+export { runServer };

package/dist/utils/runtime-target.js

@@ -0,0 +1,9 @@
+//#region src/utils/runtime-target.ts
+function resolveRuntimeTarget(target) {
+	switch (target) {
+		case "hermes": return "Hermes";
+		default: return "HermesV1";
+	}
+}
+//#endregion
+export { resolveRuntimeTarget };

package/dist/utils/serialize.js

@@ -0,0 +1,10 @@
+//#region src/utils/serialize.ts
+function serialize(value) {
+	return JSON.stringify(value, (_, value) => {
+		if (typeof value === "function") return value.toString();
+		if (value instanceof RegExp) return value.toString();
+		return value;
+	});
+}
+//#endregion
+export { serialize };

package/dist/utils/server.js

@@ -0,0 +1,6 @@
+//#region src/utils/server.ts
+function getBaseUrl(host, port, https) {
+	return `${https ? "https" : "http"}://${host}:${port}`;
+}
+//#endregion
+export { getBaseUrl };

package/dist/utils/storage.js

@@ -0,0 +1,6 @@
+//#region src/utils/storage.ts
+function getBuildTotalModules(storage, id) {
+	return storage.get().build[id]?.totalModules ?? 0;
+}
+//#endregion
+export { getBuildTotalModules };

package/dist/utils/string.js

@@ -0,0 +1,6 @@
+//#region src/utils/string.ts
+function indent(text, indent, space = " ") {
+	return text.replace(/^/gm, space.repeat(indent));
+}
+//#endregion
+export { indent };

package/dist/utils/swc.js

@@ -0,0 +1,10 @@
+import { mergeWith } from "es-toolkit";
+//#region src/utils/swc.ts
+function mergeSwcOptions(options) {
+	return options.reduce((acc, options) => mergeWith(acc, options, merge$1), {});
+}
+function merge$1(target, source, key) {
+	if (key === "plugins") return [...target ?? [], ...source ?? []];
+}
+//#endregion
+export { mergeSwcOptions };

package/dist/utils/terminal.js

@@ -0,0 +1,86 @@
+import wrapAnsi from "wrap-ansi";
+//#region src/utils/terminal.ts
+/**
+* Based on https://github.com/sindresorhus/log-update/blob/master/index.js
+* Based on https://github.com/unjs/webpackbar
+*/
+function eraseLines(count) {
+	let clear = "";
+	for (let i = 0; i < count; i++) clear += `\u001B[2K` + (i < count - 1 ? `\u001B[1A` : "");
+	if (count) clear += `\u001B[G`;
+	return clear;
+}
+function ellipsisLeft(value, maxLength) {
+	if (value.length <= maxLength - 3) return value;
+	return `...${value.slice(value.length - maxLength - 1)}`;
+}
+const originalWrite = Symbol("original-write");
+var StreamManager = class {
+	prevLineCount;
+	listening;
+	extraLines;
+	_streams;
+	constructor() {
+		this.prevLineCount = 0;
+		this.listening = false;
+		this.extraLines = "";
+		this._onData = this._onData.bind(this);
+		this._streams = [process.stdout, process.stderr];
+	}
+	render(lines) {
+		this.listen();
+		const wrappedLines = wrapAnsi(lines, this.columns, {
+			trim: false,
+			hard: true,
+			wordWrap: false
+		});
+		const data = eraseLines(this.prevLineCount) + wrappedLines + "\n" + this.extraLines;
+		this.write(data);
+		const _lines = data.split("\n");
+		this.prevLineCount = _lines.length;
+	}
+	get columns() {
+		return (process.stderr.columns || 80) - 2;
+	}
+	write(data) {
+		const stream = process.stderr;
+		if (stream.write[originalWrite]) stream.write[originalWrite].call(stream, data, "utf8");
+		else stream.write(data, "utf8");
+	}
+	clear() {
+		this.done();
+		this.write(eraseLines(this.prevLineCount));
+	}
+	done() {
+		this.stopListen();
+		this.prevLineCount = 0;
+		this.extraLines = "";
+	}
+	_onData(data) {
+		const lines = String(data).split("\n").length - 1;
+		if (lines > 0) {
+			this.prevLineCount += lines;
+			this.extraLines += data;
+		}
+	}
+	listen() {
+		if (this.listening) return;
+		for (const stream of this._streams) {
+			if (stream.write[originalWrite]) continue;
+			const write = (data, ...args) => {
+				if (!stream.write[originalWrite]) return stream.write(data, ...args);
+				this._onData(data);
+				return stream.write[originalWrite].call(stream, data, ...args);
+			};
+			write[originalWrite] = stream.write;
+			stream.write = write;
+		}
+		this.listening = true;
+	}
+	stopListen() {
+		for (const stream of this._streams) if (stream.write[originalWrite]) stream.write = stream.write[originalWrite];
+		this.listening = false;
+	}
+};
+//#endregion
+export { StreamManager, ellipsisLeft };

package/dist/utils/url.js

@@ -0,0 +1,23 @@
+//#region src/utils/url.ts
+function parseUrl(value) {
+	if (value.startsWith("/")) {
+		const [pathname, query] = value.split("?");
+		return {
+			pathname,
+			query: query ? toQueryObject(new URLSearchParams(query)) : {}
+		};
+	}
+	const url = new URL(value);
+	return {
+		pathname: url.pathname,
+		query: toQueryObject(url.searchParams)
+	};
+}
+function toQueryObject(searchParams) {
+	return searchParams.entries().reduce((acc, [key, value]) => ({
+		...acc,
+		[key]: value
+	}), {});
+}
+//#endregion
+export { parseUrl };