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

package/dist/common/code.js

@@ -0,0 +1,21 @@
+import { GLOBAL_IDENTIFIER } from "../constants.js";
+import { indent } from "../utils/string.js";
+import dedent from "dedent";
+//#region src/common/code.ts
+function asLiteral(value) {
+	return JSON.stringify(value);
+}
+function nodeEnvironment(dev) {
+	return dev ? "development" : "production";
+}
+function iife(body, path = "<unknown>") {
+	const bodyPlaceholder = "__BODY__";
+	return dedent`
+  // ${path}
+  (function (global) {
+  ${bodyPlaceholder}
+  })(${GLOBAL_IDENTIFIER});
+  `.replace(bodyPlaceholder, indent(body, 1));
+}
+//#endregion
+export { asLiteral, iife, nodeEnvironment };

package/dist/common/constants.js

@@ -0,0 +1,5 @@
+//#region src/common/constants.ts
+const DEBUG_KEY = "rollipop";
+const SHARED_DATA_PATH = ".rollipop";
+//#endregion
+export { DEBUG_KEY, SHARED_DATA_PATH };

package/dist/common/env.js

@@ -0,0 +1,33 @@
+import "./constants.js";
+//#region src/common/env.ts
+const TRUTHY_VALUES = [
+	"yes",
+	"on",
+	"true",
+	"enabled"
+];
+const FALSY_VALUES = [
+	"no",
+	"off",
+	"false",
+	"disabled"
+];
+function parseDebugKeys() {
+	return Object.keys(process.env).filter((key) => /^debug_/i.test(key)).reduce((acc, key) => {
+		const prop = key.slice(6).toLowerCase().replace(/_([a-z])/g, (_, key) => key.toUpperCase());
+		let value = process.env[key];
+		const lowerCase = typeof value === "string" ? value.toLowerCase() : value.toString();
+		if (TRUTHY_VALUES.includes(lowerCase)) value = true;
+		else if (FALSY_VALUES.includes(lowerCase)) value = false;
+		else value = Boolean(Number(value));
+		acc[prop] = value;
+		return acc;
+	}, {});
+}
+let debugKeys = null;
+function isDebugEnabled() {
+	if (debugKeys == null) debugKeys = parseDebugKeys();
+	return debugKeys["rollipop"] ?? false;
+}
+//#endregion
+export { isDebugEnabled };

package/dist/common/logger.d.ts

@@ -0,0 +1,34 @@
+import { ChalkInstance } from "chalk";
+
+//#region src/common/logger.d.ts
+declare class Logger {
+  private readonly scope?;
+  private static blocked;
+  private static queuedMessages;
+  static Colors: {
+    trace: ChalkInstance;
+    debug: ChalkInstance;
+    log: ChalkInstance;
+    info: ChalkInstance;
+    warn: ChalkInstance;
+    error: ChalkInstance;
+  };
+  private format;
+  private debugEnabled;
+  static block(): void;
+  static unblock(flush?: boolean): void;
+  constructor(scope?: string | undefined);
+  getFormat(): string;
+  setFormat(format: string): void;
+  private getTimestamp;
+  private print;
+  trace(...args: unknown[]): void;
+  debug(...args: unknown[]): void;
+  log(...args: unknown[]): void;
+  info(...args: unknown[]): void;
+  warn(...args: unknown[]): void;
+  error(...args: unknown[]): void;
+  child(scope: string): Logger;
+}
+//#endregion
+export { Logger };

package/dist/common/logger.js

@@ -0,0 +1,82 @@
+import { isDebugEnabled } from "./env.js";
+import { invariant } from "es-toolkit";
+import chalk from "chalk";
+import dayjs from "dayjs";
+//#region src/common/logger.ts
+var Logger = class Logger {
+	scope;
+	static blocked = false;
+	static queuedMessages = [];
+	static Colors = {
+		trace: chalk.gray,
+		debug: chalk.blue,
+		log: chalk.green,
+		info: chalk.cyan,
+		warn: chalk.yellow,
+		error: chalk.red
+	};
+	format = "HH:mm:ss.SSS";
+	debugEnabled;
+	static block() {
+		this.blocked = true;
+	}
+	static unblock(flush = true) {
+		this.blocked = false;
+		if (flush) for (const args of Logger.queuedMessages) console.log(...args);
+		Logger.queuedMessages.length = 0;
+	}
+	constructor(scope) {
+		this.scope = scope;
+		this.debugEnabled = isDebugEnabled();
+	}
+	getFormat() {
+		return this.format;
+	}
+	setFormat(format) {
+		this.format = format;
+	}
+	getTimestamp() {
+		return dayjs().format(this.getFormat());
+	}
+	print(logLevel, ...args) {
+		const timestamp = chalk.gray(this.getTimestamp());
+		const level = Logger.Colors[logLevel](logLevel);
+		if (this.scope) args = [
+			timestamp,
+			level,
+			chalk.magenta(this.scope),
+			...args
+		];
+		else args = [
+			timestamp,
+			level,
+			...args
+		];
+		if (Logger.blocked) Logger.queuedMessages.push(args);
+		else console.log(...args);
+	}
+	trace(...args) {
+		this.debugEnabled && this.print("trace", ...args);
+	}
+	debug(...args) {
+		this.debugEnabled && this.print("debug", ...args);
+	}
+	log(...args) {
+		this.print("log", ...args);
+	}
+	info(...args) {
+		this.print("info", ...args);
+	}
+	warn(...args) {
+		this.print("warn", ...args);
+	}
+	error(...args) {
+		this.print("error", ...args);
+	}
+	child(scope) {
+		invariant(this.scope, "Logger must have a scope to create a child logger");
+		return new Logger(`${this.scope}:${scope}`);
+	}
+};
+//#endregion
+export { Logger };

package/dist/common/logo.js

@@ -0,0 +1,54 @@
+import chalk from "chalk";
+import gradient from "gradient-string";
+//#region src/common/logo.ts
+const CANDY = `
+    _....._
+  .' _..._ '.
+ / /\`  __ \`\\ \\
+; ;  /\`  \\  | ;
+| | |  (_/  ; |
+; ;  \\_  _.' .;
+ \\ '.  \`\` _.'/
+  '._\`"'"\`_.'`;
+const STICK = `
+    /  /\`\`
+   /  /
+  /__/`;
+const DESCRIPTIONS = [
+	"Rollipop",
+	"Modern build toolkit for React Native",
+	"Powered by Rolldown"
+];
+const PRIMARY_COLOR = "#42A5F5";
+const BASE_GRADIENT_COLORS = [PRIMARY_COLOR, "#BBDEFB"];
+const PADDING = 20;
+function printLogo() {
+	let maxLogoWidth = 0;
+	const padding = " ".repeat(PADDING);
+	const gradientColors = [...BASE_GRADIENT_COLORS];
+	const styledCandy = CANDY.split("\n").map((line) => {
+		maxLogoWidth = Math.max(line.length, maxLogoWidth);
+		return gradient(gradientColors.reverse())(line);
+	}).join("\n") + STICK;
+	console.log(styledCandy.split("\n").map((line) => padding + line).join("\n"));
+	console.log("");
+	DESCRIPTIONS.forEach((description, index) => {
+		const descriptionHalfLength = description.length / 2;
+		const logoHalfWidth = maxLogoWidth / 2;
+		const padding = " ".repeat(PADDING - descriptionHalfLength + logoHalfWidth);
+		if (index === 0) console.log(padding + chalk.bold.hex(PRIMARY_COLOR)(description));
+		else console.log(padding + description);
+	});
+	console.log("");
+}
+let _printed = false;
+const Logo = {
+	print: printLogo,
+	printOnce: () => {
+		if (_printed) return;
+		_printed = true;
+		printLogo();
+	}
+};
+//#endregion
+export { Logo };

package/dist/common/progress-bar.js

@@ -0,0 +1,167 @@
+import { StreamManager, ellipsisLeft } from "../utils/terminal.js";
+import { range, throttle } from "es-toolkit";
+import chalk from "chalk";
+//#region src/common/progress-bar.ts
+const BAR_LENGTH = 25;
+const BLOCK_CHAR = "█";
+const idleRenderer = { render(_state, context) {
+	return `  ${chalk.gray("Waiting...")} ${chalk.gray(context.label)}\n`;
+} };
+const runningRenderer = { render(state, context) {
+	const { label, current, total, columns } = context;
+	const unknownTotal = total === 0;
+	const progress = unknownTotal ? 0 : current / total * 100;
+	const width = unknownTotal ? 0 : progress * (BAR_LENGTH / 100);
+	const bg = chalk.white(BLOCK_CHAR);
+	const fg = chalk.cyan(BLOCK_CHAR);
+	const bar = range(BAR_LENGTH).map((n) => n < width ? fg : bg).join("");
+	const progressLabel = unknownTotal ? chalk.gray("(calculating...)") : `(${progress.toFixed(2)}%)`;
+	const moduleCountLabel = unknownTotal ? `${current} modules` : `${current}/${total} modules`;
+	return `${[
+		chalk.cyan("●"),
+		bar,
+		progressLabel,
+		chalk.gray(moduleCountLabel),
+		chalk.gray(label)
+	].join(" ")}\n${state.moduleId ? "  " + chalk.grey(ellipsisLeft(state.moduleId, columns - 10)) : ""}`;
+} };
+const completedRenderer = { render(state, context) {
+	if (state.hasErrors) return `${chalk.red("✘")} Build failed ${chalk.gray(context.label)}`;
+	else {
+		const icon = chalk.green("✔");
+		const durationInSeconds = (state.duration / 1e3).toFixed(2);
+		return `${`${icon} Build completed ${chalk.gray(context.label)}`}\n${chalk.grey(`  Built in ${durationInSeconds}s (${context.current}/${context.total} modules)`)}`;
+	}
+} };
+const hmrCompletedRenderer = { render(state, context) {
+	const icon = chalk.green("✔");
+	const count = chalk.yellow(`(x${state.count})`);
+	const moduleId = chalk.gray(ellipsisLeft(state.moduleId, context.columns - 4));
+	return `${icon} HMR Updated ${chalk.gray(context.label)} ${count}\n  ${moduleId}`;
+} };
+var ProgressBarRenderer = class {
+	renderers = {
+		idle: idleRenderer,
+		running: runningRenderer,
+		completed: completedRenderer,
+		"hmr-completed": hmrCompletedRenderer
+	};
+	render(state, context) {
+		return this.renderers[state.type].render(state, context);
+	}
+};
+var ProgressBar = class {
+	columns = (process.stderr.columns || 80) - 2;
+	renderer;
+	label;
+	state = { type: "idle" };
+	current = 0;
+	total;
+	stale = false;
+	constructor(options) {
+		this.total = options.total;
+		this.label = options.label;
+		this.renderer = options.renderer ?? new ProgressBarRenderer();
+	}
+	get done() {
+		return this.state.type === "completed" || this.state.type === "hmr-completed";
+	}
+	setCurrent(current) {
+		this.current = current;
+		this.stale = true;
+		return this;
+	}
+	setTotal(total) {
+		this.total = total;
+		this.stale = true;
+		return this;
+	}
+	start() {
+		this.state = { type: "running" };
+		this.stale = true;
+		return this;
+	}
+	setModuleId(moduleId) {
+		if (this.state.type !== "running") return this;
+		this.state = {
+			type: "running",
+			moduleId
+		};
+		this.stale = true;
+		return this;
+	}
+	complete(duration, hasErrors = false) {
+		this.state = {
+			type: "completed",
+			duration,
+			hasErrors
+		};
+		this.stale = true;
+		return this;
+	}
+	completeHmr(moduleId, count) {
+		this.state = {
+			type: "hmr-completed",
+			count,
+			moduleId
+		};
+		this.stale = true;
+		return this;
+	}
+	render() {
+		this.stale = false;
+		const context = {
+			label: this.label,
+			current: this.current,
+			total: this.total,
+			columns: this.columns
+		};
+		return this.renderer.render(this.state, context);
+	}
+};
+var ProgressBarRenderManager = class ProgressBarRenderManager {
+	static instance = null;
+	streamManager = new StreamManager();
+	progressBars = /* @__PURE__ */ new Map();
+	throttledRender;
+	static getInstance() {
+		if (!ProgressBarRenderManager.instance) ProgressBarRenderManager.instance = new ProgressBarRenderManager();
+		return ProgressBarRenderManager.instance;
+	}
+	constructor() {
+		this.throttledRender = throttle(this._render.bind(this), 50);
+	}
+	_render() {
+		const renderedLines = Array.from(this.progressBars.values().filter((progressBar) => progressBar.stale).map((progressBar) => progressBar.render()));
+		if (renderedLines.length > 0) this.streamManager.render(renderedLines.join("\n\n"));
+	}
+	register(key, options) {
+		const progressBar = this.progressBars.get(key);
+		if (progressBar == null) {
+			const newProgressBar = new ProgressBar(options);
+			this.progressBars.set(key, newProgressBar);
+			return newProgressBar;
+		}
+		return progressBar;
+	}
+	start() {
+		console.log();
+		this.streamManager.listen();
+		this._render();
+	}
+	render() {
+		this.throttledRender();
+	}
+	release() {
+		if (this.progressBars.values().every((progressBar) => progressBar.done)) {
+			this._render();
+			this.streamManager.done();
+			console.log();
+		}
+	}
+	clear() {
+		this.streamManager.clear();
+	}
+};
+//#endregion
+export { ProgressBarRenderManager };

package/dist/common/transformer.js

@@ -0,0 +1,13 @@
+import transform from "fast-flow-transform";
+//#region src/common/transformer.ts
+async function stripFlowTypes(id, code) {
+	return await transform({
+		filename: id,
+		source: code,
+		sourcemap: true,
+		dialect: "flow",
+		format: "pretty"
+	});
+}
+//#endregion
+export { stripFlowTypes };

package/dist/common/types.d.ts

@@ -0,0 +1,10 @@
+//#region src/common/types.d.ts
+interface FileStorageData {
+  build: {
+    [buildHash: string]: {
+      totalModules: number;
+    };
+  };
+}
+//#endregion
+export { FileStorageData };

package/dist/config/compose-override.js

@@ -0,0 +1,18 @@
+import { merge } from "es-toolkit";
+//#region src/config/compose-override.ts
+async function applyOverrideRolldownOptions(override, rolldownOptions) {
+	if (typeof override === "function") return await override(rolldownOptions);
+	return {
+		input: merge(rolldownOptions.input ?? {}, override.input ?? {}),
+		output: merge(rolldownOptions.output ?? {}, override.output ?? {})
+	};
+}
+function composeOverrideRolldownOptions(target, source) {
+	if (source == null) return target;
+	if (target == null) return source;
+	return async (rolldownOptions) => {
+		return await applyOverrideRolldownOptions(source, await applyOverrideRolldownOptions(target, rolldownOptions));
+	};
+}
+//#endregion
+export { applyOverrideRolldownOptions, composeOverrideRolldownOptions };

package/dist/config/defaults.d.ts

@@ -0,0 +1,74 @@
+import { Reporter } from "../types.js";
+import { Config, DevModeConfig, OptimizationConfig, ReactNativeConfig } from "./types.js";
+import { PluginFlattenConfig } from "./merge-config.js";
+
+//#region src/config/defaults.d.ts
+declare function getDefaultConfig(projectRoot: string, mode?: Config['mode']): Promise<{
+  root: string;
+  mode: "development" | "production";
+  entry: string;
+  resolver: {
+    sourceExtensions: string[];
+    assetExtensions: string[];
+    mainFields: string[];
+    aliasFields: string[][];
+    conditionNames: string[];
+    preferNativePlatform: true;
+    symlinks: true;
+  };
+  transformer: {
+    flow: {
+      filter: {
+        id: RegExp;
+        code: RegExp;
+      };
+    };
+  };
+  serializer: {
+    prelude: string[];
+    polyfills: {
+      type: "iife";
+      code: string;
+    }[];
+  };
+  watcher: {
+    skipWrite: true;
+    useDebounce: true;
+    debounceDuration: number;
+  };
+  optimization: {
+    treeshake: NonNullable<OptimizationConfig["treeshake"]>;
+  };
+  reactNative: {
+    reactNativePath: string;
+    codegen: {
+      /**
+       * @see {@link https://github.com/facebook/react-native/blob/v0.83.1/packages/react-native-babel-preset/src/configs/main.js#L78}
+       */
+      filter: {
+        code: RegExp;
+      };
+    };
+    assetRegistryPath: NonNullable<NonNullable<ReactNativeConfig>["assetRegistryPath"]>;
+    hmrClientPath: NonNullable<NonNullable<ReactNativeConfig>["hmrClientPath"]>;
+    globalIdentifiers: string[];
+  };
+  devMode: {
+    hmr: NonNullable<DevModeConfig["hmr"]>;
+  };
+  reporter: Reporter;
+  terminal: {
+    status: "none" | "compat" | "progress" | undefined;
+  };
+  envDir: string;
+  envFile: string;
+  envPrefix: string;
+  runtimeTarget: "hermes-v1";
+  experimental: {
+    nativeTransformPipeline: boolean;
+  };
+}>;
+type DefaultConfig = Awaited<ReturnType<typeof getDefaultConfig>>;
+type ResolvedConfig = DefaultConfig & PluginFlattenConfig;
+//#endregion
+export { DefaultConfig, ResolvedConfig, getDefaultConfig };

package/dist/config/defaults.js

@@ -0,0 +1,74 @@
+import { isDebugEnabled } from "../common/env.js";
+import { stripFlowTypes } from "../common/transformer.js";
+import { DEFAULT_ASSET_EXTENSIONS, DEFAULT_ASSET_REGISTRY_PATH, DEFAULT_ENV_FILE, DEFAULT_ENV_PREFIX, DEFAULT_HMR_CLIENT_PATH, DEFAULT_REACT_NATIVE_GLOBAL_IDENTIFIERS, DEFAULT_RESOLVER_ALIAS_FIELDS, DEFAULT_RESOLVER_CONDITION_NAMES, DEFAULT_RESOLVER_MAIN_FIELDS, DEFAULT_RUNTIME_TARGET, DEFAULT_SOURCE_EXTENSIONS } from "../constants.js";
+import { getInitializeCorePath, getPolyfillScriptPaths } from "../internal/react-native.js";
+import { resolvePackagePath } from "../utils/node-resolve.js";
+import { ClientLogReporter } from "../utils/reporters.js";
+import fs from "node:fs";
+//#region src/config/defaults.ts
+async function getDefaultConfig(projectRoot, mode) {
+	let reactNativePath;
+	try {
+		reactNativePath = process.env.ROLLIPOP_REACT_NATIVE_PATH ?? resolvePackagePath(projectRoot, "react-native");
+	} catch {
+		throw new Error(`Could not resolve 'react-native' package path. Please check your project path.`);
+	}
+	return {
+		root: projectRoot,
+		mode: mode ?? "development",
+		entry: "index.js",
+		resolver: {
+			sourceExtensions: DEFAULT_SOURCE_EXTENSIONS,
+			assetExtensions: DEFAULT_ASSET_EXTENSIONS,
+			mainFields: DEFAULT_RESOLVER_MAIN_FIELDS,
+			aliasFields: DEFAULT_RESOLVER_ALIAS_FIELDS,
+			conditionNames: DEFAULT_RESOLVER_CONDITION_NAMES,
+			preferNativePlatform: true,
+			symlinks: true
+		},
+		transformer: { flow: { filter: {
+			id: /\.jsx?$/,
+			code: /@flow/
+		} } },
+		serializer: {
+			prelude: [getInitializeCorePath(projectRoot)],
+			polyfills: await Promise.all(getPolyfillScriptPaths(reactNativePath).map(async (path) => {
+				return {
+					type: "iife",
+					code: (await stripFlowTypes(path, fs.readFileSync(path, "utf-8"))).code
+				};
+			}))
+		},
+		watcher: {
+			skipWrite: true,
+			useDebounce: true,
+			debounceDuration: 50
+		},
+		optimization: { treeshake: true },
+		reactNative: {
+			reactNativePath,
+			codegen: { 
+			/**
+			* @see {@link https://github.com/facebook/react-native/blob/v0.83.1/packages/react-native-babel-preset/src/configs/main.js#L78}
+			*/
+filter: { code: /\bcodegenNativeComponent</ } },
+			assetRegistryPath: DEFAULT_ASSET_REGISTRY_PATH,
+			hmrClientPath: DEFAULT_HMR_CLIENT_PATH,
+			globalIdentifiers: DEFAULT_REACT_NATIVE_GLOBAL_IDENTIFIERS
+		},
+		devMode: { hmr: true },
+		reporter: new ClientLogReporter(),
+		terminal: { status: (() => {
+			if (isDebugEnabled()) return "compat";
+			if (process.stderr.isTTY) return "progress";
+			return "compat";
+		})() },
+		envDir: projectRoot,
+		envFile: DEFAULT_ENV_FILE,
+		envPrefix: DEFAULT_ENV_PREFIX,
+		runtimeTarget: DEFAULT_RUNTIME_TARGET,
+		experimental: { nativeTransformPipeline: false }
+	};
+}
+//#endregion
+export { getDefaultConfig };

package/dist/config/define-config.d.ts

@@ -0,0 +1,13 @@
+import { Config } from "./types.js";
+import { DefaultConfig } from "./defaults.js";
+
+//#region src/config/define-config.d.ts
+interface DefineConfigContext {
+  command?: string;
+  defaultConfig: DefaultConfig;
+}
+type UserConfig = Config | DynamicUserConfig;
+type DynamicUserConfig = ((context: DefineConfigContext) => Config) | ((context: DefineConfigContext) => Promise<Config>);
+declare function defineConfig(userConfig: UserConfig): UserConfig;
+//#endregion
+export { DefineConfigContext, DynamicUserConfig, UserConfig, defineConfig };

package/dist/config/define-config.js

@@ -0,0 +1,6 @@
+//#region src/config/define-config.ts
+function defineConfig(userConfig) {
+	return userConfig;
+}
+//#endregion
+export { defineConfig };

package/dist/config/index.d.ts

@@ -0,0 +1,5 @@
+import { BabelTransformConfig, CodegenConfig, Config, DevModeConfig, ExperimentalConfig, FlowConfig, HmrConfig, OptimizationConfig, PluginOption, Polyfill, PolyfillType, PolyfillWithCode, PolyfillWithPath, ReactNativeConfig, ResolverConfig, RolldownConfig, RollipopReactNativeFlowConfig, RollipopReactNativeWorkletsConfig, SerializerConfig, SwcTransformConfig, TerminalConfig, TransformRule, TransformerConfig, WatcherConfig } from "./types.js";
+import { PluginFlattenConfig, mergeConfig } from "./merge-config.js";
+import { DefaultConfig, ResolvedConfig, getDefaultConfig } from "./defaults.js";
+import { DefineConfigContext, DynamicUserConfig, UserConfig, defineConfig } from "./define-config.js";
+import { LoadConfigOptions, flattenPluginOption, invokeConfigResolved, loadConfig, resolvePluginConfig } from "./load-config.js";

package/dist/config/index.js

@@ -0,0 +1,5 @@
+import "./defaults.js";
+import "./define-config.js";
+import "./merge-config.js";
+import "./load-config.js";
+export {};

package/dist/config/load-config.d.ts

@@ -0,0 +1,19 @@
+import { Plugin, PluginConfig, ResolvedPluginConfig } from "../core/plugins/types.js";
+import { Config, PluginOption } from "./types.js";
+import { ResolvedConfig } from "./defaults.js";
+import { DefineConfigContext } from "./define-config.js";
+
+//#region src/config/load-config.d.ts
+interface LoadConfigOptions {
+  cwd?: string;
+  configFile?: string;
+  mode?: Config['mode'];
+  context?: Omit<DefineConfigContext, 'defaultConfig'>;
+}
+declare function loadConfig(options?: LoadConfigOptions): Promise<ResolvedConfig>;
+declare function flattenPluginOption(pluginOption: PluginOption): Promise<Plugin[]>;
+declare function resolvePluginConfig(baseConfig: ResolvedConfig, plugins: Plugin[]): Promise<ResolvedPluginConfig>;
+declare function resolvePluginConfig(baseConfig: Config, plugins: Plugin[]): Promise<PluginConfig>;
+declare function invokeConfigResolved(config: ResolvedConfig, plugins: Plugin[]): Promise<void>;
+//#endregion
+export { LoadConfigOptions, flattenPluginOption, invokeConfigResolved, loadConfig, resolvePluginConfig };