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

package/dist/core/plugins/utils/transform-utils.js

@@ -0,0 +1,56 @@
+import { id, include } from "@rollipop/rolldown/filter";
+//#region src/core/plugins/utils/transform-utils.ts
+const TRANSFORM_FLAGS_KEY = Symbol("transform-flags");
+const REVISION_KEY = Symbol("revision");
+function setFlag(context, id, flag, options) {
+	const revision = context.state.revision;
+	const moduleInfo = this.getModuleInfo(id);
+	if (moduleInfo) {
+		const meta = moduleInfo.meta;
+		if (options?.override) meta[TRANSFORM_FLAGS_KEY] = flag;
+		else if (isCurrentRevision(moduleInfo.meta, revision)) moduleInfo.meta[TRANSFORM_FLAGS_KEY] |= flag;
+		else meta[TRANSFORM_FLAGS_KEY] = flag;
+		meta[REVISION_KEY] = revision;
+		return moduleInfo.meta;
+	} else return {
+		[TRANSFORM_FLAGS_KEY]: flag,
+		[REVISION_KEY]: revision
+	};
+}
+function hasFlag(meta) {
+	return TRANSFORM_FLAGS_KEY in meta;
+}
+function getFlag(context, id) {
+	return getFlagFromModuleInfo(context, this.getModuleInfo(id));
+}
+function getFlagFromModuleInfo(context, moduleInfo) {
+	if (moduleInfo && isCurrentRevision(moduleInfo.meta, context.state.revision)) return moduleInfo.meta[TRANSFORM_FLAGS_KEY];
+	return 0;
+}
+function isCurrentRevision(meta, revision) {
+	return hasFlag(meta) && meta[REVISION_KEY] === revision;
+}
+function withTransformBoundary(context, plugins) {
+	return [
+		{
+			name: "rollipop:build-initializer",
+			buildStart() {
+				context.state.revision += 1;
+				context.state.latestBuildStartTime = Date.now();
+			}
+		},
+		{
+			name: "rollipop:transform-skip-json",
+			transform: {
+				order: "pre",
+				filter: [include(id(/\.json$/))],
+				handler(_code, id) {
+					return { meta: setFlag.call(this, context, id, 128) };
+				}
+			}
+		},
+		plugins
+	];
+}
+//#endregion
+export { getFlag, setFlag, withTransformBoundary };

package/dist/core/rolldown.js

@@ -0,0 +1,313 @@
+import { isDebugEnabled } from "../common/env.js";
+import { getGlobalVariables } from "../internal/react-native.js";
+import { resolveFrom, resolvePackageJson } from "../utils/node-resolve.js";
+import { CompatStatusReporter, ProgressBarStatusReporter, mergeReporters } from "../utils/reporters.js";
+import { printPluginLog } from "./plugins/context.js";
+import { applyOverrideRolldownOptions } from "../config/compose-override.js";
+import { asLiteral, iife, nodeEnvironment } from "../common/code.js";
+import { resolveHmrConfig } from "../utils/config.js";
+import { defineEnvFromObject } from "../utils/env.js";
+import { resolveRuntimeTarget } from "../utils/runtime-target.js";
+import { getBaseUrl } from "../utils/server.js";
+import { getBuildTotalModules } from "../utils/storage.js";
+import { loadEnv } from "./env.js";
+import { withTransformBoundary } from "./plugins/utils/transform-utils.js";
+import { reactNativePlugin } from "./plugins/react-native-plugin.js";
+import { preludePlugin } from "./plugins/prelude-plugin.js";
+import { babelPlugin } from "./plugins/babel-plugin.js";
+import { swcPlugin } from "./plugins/swc-plugin.js";
+import { reporterPlugin } from "./plugins/reporter-plugin.js";
+import { devServerPlugin } from "./plugins/dev-server-plugin.js";
+import "./plugins/index.js";
+import fs from "node:fs";
+import path from "node:path";
+import { invariant, isNotNil, merge } from "es-toolkit";
+//#region src/core/rolldown.ts
+async function resolveRolldownOptions(context, config, buildOptions, devEngineOptions) {
+	const cachedOptions = resolveRolldownOptions.cache.get(context.id);
+	if (cachedOptions != null) return cachedOptions;
+	const { platform, dev, cache } = buildOptions;
+	const isDevServerMode = dev && context.buildType === "serve";
+	invariant(isDevServerMode ? devEngineOptions != null : true, "devEngineOptions is required in dev server mode");
+	const env = loadEnv(config);
+	const builtInEnv = {
+		MODE: config.mode,
+		...isDevServerMode ? { BASE_URL: getBaseUrl(devEngineOptions.host, devEngineOptions.port, devEngineOptions.https) } : null
+	};
+	const hmrConfig = resolveHmrConfig(config);
+	const hmrEnabled = hmrConfig != null;
+	const { sourceExtensions, assetExtensions, preferNativePlatform, external: rolldownExternal, ...rolldownResolve } = config.resolver;
+	const { polyfills, banner: rolldownBanner, footer: rolldownFooter, postBanner: rolldownPostBanner, postFooter: rolldownPostFooter, intro: rolldownIntro, outro: rolldownOutro, shimMissingExports: rolldownShimMissingExports } = config.serializer;
+	const { flow: _flow, babel: _babel, swc: _swc, ...rolldownTransform } = config.transformer;
+	const { treeshake: rolldownTreeshake, minify: rolldownMinify, lazyBarrel: rolldownLazyBarrel, ...rolldownOptimization } = config.optimization;
+	const { globalIdentifiers: rolldownGlobalIdentifiers } = config.reactNative;
+	const { sourcemap: rolldownSourcemap, sourcemapBaseUrl: rolldownSourcemapBaseUrl, sourcemapDebugIds: rolldownSourcemapDebugIds, sourcemapIgnoreList: rolldownSourcemapIgnoreList, sourcemapPathTransform: rolldownSourcemapPathTransform } = config;
+	const userPlugins = config.plugins;
+	const mergedResolveOptions = merge({ extensions: getResolveExtensions({
+		sourceExtensions,
+		assetExtensions,
+		platform,
+		preferNativePlatform
+	}) }, rolldownResolve);
+	const mergedTransformOptions = merge({
+		cwd: config.root,
+		target: "esnext",
+		jsx: {
+			runtime: "automatic",
+			development: dev
+		},
+		define: {
+			__DEV__: asLiteral(dev),
+			"process.env.NODE_ENV": asLiteral(nodeEnvironment(dev)),
+			"process.env.DEBUG_ROLLIPOP": asLiteral(isDebugEnabled()),
+			...hmrEnabled ? null : { "import.meta.hot": "{}" },
+			...defineEnvFromObject(env),
+			...defineEnvFromObject(builtInEnv)
+		},
+		helpers: { mode: "Runtime" }
+	}, rolldownTransform);
+	const preludePluginOptions = resolvePreludePluginOptions(config);
+	const reactNativePluginOptions = await resolveReactNativePluginOptions(config, context, buildOptions);
+	const babelPluginOptions = resolveBabelPluginOptions(config, context);
+	const swcPluginOptions = resolveSwcPluginOptions(config, context);
+	const devServerPluginOptions = resolveDevServerPluginOptions(config, hmrConfig);
+	const reporterPluginOptions = resolveReporterPluginOptions(config, context, buildOptions);
+	const finalOptions = await applyDangerouslyOverrideOptionsFinalizer(config, {
+		platform: "neutral",
+		cwd: config.root,
+		input: config.entry,
+		tsconfig: config.tsconfig,
+		resolve: mergedResolveOptions,
+		transform: mergedTransformOptions,
+		treeshake: rolldownTreeshake,
+		external: rolldownExternal,
+		shimMissingExports: rolldownShimMissingExports,
+		optimization: rolldownOptimization,
+		experimental: {
+			lazyBarrel: rolldownLazyBarrel,
+			...isDevServerMode ? { devMode: hmrConfig ? { implement: hmrConfig.runtimeImplement } : false } : null
+		},
+		plugins: withTransformBoundary(context, [
+			preludePlugin(preludePluginOptions),
+			reactNativePlugin(reactNativePluginOptions),
+			babelPlugin(babelPluginOptions),
+			swcPlugin(swcPluginOptions),
+			devServerPlugin(devServerPluginOptions),
+			reporterPlugin(reporterPluginOptions),
+			userPlugins
+		]),
+		checks: {
+			/**
+			* Disable eval check because react-native uses `eval` to execute code.
+			*/
+			eval: false,
+			pluginTimings: isDebugEnabled()
+		},
+		logLevel: isDebugEnabled() ? "debug" : "info",
+		onLog(level, log, defaultHandler) {
+			const diagnostic = toBuildDiagnosticLog(log);
+			if (level === "warn") config.reporter?.update({
+				type: "build_error",
+				level,
+				log: diagnostic
+			});
+			else if (isPluginLog(log)) config.reporter?.update({
+				type: "build_log",
+				level,
+				log: diagnostic
+			});
+			if (log.code?.startsWith("PLUGIN_")) printPluginLog(level, log, log.plugin);
+			else defaultHandler(level, log);
+		},
+		id: context.id
+	}, {
+		format: "esm",
+		file: buildOptions.outfile,
+		banner: rolldownBanner,
+		footer: rolldownFooter,
+		postFooter: rolldownPostFooter,
+		postBanner: rolldownPostBanner,
+		outro: rolldownOutro,
+		intro: async (chunk) => {
+			return [
+				...getGlobalVariables(dev, context.buildType),
+				...loadPolyfills(polyfills),
+				typeof rolldownIntro === "function" ? await rolldownIntro(chunk) : rolldownIntro
+			].filter(isNotNil).join("\n");
+		},
+		minify: buildOptions.minify ?? rolldownMinify,
+		sourcemap: buildOptions.sourcemap ?? rolldownSourcemap,
+		sourcemapBaseUrl: rolldownSourcemapBaseUrl,
+		sourcemapDebugIds: rolldownSourcemapDebugIds,
+		sourcemapIgnoreList: rolldownSourcemapIgnoreList,
+		sourcemapPathTransform: rolldownSourcemapPathTransform ?? createProjectRootSourcemapPathTransform(config.root),
+		codeSplitting: false,
+		strictExecutionOrder: true,
+		globalIdentifiers: rolldownGlobalIdentifiers,
+		persistentCache: cache
+	});
+	resolveRolldownOptions.cache.set(context.id, finalOptions);
+	return finalOptions;
+}
+resolveRolldownOptions.cache = /* @__PURE__ */ new Map();
+function resolvePreludePluginOptions(config) {
+	return {
+		entryPath: config.entry,
+		modulePaths: config.serializer.prelude
+	};
+}
+async function resolveReactNativePluginOptions(config, context, buildOptions) {
+	return {
+		context,
+		projectRoot: config.root,
+		platform: buildOptions.platform,
+		preferNativePlatform: config.resolver.preferNativePlatform,
+		buildType: context.buildType,
+		assetsDir: buildOptions.assetsDir,
+		assetExtensions: config.resolver.assetExtensions,
+		assetRegistryPath: await resolveAssetRegistryPath(config),
+		flowFilter: config.transformer.flow?.filter ?? [],
+		codegenFilter: config.reactNative.codegen?.filter ?? [],
+		builtinPluginConfig: resolveReactNativeBuiltinPluginConfig(config)
+	};
+}
+async function resolveAssetRegistryPath(config) {
+	const { assetRegistryPath } = config.reactNative;
+	const path = typeof assetRegistryPath === "function" ? await assetRegistryPath(config.root) : assetRegistryPath;
+	return resolveFrom(config.root, path);
+}
+function resolveReactNativeBuiltinPluginConfig(config) {
+	if (!config.experimental?.nativeTransformPipeline) return null;
+	return {
+		envName: config.mode,
+		runtimeTarget: resolveRuntimeTarget(config.runtimeTarget),
+		flow: config.experimental.flow,
+		worklets: resolveWorkletsConfig(config)
+	};
+}
+function resolveWorkletsConfig(config) {
+	const { worklets } = config.experimental ?? {};
+	if (worklets == null) return;
+	return merge({
+		isRelease: config.mode === "production",
+		pluginVersion: resolvePackageJson(config.root, "react-native-worklets")?.version
+	}, worklets);
+}
+function resolveBabelPluginOptions(config, context) {
+	return {
+		context,
+		useNativeTransformPipeline: config.experimental?.nativeTransformPipeline,
+		transformConfig: config.transformer.babel
+	};
+}
+function resolveSwcPluginOptions(config, context) {
+	return {
+		context,
+		useNativeTransformPipeline: config.experimental?.nativeTransformPipeline,
+		runtimeTarget: config.runtimeTarget,
+		transformConfig: config.transformer.swc
+	};
+}
+function resolveDevServerPluginOptions(config, hmrConfig) {
+	return {
+		cwd: config.root,
+		hmrClientPath: config.reactNative.hmrClientPath,
+		hmrConfig
+	};
+}
+function resolveReporterPluginOptions(config, context, buildOptions) {
+	const statusReporter = createStatusReporter(config, context, buildOptions);
+	return {
+		initialTotalModules: getBuildTotalModules(context.storage, context.id),
+		reporter: mergeReporters([statusReporter, config.reporter].filter(isNotNil))
+	};
+}
+function createStatusReporter(config, context, buildOptions) {
+	switch (config.terminal.status) {
+		case "compat": return new CompatStatusReporter();
+		case "progress": return new ProgressBarStatusReporter(config.root, context.id, `[${buildOptions.platform}, ${buildOptions.dev ? "dev" : "prod"}]`, getBuildTotalModules(context.storage, context.id));
+	}
+}
+function getResolveExtensions({ platform, sourceExtensions, assetExtensions, preferNativePlatform }) {
+	const supportedExtensions = [...sourceExtensions, ...assetExtensions];
+	return [...[platform, preferNativePlatform ? "native" : null].filter(isNotNil).map((platform) => {
+		return supportedExtensions.map((extension) => `.${platform}.${extension}`);
+	}), ...supportedExtensions.map((extension) => `.${extension}`)].flat();
+}
+/**
+* Default sourcemap path transform.
+*
+* Rolldown emits `sources` relative to the bundle output's directory, which
+* yields paths like `../App.tsx` when the bundle lives under e.g. `dist/`.
+* RN tooling (symbolication, devtools) expects project-root-relative paths,
+* so this rewrites each entry to be relative to `projectRoot`.
+*/
+function createProjectRootSourcemapPathTransform(projectRoot) {
+	return (source, sourcemapPath) => {
+		const absolute = path.resolve(path.dirname(sourcemapPath), source);
+		return path.relative(projectRoot, absolute);
+	};
+}
+function loadPolyfills(polyfills) {
+	return polyfills.map((polyfill) => {
+		if (typeof polyfill === "string") return fs.readFileSync(polyfill, "utf-8");
+		const path = "path" in polyfill ? polyfill.path : void 0;
+		const content = "code" in polyfill ? polyfill.code : fs.readFileSync(polyfill.path, "utf-8");
+		return polyfill.type === "iife" ? iife(content, path) : content;
+	});
+}
+async function applyDangerouslyOverrideOptionsFinalizer(config, inputOptions, outputOptions) {
+	const override = config.dangerously_overrideRolldownOptions;
+	if (override == null) return {
+		input: inputOptions,
+		output: outputOptions
+	};
+	return await applyOverrideRolldownOptions(override, {
+		input: inputOptions,
+		output: outputOptions
+	});
+}
+function isPluginLog(log) {
+	return log.plugin != null || log.code?.startsWith("PLUGIN_") === true;
+}
+function toBuildDiagnosticLog(log) {
+	return {
+		code: log.code,
+		plugin: log.plugin,
+		message: log.message,
+		stack: log.stack,
+		id: log.id,
+		hook: log.hook,
+		frame: log.frame,
+		loc: log.loc,
+		meta: log.meta
+	};
+}
+function getOverrideOptions() {
+	return {
+		input: { experimental: { nativeMagicString: true } },
+		output: {}
+	};
+}
+function getOverrideOptionsForDevServer(buildOptions) {
+	const overrideOptions = getOverrideOptions();
+	const input = {
+		transform: { jsx: { development: true } },
+		experimental: { incrementalBuild: true },
+		treeshake: false
+	};
+	const output = {
+		minify: buildOptions.minify ?? false,
+		sourcemap: buildOptions.sourcemap ?? true,
+		generatedCode: {
+			symbols: buildOptions.dev,
+			profilerNames: buildOptions.dev
+		}
+	};
+	return {
+		input: merge(overrideOptions.input, input),
+		output: merge(overrideOptions.output, output)
+	};
+}
+//#endregion
+export { getOverrideOptions, getOverrideOptionsForDevServer, resolveRolldownOptions };

package/dist/core/settings.js

@@ -0,0 +1,19 @@
+import { getSharedDataPath } from "./fs/data.js";
+import fs from "node:fs";
+import path from "node:path";
+import { merge } from "es-toolkit";
+//#region src/core/settings.ts
+function getSettingsPath(basePath) {
+	return path.join(getSharedDataPath(basePath), "settings.json");
+}
+function loadSettings(basePath) {
+	const settingsPath = getSettingsPath(basePath);
+	if (!fs.existsSync(settingsPath)) return {};
+	return JSON.parse(fs.readFileSync(settingsPath, "utf-8"));
+}
+function saveSettings(basePath, settings) {
+	const newSettings = merge(loadSettings(basePath), settings);
+	fs.writeFileSync(getSettingsPath(basePath), JSON.stringify(newSettings, null, 2));
+}
+//#endregion
+export { loadSettings, saveSettings };

package/dist/core/types.d.ts

@@ -0,0 +1,83 @@
+import { FileStorage } from "./fs/storage.js";
+import * as rolldown from "@rollipop/rolldown";
+import { DevEngine, DevOptions } from "@rollipop/rolldown/experimental";
+
+//#region src/core/types.d.ts
+interface BuildOptions {
+  /**
+   * The platform to build for.
+   */
+  platform: string;
+  /**
+   * Whether to build in development mode.
+   *
+   * Defaults to `config.mode === 'development'`.
+   */
+  dev?: boolean;
+  /**
+   * Whether to minify the bundle.
+   *
+   * This option is overridden by the `minify` option in the config.
+   *
+   * Defaults to `false`.
+   */
+  minify?: rolldown.OutputOptions['minify'];
+  /**
+   * Enable or disable the cache.
+   *
+   * Defaults to `true`.
+   */
+  cache?: boolean;
+  /**
+   * The output file.
+   */
+  outfile?: string;
+  /**
+   * The sourcemap file.
+   *
+   * This option is overridden by the `sourcemap` option in the config.
+   */
+  sourcemap?: rolldown.OutputOptions['sourcemap'];
+  /**
+   * The output file for the sourcemap.
+   */
+  sourcemapOutfile?: string;
+  /**
+   * The assets directory.
+   */
+  assetsDir?: string;
+}
+type DevEngine$1 = DevEngine & {
+  getContext: () => BundlerContext;
+};
+type DevEngineOptions = Omit<DevOptions, 'watch'> & {
+  /**
+   * The host to run the dev server on.
+   */
+  host: string;
+  /**
+   * The port to run the dev server on.
+   */
+  port: number;
+  /**
+   * Whether to use HTTPS.
+   *
+   * Defaults to `false`.
+   */
+  https?: boolean;
+};
+interface BundlerContext {
+  id: string;
+  root: string;
+  storage: FileStorage;
+  buildType: BuildType;
+  state: BundlerState;
+}
+interface BundlerState {
+  revision: number;
+  latestBuildStartTime: number;
+}
+type BuildType = 'build' | 'serve';
+type AsyncResult<T> = T | Promise<T>;
+//#endregion
+export { AsyncResult, BuildOptions, BuildType, BundlerContext, BundlerState, DevEngine$1 as DevEngine, DevEngineOptions };

package/dist/filter.d.ts

@@ -0,0 +1 @@
+export * from "@rollipop/rolldown/filter";

package/dist/filter.js

@@ -0,0 +1,2 @@
+export * from "@rollipop/rolldown/filter";
+export {};

package/dist/hmr-runtime.iife.js

@@ -28,12 +28,12 @@
 	};
 	var __commonJS = function e(e, r) {
 		return function() {
-			return r || (0, e[__getOwnPropNames(e)[0]])((r = { exports: {} }).exports, r), r.exports;
+			return r || ((0, e[__getOwnPropNames(e)[0]])((r = { exports: {} }).exports, r), e = null), r.exports;
 		};
 	};
 	var __commonJSMin = function e(e, r) {
 		return function() {
-			return r || e((r = { exports: {} }).exports, r), r.exports;
+			return r || (e((r = { exports: {} }).exports, r), e = null), r.exports;
 		};
 	};
 	var __exportAll = function e(e, r) {
@@ -270,7 +270,7 @@
 	}
 	var _globalThis, ___rolldown_runtime__;
 	var BaseDevRuntime = DevRuntime;
-	var ModuleHotContext = /* @__PURE__ */ function() {
+	var ModuleHotContext = /*#__PURE__*/ function() {
 		"use strict";
 		function e(t, r) {
 			_class_call_check(this, e);
@@ -368,7 +368,7 @@
 		]);
 		return e;
 	}();
-	var SocketHolder = /* @__PURE__ */ function() {
+	var SocketHolder = /*#__PURE__*/ function() {
 		"use strict";
 		function e() {
 			_class_call_check(this, e);
@@ -464,7 +464,7 @@
 		]);
 		return e;
 	}();
-	var ReactNativeDevRuntime = /* @__PURE__ */ function(BaseDevRuntime1) {
+	var ReactNativeDevRuntime = /*#__PURE__*/ function(BaseDevRuntime1) {
 		"use strict";
 		_inherits(ReactNativeDevRuntime1, BaseDevRuntime1);
 		function ReactNativeDevRuntime1() {