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

package/dist/node/commands/start/setup-interactive-mode.js

@@ -0,0 +1,107 @@
+import { logger } from "../../logger.js";
+import { DebuggerOpener } from "./debugger.js";
+import { throttle } from "es-toolkit";
+import chalk from "chalk";
+import readline from "node:readline";
+import { ReadStream } from "node:tty";
+//#region src/node/commands/start/setup-interactive-mode.ts
+const CTRL_C = "";
+const CTRL_D = "";
+const BROADCAST_THROTTLE_DELAY = 500;
+function setupInteractiveMode(options) {
+	const { devServer, extraCommands = [] } = options;
+	if (!devServer.instance.server.listening) throw new Error("Dev server is not listening. Please call `devServer.instance.listen()` first.");
+	if (!(process.stdin.isTTY && process.stdin instanceof ReadStream)) {
+		logger.warn("Interactive mode is not supported in non-interactive environments");
+		return;
+	}
+	const debuggerOpener = new DebuggerOpener(devServer.config.root, devServer.instance.listeningOrigin);
+	const defaultCommands = getDefaultCommands(devServer, debuggerOpener);
+	const allCommands = [...defaultCommands, ...extraCommands];
+	assertHasNoDuplicateCommands(defaultCommands, extraCommands);
+	readline.emitKeypressEvents(process.stdin);
+	process.stdin.setRawMode(true);
+	devServer.on("device.connected", () => {
+		debuggerOpener.autoOpen().catch(() => {
+			logger.error("Failed to open debugger");
+		});
+	});
+	process.stdin.on("keypress", (_, key) => {
+		const { ctrl = false, shift = false } = key;
+		const sequence = key.sequence?.toLowerCase();
+		if (sequence == null || debuggerOpener.isPrompting()) return;
+		if (ctrl && [CTRL_C, CTRL_D].includes(sequence)) {
+			process.stdin.setRawMode(false);
+			process.stdin.pause();
+			process.emit("SIGINT");
+			process.exit(0);
+		}
+		const targetCommand = allCommands.find((command) => command.key === sequence && (command.shift ?? false) === shift);
+		if (targetCommand) targetCommand.handler.call({
+			server: devServer,
+			logger
+		});
+	});
+	console.log();
+	allCommands.forEach((command, index) => {
+		if (defaultCommands.length === index) console.log();
+		const leadingLabel = command.shift ? "»" : "» Press";
+		const shortcut = chalk.bold(shortcutLabel(command.key, command.shift));
+		console.log(`${leadingLabel} ${shortcut} │ ${typeof command.description === "function" ? command.description() : command.description}`);
+	});
+}
+function getDefaultCommands(devServer, debuggerOpener) {
+	return [
+		{
+			key: "r",
+			description: "Reload app",
+			handler: throttle(() => {
+				logger.info("Reloading app...");
+				devServer.message.broadcast("reload");
+			}, BROADCAST_THROTTLE_DELAY)
+		},
+		{
+			key: "j",
+			description: "Open DevTools",
+			handler: () => {
+				debuggerOpener.open().catch(() => {
+					logger.error("Failed to open debugger");
+				});
+			}
+		},
+		{
+			key: "d",
+			description: "Show developer menu",
+			handler: throttle(() => {
+				logger.info("Showing developer menu...");
+				devServer.message.broadcast("devMenu");
+			}, BROADCAST_THROTTLE_DELAY)
+		},
+		{
+			key: "d",
+			shift: true,
+			description: () => {
+				const autoOpenEnabled = debuggerOpener.isAutoOpenEnabled();
+				return `Toggle auto opening developer tools on startup (${chalk.bold(autoOpenEnabled ? "enabled" : "disabled")})`;
+			},
+			handler: () => {
+				const newAutoOpenEnabled = !debuggerOpener.isAutoOpenEnabled();
+				debuggerOpener.setAutoOpenEnabled(newAutoOpenEnabled);
+				logger.info(`Auto opening developer tools: ${chalk.bold(newAutoOpenEnabled ? "enabled" : "disabled")}`);
+			}
+		}
+	];
+}
+function shortcutLabel(key, shift) {
+	if (shift) return `shift+${key}`;
+	return key;
+}
+function assertHasNoDuplicateCommands(defaultCommands, commands) {
+	const defaultCommandKeys = defaultCommands.map(({ key, shift }) => shortcutLabel(key, shift));
+	const duplicateKeys = commands.map(({ key, shift }) => shortcutLabel(key, shift)).filter((key) => defaultCommandKeys.includes(key));
+	const invalidCommandKeys = commands.filter(({ key }) => key.length > 1).map(({ key, shift }) => shortcutLabel(key, shift));
+	if (invalidCommandKeys.length > 0) throw new Error(`Invalid commands: ${invalidCommandKeys.join(", ")}`);
+	if (duplicateKeys.length > 0) throw new Error(`Duplicate commands: ${duplicateKeys.join(", ")}`);
+}
+//#endregion
+export { setupInteractiveMode };

package/dist/node/constants.js

@@ -0,0 +1,4 @@
+//#region src/node/constants.ts
+const UNSUPPORTED_OPTION_DESCRIPTION = "This option is not supported by Rollipop.";
+//#endregion
+export { UNSUPPORTED_OPTION_DESCRIPTION };

package/dist/node/logger.js

@@ -0,0 +1,5 @@
+import { Logger } from "../common/logger.js";
+//#region src/node/logger.ts
+const logger = new Logger("cli");
+//#endregion
+export { logger };

package/dist/node/types.d.ts

@@ -0,0 +1,23 @@
+//#region src/node/types.d.ts
+interface CommandDefinition<Options> {
+  name: string;
+  description: string;
+  helpText?: string;
+  options?: CommandOptionDefinition[];
+  action: CommandAction<Options>;
+}
+interface CommandAction<Options> {
+  (this: CommandContext, options: Options): Promise<void>;
+}
+interface CommandOptionDefinition<T = any> {
+  name: string;
+  description: string;
+  required?: boolean;
+  default?: T;
+  parse?: (value: string) => T;
+}
+interface CommandContext {
+  platforms: string[];
+}
+//#endregion
+export { CommandDefinition };

package/dist/node/utils.js

@@ -0,0 +1,23 @@
+import { logger } from "./logger.js";
+import path from "node:path";
+//#region src/node/utils.ts
+function parseBoolean(value) {
+	return value === "true" || value === "1";
+}
+function resolvePath(value) {
+	return path.resolve(value);
+}
+function withErrorHandler(action) {
+	return async function(args) {
+		try {
+			await action.call(this, args);
+		} catch (reason) {
+			logger.error("An error occurred while executing the command");
+			logger.error(`Reason: ${reason instanceof Error ? reason.message : String(reason)}`);
+			logger.debug(reason);
+			process.exit(1);
+		}
+	};
+}
+//#endregion
+export { parseBoolean, resolvePath, withErrorHandler };

package/dist/package.js

@@ -0,0 +1,4 @@
+//#region package.json
+var version = "1.0.0-alpha.23";
+//#endregion
+export { version };

package/dist/runtime.js

@@ -1,4 +1,4 @@
-import "./chunk-DXpK5_cz.js";
+import "./chunk-DJV587Yu.js";
 //#region src/runtime.ts
 function setCustomHMRHandler(_) {
 	if (__DEV__) {

package/dist/server/bundle.d.ts

@@ -0,0 +1,12 @@
+import { BasicSourceMapConsumer, IndexedSourceMapConsumer } from "source-map";
+
+//#region src/server/bundle.d.ts
+type SourceMapConsumerType = BasicSourceMapConsumer | IndexedSourceMapConsumer;
+interface BundleStore {
+  bundleFilePath: string;
+  code: string;
+  sourceMap: string | undefined;
+  sourceMapConsumer: Promise<SourceMapConsumerType> | undefined;
+}
+//#endregion
+export { BundleStore };

package/dist/server/bundle.js

@@ -0,0 +1,55 @@
+import { logger } from "../logger.js";
+import { getSharedDataPath } from "../core/fs/data.js";
+import fs from "node:fs";
+import path from "node:path";
+import { SourceMapConsumer } from "source-map";
+//#region src/server/bundle.ts
+var FileSystemBundleStore = class {
+	bundleFilePath;
+	_sourceMap;
+	lazySourceMapConsumer = null;
+	holder;
+	constructor(projectRoot, id, code, sourceMap) {
+		const sharedDataPath = getSharedDataPath(projectRoot);
+		const bundlesPath = path.join(sharedDataPath, "bundles");
+		const bundleFilePath = path.join(bundlesPath, `${id}.bundle`);
+		if (!fs.existsSync(bundlesPath)) fs.mkdirSync(bundlesPath, { recursive: true });
+		fs.writeFileSync(bundleFilePath, code, { encoding: "utf-8" });
+		const stats = fs.statSync(bundleFilePath);
+		this.bundleFilePath = bundleFilePath;
+		this._sourceMap = sourceMap;
+		this.holder = {
+			code,
+			mtimeMs: stats.mtimeMs
+		};
+		logger.debug(`File system bundle created at ${bundleFilePath}`);
+	}
+	update() {
+		const code = fs.readFileSync(this.bundleFilePath, { encoding: "utf-8" });
+		const stats = fs.statSync(this.bundleFilePath);
+		this.holder = {
+			code,
+			mtimeMs: stats.mtimeMs
+		};
+	}
+	get code() {
+		if (this.isStale()) {
+			logger.info("File system bundle is stale, updating...");
+			this.update();
+		} else logger.trace("File system bundle is up to date");
+		return this.holder.code;
+	}
+	get sourceMap() {
+		return this.isStale() ? void 0 : this._sourceMap;
+	}
+	get sourceMapConsumer() {
+		if (this.isStale() || this._sourceMap == null) return;
+		if (this.lazySourceMapConsumer == null) this.lazySourceMapConsumer = new SourceMapConsumer(this._sourceMap);
+		return this.lazySourceMapConsumer;
+	}
+	isStale() {
+		return this.holder.mtimeMs !== fs.statSync(this.bundleFilePath).mtimeMs;
+	}
+};
+//#endregion
+export { FileSystemBundleStore };

package/dist/server/bundler-pool.d.ts

@@ -0,0 +1,51 @@
+import { BuildOptions, DevEngine } from "../core/types.js";
+import { BundleStore } from "./bundle.js";
+import { ServerEventBus } from "./events/event-bus.js";
+import { ServerOptions } from "./types.js";
+import { ResolvedConfig } from "../config/defaults.js";
+//#region src/server/bundler-pool.d.ts
+interface DevServerOptions {
+  host: string;
+  port: number;
+}
+interface BundlerDevEngineOptions {
+  server: DevServerOptions;
+}
+type BundlerStatus = 'idle' | 'building' | 'build-done' | 'build-failed';
+declare class BundlerDevEngine {
+  private readonly options;
+  private readonly config;
+  private readonly buildOptions;
+  private readonly eventBus;
+  private readonly initializeHandle;
+  private readonly isHmrEnabled;
+  private readonly _id;
+  private bundleStore;
+  private buildFailedError;
+  private _devEngine;
+  private _state;
+  private _status;
+  constructor(options: BundlerDevEngineOptions, config: ResolvedConfig, buildOptions: BuildOptions, eventBus: ServerEventBus);
+  get id(): string;
+  /** Snapshot of the bundler's current lifecycle state. */
+  get status(): BundlerStatus;
+  get devEngine(): DevEngine;
+  get ensureInitialized(): Promise<void>;
+  private initialize;
+  private updateBundleStore;
+  getBundle(): Promise<BundleStore>;
+}
+declare class BundlerPool {
+  private readonly config;
+  private readonly resolvedServerOptions;
+  private readonly eventBus;
+  private static readonly instances;
+  constructor(config: ResolvedConfig, resolvedServerOptions: Required<Pick<ServerOptions, 'host' | 'port'>>, eventBus: ServerEventBus);
+  get(bundleName: string, buildOptions: Pick<BuildOptions, 'platform' | 'dev'>): BundlerDevEngine;
+  /**
+   * Look up a cached bundler by the id carried as `bundlerId` in events such as `bundle_build_done`. Returns `undefined` when no instance with that id has been created yet.
+   */
+  getInstanceById(id: string): BundlerDevEngine | undefined;
+}
+//#endregion
+export { BundlerPool };

package/dist/server/bundler-pool.js

@@ -0,0 +1,197 @@
+import { bindReporter } from "../utils/config.js";
+import { logger } from "./logger.js";
+import { getBaseBundleName } from "../utils/bundle.js";
+import { normalizeRolldownError } from "../utils/errors.js";
+import { taskHandler } from "../utils/promise.js";
+import { FileSystemBundleStore } from "./bundle.js";
+import { Bundler } from "../core/bundler.js";
+import { invariant } from "es-toolkit";
+//#region src/server/bundler-pool.ts
+var BundlerDevEngine = class {
+	options;
+	config;
+	buildOptions;
+	eventBus;
+	initializeHandle;
+	isHmrEnabled;
+	_id;
+	bundleStore = null;
+	buildFailedError = null;
+	_devEngine = null;
+	_state = "idle";
+	_status = "idle";
+	constructor(options, config, buildOptions, eventBus) {
+		this.options = options;
+		this.config = config;
+		this.buildOptions = buildOptions;
+		this.eventBus = eventBus;
+		this._id = Bundler.createId(config, buildOptions);
+		this.initializeHandle = taskHandler();
+		this.isHmrEnabled = Boolean(buildOptions.dev && config.devMode.hmr);
+		this.initialize();
+	}
+	get id() {
+		return this._id;
+	}
+	/** Snapshot of the bundler's current lifecycle state. */
+	get status() {
+		return this._status;
+	}
+	get devEngine() {
+		invariant(this._devEngine, "DevEngine is not initialized");
+		return this._devEngine;
+	}
+	get ensureInitialized() {
+		return this.initializeHandle.task;
+	}
+	async initialize() {
+		if (this._state !== "idle" || this._devEngine != null) return this;
+		this._state = "initializing";
+		let pendingBuildDoneEvent = null;
+		const emitReportableEvent = (event) => {
+			switch (event.type) {
+				case "bundle_build_started":
+					this._status = "building";
+					break;
+				case "bundle_build_done":
+					this._status = "build-done";
+					break;
+				case "bundle_build_failed":
+					this._status = "build-failed";
+					break;
+			}
+			this.eventBus.emit({
+				...event,
+				bundlerId: this.id
+			});
+		};
+		const config = bindReporter(this.config, (event) => {
+			if (event.type === "bundle_build_started") pendingBuildDoneEvent = null;
+			if (event.type === "bundle_build_done") {
+				pendingBuildDoneEvent = event;
+				return;
+			}
+			emitReportableEvent(event);
+		});
+		const devEngine = await Bundler.devEngine(config, this.buildOptions, {
+			host: this.options.server.host,
+			port: this.options.server.port,
+			onHmrUpdates: (errorOrResult) => {
+				if (!this.isHmrEnabled) return;
+				if (errorOrResult instanceof Error) {
+					logger.error("Failed to handle HMR updates", {
+						bundlerId: this.id,
+						error: errorOrResult
+					});
+					const event = {
+						type: "hmr_failed",
+						error: normalizeRolldownError(errorOrResult)
+					};
+					this.eventBus.emit({
+						...event,
+						bundlerId: this.id
+					});
+				} else {
+					logger.trace("Detected changed files", {
+						bundlerId: this.id,
+						changedFiles: errorOrResult.changedFiles
+					});
+					this.eventBus.emit({
+						bundlerId: this.id,
+						type: "hmr_updates",
+						updates: errorOrResult.updates
+					});
+				}
+			},
+			onOutput: (errorOrResult) => {
+				if (errorOrResult instanceof Error) {
+					pendingBuildDoneEvent = null;
+					const normalizedError = normalizeRolldownError(errorOrResult);
+					logger.trace("onOutput", { bundlerId: this.id });
+					logger.error(errorOrResult.message);
+					this.buildFailedError = normalizedError;
+					const event = {
+						type: "bundle_build_failed",
+						error: normalizedError
+					};
+					this._status = "build-failed";
+					this.eventBus.emit({
+						...event,
+						bundlerId: this.id
+					});
+				} else {
+					const output = errorOrResult.output[0];
+					const bundleStore = this.updateBundleStore(output);
+					this.buildFailedError = null;
+					logger.debug("Build completed", {
+						bundlerId: this.id,
+						bundleName: output.name,
+						bundleFilePath: bundleStore.bundleFilePath
+					});
+					if (pendingBuildDoneEvent != null) {
+						emitReportableEvent({
+							...pendingBuildDoneEvent,
+							bundleFilePath: bundleStore.bundleFilePath
+						});
+						pendingBuildDoneEvent = null;
+					}
+				}
+			},
+			rebuildStrategy: "auto"
+		});
+		await devEngine.run();
+		this._devEngine = devEngine;
+		this._state = "ready";
+		this.initializeHandle.resolve();
+	}
+	updateBundleStore(output) {
+		this.bundleStore = new FileSystemBundleStore(this.config.root, this.id, output.code, output.map?.toString());
+		return this.bundleStore;
+	}
+	async getBundle() {
+		await this.ensureInitialized;
+		const state = await this.devEngine.getBundleState();
+		logger.debug("Bundle state", {
+			bundlerId: this.id,
+			state
+		});
+		if (state.lastFullBuildFailed) throw new Error(this.buildFailedError?.message ?? "Build failed");
+		if (state.hasStaleOutput || this.bundleStore == null) await this.devEngine.ensureLatestBuildOutput();
+		invariant(this.bundleStore, "Bundle is not available");
+		return this.bundleStore;
+	}
+};
+var BundlerPool = class BundlerPool {
+	config;
+	resolvedServerOptions;
+	eventBus;
+	static instances = /* @__PURE__ */ new Map();
+	constructor(config, resolvedServerOptions, eventBus) {
+		this.config = config;
+		this.resolvedServerOptions = resolvedServerOptions;
+		this.eventBus = eventBus;
+	}
+	get(bundleName, buildOptions) {
+		const key = `${getBaseBundleName(bundleName)}-${Bundler.createId(this.config, buildOptions)}`;
+		const instance = BundlerPool.instances.get(key);
+		if (instance) return instance;
+		else {
+			logger.debug("Preparing new bundler instance", {
+				bundleName,
+				key
+			});
+			const instance = new BundlerDevEngine({ server: this.resolvedServerOptions }, this.config, buildOptions, this.eventBus);
+			logger.debug("Setting new bundler instance", { key });
+			BundlerPool.instances.set(key, instance);
+			return instance;
+		}
+	}
+	/**
+	* Look up a cached bundler by the id carried as `bundlerId` in events such as `bundle_build_done`. Returns `undefined` when no instance with that id has been created yet.
+	*/
+	getInstanceById(id) {
+		for (const instance of BundlerPool.instances.values()) if (instance.id === id) return instance;
+	}
+};
+//#endregion
+export { BundlerPool };

package/dist/server/common/schema.js

@@ -0,0 +1,19 @@
+import { asConst } from "json-schema-to-ts";
+import Ajv from "ajv";
+//#region src/server/common/schema.ts
+const bundleRequestSchema = asConst({
+	type: "object",
+	properties: {
+		platform: { type: "string" },
+		app: { type: "string" },
+		dev: { type: "boolean" },
+		minify: { type: "boolean" },
+		runModule: { type: "boolean" },
+		inlineSourceMap: { type: "boolean" },
+		modulesOnly: { type: "boolean" }
+	},
+	required: ["platform"]
+});
+new Ajv().compile(bundleRequestSchema);
+//#endregion
+export { bundleRequestSchema };

package/dist/server/constants.d.ts

@@ -0,0 +1,6 @@
+//#region src/server/constants.d.ts
+declare const DEFAULT_PORT = 8081;
+declare const DEFAULT_HOST = "localhost";
+declare const DEV_SERVER_ASSET_PATH = "assets";
+//#endregion
+export { DEFAULT_HOST, DEFAULT_PORT, DEV_SERVER_ASSET_PATH };

package/dist/server/constants.js

@@ -0,0 +1,6 @@
+//#region src/server/constants.ts
+const DEFAULT_PORT = 8081;
+const DEFAULT_HOST = "localhost";
+const DEV_SERVER_ASSET_PATH = "assets";
+//#endregion
+export { DEFAULT_HOST, DEFAULT_PORT, DEV_SERVER_ASSET_PATH };

package/dist/server/create-dev-server.d.ts

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