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

package/dist/server/symbolicate.js

@@ -0,0 +1,93 @@
+import { parseUrl } from "../utils/url.js";
+import { codeFrameColumns } from "@babel/code-frame";
+//#region src/server/symbolicate.ts
+/**
+* @see https://github.com/facebook/react-native/blob/0.83-stable/packages/metro-config/src/index.flow.js#L17
+*/
+const INTERNAL_CALLSITES_REGEX = new RegExp([
+	"/Libraries/BatchedBridge/MessageQueue\\.js$",
+	"/Libraries/Core/.+\\.js$",
+	"/Libraries/LogBox/.+\\.js$",
+	"/Libraries/Network/.+\\.js$",
+	"/Libraries/Pressability/.+\\.js$",
+	"/Libraries/Renderer/implementations/.+\\.js$",
+	"/Libraries/Utilities/.+\\.js$",
+	"/Libraries/vendor/.+\\.js$",
+	"/Libraries/WebSocket/.+\\.js$",
+	"/src/private/renderer/errorhandling/.+\\.js$",
+	"/metro-runtime/.+\\.js$",
+	"/node_modules/@babel/runtime/.+\\.js$",
+	"/node_modules/@react-native/js-polyfills/.+\\.js$",
+	"/node_modules/invariant/.+\\.js$",
+	"/node_modules/react-devtools-core/.+\\.js$",
+	"/node_modules/react-native/index.js$",
+	"/node_modules/react-refresh/.+\\.js$",
+	"/node_modules/scheduler/.+\\.js$",
+	"^\\[native code\\]$"
+].map((pathPattern) => pathPattern.replaceAll("/", "[/\\\\]")).join("|"));
+async function symbolicate(bundleStore, stack) {
+	const sourceMapConsumer = await bundleStore.sourceMapConsumer;
+	const symbolicatedStack = stack.filter((frame) => frame.file?.startsWith("http")).map((frame) => sourceMapConsumer ? originalPositionFor(sourceMapConsumer, frame) : frame).map((frame) => collapseFrame(frame));
+	return {
+		stack: symbolicatedStack,
+		codeFrame: getCodeFrame(symbolicatedStack, bundleStore, sourceMapConsumer)
+	};
+}
+function originalPositionFor(sourceMapConsumer, frame) {
+	if (frame.column == null || frame.lineNumber == null) return frame;
+	const originalPosition = sourceMapConsumer.originalPositionFor({
+		column: frame.column,
+		line: frame.lineNumber
+	});
+	return Object.entries(originalPosition).reduce((frame, [key, value]) => {
+		const targetKey = convertFrameKey(key);
+		return {
+			...frame,
+			...value ? { [targetKey]: value } : null
+		};
+	}, frame);
+}
+function collapseFrame(frame) {
+	return {
+		...frame,
+		collapse: Boolean(frame.file && INTERNAL_CALLSITES_REGEX.test(frame.file))
+	};
+}
+function isCollapsed(frame) {
+	return "collapse" in frame && frame.collapse;
+}
+function convertFrameKey(key) {
+	if (key === "line") return "lineNumber";
+	else if (key === "source") return "file";
+	else if (key === "name") return "methodName";
+	return key;
+}
+function getCodeFrame(frames, bundleStore, sourceMapConsumer) {
+	const frame = frames.find((frame) => {
+		return frame.lineNumber != null && frame.column != null && !isCollapsed(frame);
+	});
+	if (frame?.file == null || frame.column == null || frame.lineNumber == null) return null;
+	try {
+		const { lineNumber, column, file } = frame;
+		const unresolved = file.startsWith("http");
+		const source = sourceMapConsumer == null || unresolved ? bundleStore.code : sourceMapConsumer.sourceContentFor(frame.file);
+		const fileName = unresolved ? parseUrl(file).pathname ?? "unknown" : file;
+		let content = "";
+		if (source) content = codeFrameColumns(source, { start: {
+			column,
+			line: lineNumber
+		} }, { highlightCode: true });
+		return {
+			content,
+			fileName,
+			location: {
+				column,
+				row: lineNumber
+			}
+		};
+	} catch {
+		return null;
+	}
+}
+//#endregion
+export { symbolicate };

package/dist/server/types.d.ts

@@ -0,0 +1,125 @@
+import { BuildOptions } from "../core/types.js";
+import { WebSocketClient } from "./wss/server.js";
+import { ServerEventBus } from "./events/event-bus.js";
+import { BundlerPool } from "./bundler-pool.js";
+import { ResolvedConfig } from "../config/defaults.js";
+import { FastifyInstance } from "fastify";
+import { Emitter } from "mitt";
+import * as ws from "ws";
+import * as fastifyMiddie from "@fastify/middie";
+
+//#region src/server/types.d.ts
+type FastifyInstance$1 = FastifyInstance & {
+  use(fn: fastifyMiddie.Handler): FastifyInstance$1;
+  use(route: string, fn: fastifyMiddie.Handler): FastifyInstance$1;
+  use(routes: string[], fn: fastifyMiddie.Handler): FastifyInstance$1;
+};
+interface ServerOptions {
+  port?: number;
+  host?: string;
+  https?: boolean;
+  key?: string;
+  cert?: string;
+  buildOptions?: Pick<BuildOptions, 'cache'>;
+  mcp?: boolean;
+}
+interface DevServerContext {
+  /**
+   * The base URL of the development server.
+   */
+  serverBaseUrl: string;
+  /**
+   * Resolved Rollipop config.
+   */
+  config: ResolvedConfig;
+  /**
+   * Server options.
+   */
+  options: ServerOptions;
+  /**
+   * The bundler pool.
+   */
+  bundlerPool: BundlerPool;
+  /**
+   * The event bus.
+   */
+  eventBus: ServerEventBus;
+  /**
+   * The message websocket server API.
+   */
+  message: ws.Server & {
+    /**
+     * Broadcast a message to all connected devices.
+     */
+    broadcast: (method: string, params?: Record<string, any>) => void;
+  };
+  /**
+   * The events websocket server API.
+   */
+  events: ws.Server & {
+    /**
+     * Report an event to the reporter.
+     */
+    reportEvent: (event: {
+      type: string;
+      [key: string]: unknown;
+    }) => void;
+  };
+  /**
+   * HMR websocket server API
+   */
+  hot: ws.Server & {
+    send: (client: ws.WebSocket, eventName: string, payload?: unknown) => void;
+    sendAll: (eventName: string, payload?: unknown) => void;
+  };
+}
+type DevServerEvents = {
+  'device.connected': {
+    client: WebSocketClient;
+  };
+  'device.message': {
+    client: WebSocketClient;
+    data: ws.RawData;
+  };
+  'device.error': {
+    client: WebSocketClient;
+    error: Error;
+  };
+  'device.disconnected': {
+    client: WebSocketClient;
+  };
+};
+interface Middlewares {
+  /**
+   * Register a middleware to the Fastify instance.
+   *
+   * **NOTE**: This is a wrapper of `instance.use`.
+   */
+  use: FastifyInstance$1['use'];
+}
+type DevServer = {
+  /**
+   * The Fastify instance.
+   */
+  instance: FastifyInstance$1;
+  /**
+   * `express` and `connect` style middleware registration API.
+   */
+  middlewares: Middlewares;
+} & DevServerContext & Emitter<DevServerEvents>;
+interface BundleDetails {
+  bundleType: string;
+  dev: boolean;
+  entryFile: string;
+  minify: boolean;
+  platform?: string;
+}
+interface FormattedError {
+  type: string;
+  message: string;
+  errors: {
+    description: string;
+  }[];
+}
+//#endregion
+export { BundleDetails, DevServer, DevServerContext, DevServerEvents, FastifyInstance$1 as FastifyInstance, FormattedError, Middlewares, ServerOptions };

package/dist/server/wss/hmr-server.js

@@ -0,0 +1,209 @@
+import { isBundlerEventForId } from "../events/types.js";
+import { WebSocketServer } from "./server.js";
+import { invariant } from "es-toolkit";
+//#region src/server/wss/hmr-server.ts
+var HMRServer = class extends WebSocketServer {
+	bundlerPool;
+	eventBus;
+	instances = /* @__PURE__ */ new Map();
+	bindings = /* @__PURE__ */ new Map();
+	constructor({ bundlerPool, eventBus }) {
+		super("hmr", { noServer: true });
+		this.bundlerPool = bundlerPool;
+		this.eventBus = eventBus;
+	}
+	parseClientMessage(data) {
+		const parsedData = JSON.parse(this.rawDataToString(data));
+		const clientMessage = "type" in parsedData ? parsedData : null;
+		invariant(clientMessage, "Invalid HMR client message");
+		return clientMessage;
+	}
+	async handleConnected(client, platform, bundleEntry) {
+		try {
+			this.logger.trace(`HMR client connected (clientId: ${client.id})`, {
+				platform,
+				bundleEntry
+			});
+			const devEngineInstance = this.bundlerPool.get(bundleEntry, {
+				platform,
+				dev: true
+			});
+			this.bindEvents(client, devEngineInstance);
+			this.instances.set(client.id, devEngineInstance);
+			this.logger.trace(`Bundler instance prepared (bundlerId: ${devEngineInstance.id})`);
+		} catch (error) {
+			this.logger.error(`Failed to prepare bundler instance`, error);
+		}
+	}
+	bindEvents(client, instance) {
+		if (this.bindings.get(client.id) == null) {
+			const unsubscribe = this.eventBus.subscribe((event) => {
+				if (!isBundlerEventForId(event, instance.id)) return;
+				switch (event.type) {
+					case "hmr_updates":
+						this.handleUpdates(client, event.updates);
+						break;
+					case "hmr_failed":
+						this.sendBuildFailed(client, event.error);
+						break;
+				}
+			});
+			this.bindings.set(client.id, { unsubscribe });
+			this.logger.trace(`HMR event binding established (clientId: ${client.id})`);
+		}
+	}
+	sendBuildFailed(client, error) {
+		this.send(client, JSON.stringify({
+			type: "hmr:error",
+			payload: {
+				type: "BuildError",
+				errors: [{ description: error.message }],
+				message: error.message
+			}
+		}));
+	}
+	async handleModuleRegistered(client, modules) {
+		try {
+			const instance = this.instances.get(client.id);
+			invariant(instance != null, `Bundler instance not found for client clientId: ${client.id}`);
+			await instance.ensureInitialized;
+			await instance.devEngine.registerModules(client.id.toString(), modules);
+		} catch (error) {
+			this.logger.error(`Failed to handle module registered`, error);
+		}
+	}
+	async handleInvalidate(client, moduleId) {
+		try {
+			const instance = this.instances.get(client.id);
+			invariant(instance != null, `Bundler instance not found for client clientId: ${client.id}`);
+			await instance.ensureInitialized;
+			const updates = await instance.devEngine.invalidate(moduleId);
+			await this.handleUpdates(client, updates);
+		} catch (error) {
+			this.logger.error(`Failed to handle invalidate`, error);
+		}
+	}
+	async handleUpdates(client, updates) {
+		this.logger.trace(`HMR updates found (clientId: ${client.id})`, { updatesCount: updates.length });
+		const actionableUpdates = updates.filter((clientUpdate) => clientUpdate.update.type !== "Noop");
+		if (actionableUpdates.length === 0) return;
+		this.send(client, JSON.stringify({ type: "hmr:update-start" }));
+		for (const clientUpdate of actionableUpdates) {
+			const update = clientUpdate.update;
+			switch (update.type) {
+				case "Patch":
+					this.sendUpdateToClient(client, update);
+					break;
+				case "FullReload":
+					this.sendReloadToClient(client);
+					break;
+				case "Noop": break;
+			}
+		}
+	}
+	sendUpdateToClient(client, update) {
+		invariant(update.type === "Patch", "Invalid HMR update type");
+		const updateMessage = {
+			type: "hmr:update",
+			code: update.code
+		};
+		this.send(client, JSON.stringify(updateMessage));
+		this.done(client);
+	}
+	sendReloadToClient(client) {
+		this.logger.trace(`Sending HMR reload message to client (clientId: ${client.id})`);
+		this.send(client, JSON.stringify({ type: "hmr:reload" }));
+		this.done(client);
+	}
+	done(client) {
+		this.send(client, JSON.stringify({ type: "hmr:update-done" }));
+	}
+	sendError(client, error) {
+		try {
+			this.send(client, JSON.stringify(error));
+		} catch (error) {
+			this.logger.error(`Failed to send HMR error message to client (clientId: ${client.id})`, error);
+		}
+	}
+	cleanup(client) {
+		this.logger.trace(`HMR client cleanup (clientId: ${client.id})`);
+		const binding = this.bindings.get(client.id);
+		const instance = this.instances.get(client.id);
+		if (binding != null) binding.unsubscribe();
+		if (instance != null) try {
+			instance.devEngine.removeClient(String(client.id));
+		} catch (error) {
+			this.logger.warn(`Skipped devEngine.removeClient for client ${client.id}: ` + (error instanceof Error ? error.message : String(error)));
+		}
+		this.bindings.delete(client.id);
+		this.instances.delete(client.id);
+	}
+	onMessage(client, data) {
+		let message;
+		try {
+			message = this.parseClientMessage(data);
+			let traceMessage = message;
+			if (message.type === "hmr:module-registered") traceMessage = {
+				...message,
+				modules: `[${message.modules.length} modules]`
+			};
+			else if (message.type === "hmr:log") traceMessage = {
+				...message,
+				data: `(${message.data.length} items)`
+			};
+			this.logger.trace("HMR client message received", traceMessage);
+		} catch (error) {
+			const message = "Failed to parse HMR client message";
+			this.logger.error(message, error);
+			this.sendError(client, {
+				type: "InternalError",
+				errors: [{ description: error instanceof Error ? error.message : String(error) }],
+				message
+			});
+			return;
+		}
+		if (isCustomHMRMessage(message)) {
+			this.wss.emit(message.type, message.payload);
+			return;
+		}
+		switch (message.type) {
+			case "hmr:connected":
+				this.handleConnected(client, message.platform, message.bundleEntry);
+				break;
+			case "hmr:module-registered":
+				this.handleModuleRegistered(client, message.modules);
+				break;
+			case "hmr:invalidate":
+				this.handleInvalidate(client, message.moduleId);
+				break;
+			case "hmr:log": {
+				const instance = this.instances.get(client.id);
+				this.eventBus.emit({
+					type: "client_log",
+					...instance != null ? { bundlerId: instance.id } : {},
+					level: message.level,
+					data: message.data
+				});
+				break;
+			}
+		}
+	}
+	onConnection(client) {
+		this.logger.trace(`connection established (clientId: ${client.id})`);
+	}
+	onError(client, error) {
+		this.logger.error(`connection error (clientId: ${client.id})`, error);
+		this.cleanup(client);
+	}
+	onClose(client) {
+		this.logger.trace(`connection closed (clientId: ${client.id})`);
+		this.cleanup(client);
+	}
+};
+function isCustomHMRMessage(message) {
+	if (typeof message !== "object" || message == null) return false;
+	if ("type" in message && typeof message.type === "string" && message.type.startsWith("hmr:")) return false;
+	return true;
+}
+//#endregion
+export { HMRServer };

package/dist/server/wss/server.d.ts

@@ -0,0 +1,9 @@
+import EventEmitter from "node:events";
+import * as ws from "ws";
+
+//#region src/server/wss/server.d.ts
+type WebSocketClient = ws.WebSocket & {
+  id: number;
+};
+//#endregion
+export { WebSocketClient };

package/dist/server/wss/server.js

@@ -0,0 +1,70 @@
+import { logger } from "../logger.js";
+import { parseUrl } from "../../utils/url.js";
+import EventEmitter from "node:events";
+import * as ws from "ws";
+//#region src/server/wss/server.ts
+var WebSocketServer = class extends EventEmitter {
+	clientId = 0;
+	wss;
+	logger;
+	constructor(name, options) {
+		super();
+		const logger$1 = logger.child(name);
+		const wss = new ws.WebSocketServer(options);
+		wss.on("connection", (socket) => {
+			const client = Object.defineProperty(socket, "id", {
+				value: this.clientId++,
+				writable: false
+			});
+			this.onConnection(client);
+			this.emit("connection", client);
+			client.on("message", (data) => {
+				this.onMessage(client, data);
+				this.emit("message", client, data);
+			});
+			client.on("error", (error) => {
+				this.onError(client, error);
+				this.emit("error", client, error);
+			});
+			client.on("close", () => {
+				this.onClose(client);
+				this.emit("close", client);
+			});
+		});
+		this.wss = wss;
+		this.logger = logger$1;
+	}
+	get server() {
+		return this.wss;
+	}
+	send(client, data) {
+		if (client.readyState === ws.WebSocket.OPEN) client.send(data);
+	}
+	sendAll(data) {
+		this.wss.clients.forEach((client) => {
+			if (client.readyState === ws.WebSocket.OPEN) client.send(data);
+		});
+	}
+	rawDataToString(data) {
+		if (Buffer.isBuffer(data)) return data.toString("utf8");
+		if (Array.isArray(data)) return Buffer.concat(data).toString("utf8");
+		return Buffer.from(data).toString("utf8");
+	}
+};
+function getWebSocketUpgradeHandler(websocketEndpoints) {
+	return (request, socket, head) => {
+		if (request.url == null) {
+			socket.destroy();
+			return;
+		}
+		const { pathname } = parseUrl(request.url);
+		if (pathname != null && websocketEndpoints[pathname]) {
+			const wss = websocketEndpoints[pathname];
+			wss.handleUpgrade(request, socket, head, (socket) => {
+				wss.emit("connection", socket, request);
+			});
+		} else socket.destroy();
+	};
+}
+//#endregion
+export { WebSocketServer, getWebSocketUpgradeHandler };

package/dist/{runtime.d.cts → types/hmr.d.ts}

@@ -73,15 +73,4 @@ interface DevRuntimeMessenger {
   send(message: HMRClientMessage): void;
 }
 //#endregion
-//#region src/runtime.d.ts
-declare global {
-  var __ROLLIPOP_CUSTOM_HMR_HANDLER__: HMRCustomHandler | undefined;
-}
-/**
- * Set a custom HMR handler.
- *
- * @param handler - The custom HMR handler to set.
- */
-declare function setCustomHMRHandler(handler: HMRCustomHandler): void;
-//#endregion
-export { setCustomHMRHandler };
+export { type DevRuntime, DevRuntimeInterface, DevRuntimeMessenger, DevRuntimeModule, HMRClientLogLevel, HMRClientMessage, HMRContext, HMRCustomHandler, HMRCustomMessage, HMRServerError, HMRServerMessage };

package/dist/types.d.ts

@@ -0,0 +1,78 @@
+//#region src/types.d.ts
+type MaybePromise<T> = T | Promise<T>;
+type NullValue<T = void> = T | undefined | null | void;
+type DeepRequired<T> = { [K in keyof T]-?: T[K] extends object ? DeepRequired<T[K]> : T[K] };
+interface Reporter {
+  update(event: ReportableEvent): void;
+}
+interface OptionalBundlerEvent {
+  bundlerId?: string;
+}
+interface BuildDiagnosticLog {
+  code?: string;
+  plugin?: string;
+  message: string;
+  stack?: string;
+  id?: string;
+  hook?: string;
+  frame?: string;
+  loc?: {
+    column: number;
+    file?: string;
+    line: number;
+  };
+  meta?: unknown;
+}
+type ReportableEvent = ({
+  type: 'bundle_build_started';
+} & OptionalBundlerEvent) | ({
+  type: 'bundle_build_done';
+  totalModules: number;
+  transformedModules: number;
+  cacheHitModules: number;
+  duration: number;
+  bundleFilePath?: string;
+} & OptionalBundlerEvent) | ({
+  type: 'bundle_build_failed';
+  error: Error;
+} & OptionalBundlerEvent) | ({
+  type: 'hmr_failed';
+  error: Error;
+} & OptionalBundlerEvent) | ({
+  type: 'transform';
+  id: string;
+  totalModules: number | undefined;
+  transformedModules: number;
+} & OptionalBundlerEvent) | ({
+  type: 'watch_change';
+  id: string;
+} & OptionalBundlerEvent) | ({
+  type: 'build_log';
+  level: 'debug' | 'info';
+  log: BuildDiagnosticLog;
+} & OptionalBundlerEvent) | ({
+  type: 'build_error';
+  level: 'warn' | 'error';
+  log: BuildDiagnosticLog;
+} & OptionalBundlerEvent) | MetroCompatibleClientLogEvent;
+type MetroCompatibleClientLogEvent = {
+  type: 'client_log';
+  level: 'trace' | 'info' | 'warn' | 'log' | 'group' | 'groupCollapsed' | 'groupEnd' | 'debug'
+  /**
+   * In react-native, ReportableEvent['level'] does not defined `error` type.
+   * But, Flipper supports the `error` type.
+   *
+   * @see https://github.com/facebook/flipper/blob/v0.273.0/desktop/flipper-common/src/server-types.tsx#L74
+   */
+  | 'error';
+  data: any[];
+  bundlerId?: string;
+};
+interface PackageJson {
+  name: string;
+  version?: string;
+  dependencies?: Record<string, string>;
+  devDependencies?: Record<string, string>;
+}
+//#endregion
+export { BuildDiagnosticLog, DeepRequired, MaybePromise, MetroCompatibleClientLogEvent, NullValue, PackageJson, ReportableEvent, Reporter };

package/dist/utils/babel.js

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

package/dist/utils/build-options.js

@@ -0,0 +1,17 @@
+import path from "node:path";
+import { merge } from "es-toolkit";
+//#region src/utils/build-options.ts
+const DEFAULT_BUILD_OPTIONS = {
+	cache: true,
+	minify: false
+};
+function resolveBuildOptions(config, buildOptions) {
+	if (buildOptions.outfile) buildOptions.outfile = path.resolve(config.root, buildOptions.outfile);
+	if ((buildOptions.sourcemap === true || buildOptions.sourcemap === "hidden") && buildOptions.sourcemapOutfile) buildOptions.sourcemapOutfile = path.resolve(config.root, buildOptions.sourcemapOutfile);
+	return merge(DEFAULT_BUILD_OPTIONS, {
+		...buildOptions,
+		dev: buildOptions.dev ?? config.mode === "development"
+	});
+}
+//#endregion
+export { resolveBuildOptions };

package/dist/utils/bundle.js

@@ -0,0 +1,6 @@
+//#region src/utils/bundle.ts
+function getBaseBundleName(name) {
+	return name.replace(/^\//, "").replace(/\.bundle$/, "");
+}
+//#endregion
+export { getBaseBundleName };

package/dist/utils/config.d.ts

@@ -0,0 +1,5 @@
+import { HmrConfig } from "../config/types.js";
+//#region src/utils/config.d.ts
+type ResolvedHmrConfig = Required<HmrConfig>;
+//#endregion
+export { ResolvedHmrConfig };

package/dist/utils/config.js

@@ -0,0 +1,32 @@
+import { __require } from "../_virtual/_rolldown/runtime.js";
+import fs from "node:fs";
+//#region src/utils/config.ts
+function bindReporter(config, onEvent) {
+	const reporter = { update(event) {
+		onEvent?.(event);
+	} };
+	return {
+		...config,
+		reporter
+	};
+}
+function resolveHmrConfig(config) {
+	if (config.mode !== "development") return null;
+	const defaultRuntimeImplements = getDefaultRuntimeImplements();
+	if (typeof config.devMode.hmr === "boolean") return config.devMode.hmr ? defaultRuntimeImplements : null;
+	const { runtimeImplement = defaultRuntimeImplements.runtimeImplement, clientImplement = defaultRuntimeImplements.clientImplement } = config.devMode.hmr;
+	return {
+		runtimeImplement,
+		clientImplement
+	};
+}
+getDefaultRuntimeImplements.cache = null;
+function getDefaultRuntimeImplements() {
+	if (getDefaultRuntimeImplements.cache == null) getDefaultRuntimeImplements.cache = {
+		runtimeImplement: fs.readFileSync(__require.resolve("rollipop/hmr-runtime"), "utf-8"),
+		clientImplement: fs.readFileSync(__require.resolve("rollipop/hmr-client"), "utf-8")
+	};
+	return getDefaultRuntimeImplements.cache;
+}
+//#endregion
+export { bindReporter, resolveHmrConfig };