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

package/dist/config/load-config.js

@@ -0,0 +1,73 @@
+import { getDefaultConfig } from "./defaults.js";
+import { createPluginContext } from "../core/plugins/context.js";
+import { mergeConfig } from "./merge-config.js";
+import path from "node:path";
+import { omit } from "es-toolkit";
+import * as c12 from "c12";
+//#region src/config/load-config.ts
+const CONFIG_FILE_NAME = "rollipop";
+const INTERNAL_PLUGIN_HOOKS = ["transformCacheHit"];
+async function loadConfig(options = {}) {
+	const { cwd = process.cwd(), configFile, mode, context = {} } = options;
+	const defaultConfig = await getDefaultConfig(cwd, mode);
+	const commonOptions = {
+		context: {
+			...context,
+			defaultConfig
+		},
+		rcFile: false
+	};
+	const { config: userConfig } = await c12.loadConfig(configFile ? {
+		configFile: path.resolve(cwd, configFile),
+		configFileRequired: true
+	} : {
+		cwd,
+		defaultConfig,
+		name: CONFIG_FILE_NAME,
+		...commonOptions
+	});
+	const plugins = await flattenPluginOption(userConfig.plugins);
+	const resolvedConfig = {
+		...await resolvePluginConfig(mergeConfig(defaultConfig, {
+			...userConfig,
+			plugins
+		}), plugins),
+		plugins
+	};
+	if (!path.isAbsolute(resolvedConfig.entry)) resolvedConfig.entry = path.resolve(resolvedConfig.root, resolvedConfig.entry);
+	await invokeConfigResolved(resolvedConfig, plugins);
+	return resolvedConfig;
+}
+async function flattenPluginOption(pluginOption) {
+	const awaitedPluginOption = await pluginOption;
+	if (Array.isArray(awaitedPluginOption)) return (await Promise.all(awaitedPluginOption.map(flattenPluginOption))).flat();
+	if (awaitedPluginOption == null || awaitedPluginOption === false) return [];
+	return [stripInternalPluginHooks(awaitedPluginOption)];
+}
+function stripInternalPluginHooks(plugin) {
+	const maybeInternalPlugin = plugin;
+	if (!INTERNAL_PLUGIN_HOOKS.some((hook) => hook in maybeInternalPlugin)) return plugin;
+	return omit(maybeInternalPlugin, INTERNAL_PLUGIN_HOOKS);
+}
+async function resolvePluginConfig(baseConfig, plugins) {
+	let mergedConfig = omit(baseConfig, ["plugins"]);
+	for (const plugin of plugins) {
+		const context = createPluginContext(plugin.name);
+		const overrideBefore = mergedConfig.dangerously_overrideRolldownOptions;
+		if (typeof plugin.config === "function") {
+			const config = await plugin.config.call(context, mergedConfig);
+			if (config != null) mergedConfig = mergeConfig(mergedConfig, config);
+		} else if (typeof plugin.config === "object") mergedConfig = mergeConfig(mergedConfig, plugin.config);
+		const overrideAfter = mergedConfig.dangerously_overrideRolldownOptions;
+		if (overrideAfter != null && overrideAfter !== overrideBefore) context.debug({ message: `set 'dangerously_overrideRolldownOptions'` });
+	}
+	return mergedConfig;
+}
+async function invokeConfigResolved(config, plugins) {
+	await Promise.all(plugins.map((plugin) => {
+		const context = createPluginContext(plugin.name);
+		return Promise.resolve(plugin.configResolved?.call(context, config));
+	}));
+}
+//#endregion
+export { flattenPluginOption, invokeConfigResolved, loadConfig, resolvePluginConfig };

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

@@ -0,0 +1,12 @@
+import { Plugin } from "../core/plugins/types.js";
+import { Config } from "./types.js";
+import { DefaultConfig, ResolvedConfig } from "./defaults.js";
+
+//#region src/config/merge-config.d.ts
+type PluginFlattenConfig = Omit<Config, 'plugins'> & {
+  plugins?: Plugin[];
+};
+declare function mergeConfig(baseConfig: PluginFlattenConfig, ...overrideConfigs: PluginFlattenConfig[]): Config;
+declare function mergeConfig(baseConfig: DefaultConfig, ...overrideConfigs: PluginFlattenConfig[]): ResolvedConfig;
+//#endregion
+export { PluginFlattenConfig, mergeConfig };

package/dist/config/merge-config.js

@@ -0,0 +1,20 @@
+import { composeOverrideRolldownOptions } from "./compose-override.js";
+import { mergeWith } from "es-toolkit";
+//#region src/config/merge-config.ts
+function mergeConfig(baseConfig, ...overrideConfigs) {
+	let mergedConfig = baseConfig;
+	for (const overrideConfig of overrideConfigs) mergedConfig = mergeWith(mergedConfig, overrideConfig, (target, source, key) => {
+		if ([
+			"sourceExtensions",
+			"assetExtensions",
+			"polyfills",
+			"prelude",
+			"plugins"
+		].includes(key)) return Array.from(new Set([...target ?? [], ...source ?? []]));
+		if (key === "reporter") return source ?? target;
+		if (key === "dangerously_overrideRolldownOptions") return composeOverrideRolldownOptions(target, source);
+	});
+	return mergedConfig;
+}
+//#endregion
+export { mergeConfig };

package/dist/config/types.d.ts

@@ -0,0 +1,452 @@
+import { MaybePromise, NullValue, Reporter } from "../types.js";
+import { Plugin } from "../core/plugins/types.js";
+import { InteractiveCommand } from "../node/commands/start/setup-interactive-mode.js";
+import * as rolldown from "@rollipop/rolldown";
+import { DevWatchOptions, RollipopReactNativeFlowConfig, RollipopReactNativeWorkletsConfig } from "@rollipop/rolldown/experimental";
+import { TopLevelFilterExpression } from "@rollipop/rolldown/filter";
+import * as babel from "@babel/core";
+import * as swc from "@swc/core";
+import { TransformOptions } from "@rollipop/rolldown/utils";
+
+//#region src/config/types.d.ts
+type RolldownExperimentalOptions = NonNullable<rolldown.InputOptions['experimental']>;
+interface Config {
+  /**
+   * Defaults to current working directory.
+   */
+  root?: string;
+  /**
+   * Specifying this in config will override the default mode for both serve and build.
+   *
+   * Defaults to: `'development'` for serve, 'production' for build.
+   */
+  mode?: 'development' | 'production';
+  /**
+   * Defaults to: `index.js`
+   */
+  entry?: string;
+  /**
+   * Resolver configuration.
+   */
+  resolver?: ResolverConfig;
+  /**
+   * Transformer configuration.
+   */
+  transformer?: TransformerConfig;
+  /**
+   * Serializer configuration.
+   */
+  serializer?: SerializerConfig;
+  /**
+   * Watcher configuration.
+   */
+  watcher?: WatcherConfig;
+  /**
+   * Optimization configuration.
+   */
+  optimization?: OptimizationConfig;
+  /**
+   * React Native specific configuration.
+   */
+  reactNative?: ReactNativeConfig;
+  /**
+   * Terminal configuration.
+   */
+  terminal?: TerminalConfig;
+  /**
+   * Reporter configuration.
+   */
+  reporter?: Reporter;
+  /**
+   * Dev mode specific configuration. (for dev server)
+   */
+  devMode?: DevModeConfig;
+  /**
+   * Directory to load environment variables from.
+   *
+   * Defaults to: `root`
+   */
+  envDir?: string;
+  /**
+   * Base name for environment files.
+   *
+   * Acts as the basename of the standard four-file resolution: the loader looks
+   * for `${envFile}`, `${envFile}.local`, `${envFile}.[mode]`, and
+   * `${envFile}.[mode].local`. Override this to use a custom name such as
+   * `.rollipop-env` instead of the default `.env`.
+   *
+   * Expects a file name (not a path).
+   *
+   * Defaults to: `'.env'`
+   */
+  envFile?: string;
+  /**
+   * Environment variable prefix.
+   *
+   * Defaults to: `'ROLLIPOP_'`
+   */
+  envPrefix?: string;
+  /**
+   * Configures TypeScript configuration file resolution and usage.
+   *
+   * Defaults to: `true`
+   */
+  tsconfig?: rolldown.InputOptions['tsconfig'];
+  /**
+   * Whether to generate sourcemaps.
+   *
+   * - `false`: No sourcemap will be generated.
+   * - `true`: A separate sourcemap file will be generated.
+   * - `'inline'`: The sourcemap will be appended to the output file as a data URL.
+   * - `'hidden'`: A separate sourcemap file will be generated, but the link to the sourcemap (//# sourceMappingURL comment) will not be included in the output file.
+   *
+   * Defaults to: `true` when in development mode, `false` otherwise.
+   */
+  sourcemap?: rolldown.OutputOptions['sourcemap'];
+  /**
+   * The base URL for the links to the sourcemap file in the output file.
+   *
+   * By default, relative URLs are generated. If this option is set, an absolute URL with that base URL will be generated.
+   * This is useful when deploying source maps to a different location than your code, such as a CDN or separate debugging server.
+   */
+  sourcemapBaseUrl?: rolldown.OutputOptions['sourcemapBaseUrl'];
+  /**
+   * Whether to include [debug IDs](https://github.com/tc39/ecma426/blob/main/proposals/debug-id.md) in the sourcemap.
+   *
+   * When `true`, a unique debug ID will be emitted in source and sourcemaps which streamlines identifying sourcemaps across different builds.
+   *
+   * Defaults to: `false`
+   */
+  sourcemapDebugIds?: rolldown.OutputOptions['sourcemapDebugIds'];
+  /**
+   * Control which source files are included in the sourcemap ignore list.
+   *
+   * Files in the ignore list are excluded from debugger stepping and error stack traces.
+   *
+   * - `false`: Include no source files in the ignore list
+   * - `true`: Include all source files in the ignore list
+   * - `string`: Files containing this string in their path will be included in the ignore list
+   * - `RegExp`: Files matching this regular expression will be included in the ignore list
+   * - `function`: Custom function to determine if a source should be ignored
+   *
+   * :::tip Performance
+   * Using static values (`boolean`, `string`, or `RegExp`) is significantly more performant than functions.
+   * Calling JavaScript functions from Rust has extremely high overhead, so prefer static patterns when possible.
+   * :::
+   *
+   * @example
+   * ```js
+   * // ✅ Preferred: Use RegExp for better performance
+   * sourcemapIgnoreList: /node_modules/
+   *
+   * // ✅ Preferred: Use string pattern for better performance
+   * sourcemapIgnoreList: "vendor"
+   *
+   * // ! Use sparingly: Function calls have high overhead
+   * sourcemapIgnoreList: (source, sourcemapPath) => {
+   *   return source.includes('node_modules') || source.includes('.min.');
+   * }
+   * ```
+   *
+   * Defaults to: `/node_modules/`
+   */
+  sourcemapIgnoreList?: rolldown.OutputOptions['sourcemapIgnoreList'];
+  /**
+   * A transformation to apply to each path in a sourcemap.
+   *
+   * @example
+   * ```js
+   * export default defineConfig({
+   *   output: {
+   *     sourcemap: true,
+   *     sourcemapPathTransform: (source, sourcemapPath) => {
+   *       // Remove 'src/' prefix from all source paths
+   *       return source.replace(/^src\//, '');
+   *     },
+   *   },
+   * });
+   * ```
+   */
+  sourcemapPathTransform?: rolldown.OutputOptions['sourcemapPathTransform'];
+  /**
+   * Plugins to apply to the build.
+   */
+  plugins?: PluginOption;
+  /**
+   * Internal option to specify the runtime target.
+   *
+   * Defaults to 'hermes-v1'.
+   */
+  runtimeTarget?: 'hermes' | 'hermes-v1';
+  /**
+   * Experimental options. Behaviour and shape may change between releases
+   * without a major version bump.
+   */
+  experimental?: ExperimentalConfig;
+  /**
+   * Rollipop provides default options for Rolldown, but you can override them by this option.
+   *
+   * **DANGEROUS**: This option is dangerous because it can break the build.
+   */
+  dangerously_overrideRolldownOptions?: RolldownConfig | ((config: RolldownConfig) => RolldownConfig) | ((config: RolldownConfig) => Promise<RolldownConfig>);
+}
+type PluginOption = MaybePromise<NullValue<Plugin> | {
+  name: string;
+} | false | PluginOption[]>;
+type ResolverConfig = Omit<NonNullable<rolldown.InputOptions['resolve']>, 'extensions'> & {
+  /**
+   * Defaults to: `['ts', 'tsx', 'js', 'jsx', 'mjs', 'cjs', 'json']`
+   */
+  sourceExtensions?: string[];
+  /**
+   * Defaults to images (`bmp`, `gif`, `jpg`, `jpeg`, `png`, `psd`, `svg`, `webp`, `xml`),
+   * video (`m4v`, `mov`, `mp4`, `mpeg`, `mpg`, `webm`), audio (`aac`, `aiff`, `caf`, `m4a`,
+   * `mp3`, `wav`), documents (`html`, `pdf`, `yaml`, `yml`), fonts (`otf`, `ttf`), and
+   * archives (`zip`).
+   */
+  assetExtensions?: string[];
+  /**
+   * If `true`, resolver will resolve `native` suffixed files.
+   *
+   * e.g.
+   * - **true**: `index.android` -> `index.native` -> `index`
+   * - **false**: `index.android` -> `index`
+   *
+   * Defaults to: `true`
+   */
+  preferNativePlatform?: boolean;
+  /**
+   * Specifies which modules should be treated as external and not bundled.
+   *
+   * External modules will be left as import statements in the output.
+   */
+  external?: rolldown.InputOptions['external'];
+};
+type TransformerConfig = Omit<TransformOptions, 'cwd' | 'lang' | 'sourceType' | 'plugins'> & {
+  /**
+   * Flow specific configuration.
+   *
+   * Only applied when `experimental.nativeTransformPipeline` is **disabled** (the
+   * default). With the native pipeline enabled, the rust-side plugin
+   * handles Flow stripping internally.
+   */
+  flow?: FlowConfig;
+  /**
+   * Babel transformation configuration.
+   */
+  babel?: BabelTransformConfig;
+  /**
+   * SWC transformation configuration.
+   */
+  swc?: SwcTransformConfig;
+};
+type BabelTransformConfig = {
+  rules?: TransformRule<babel.TransformOptions>[];
+};
+type SwcTransformConfig = {
+  rules?: TransformRule<swc.Options>[];
+};
+interface TransformRule<T = unknown> {
+  filter?: rolldown.HookFilter | TopLevelFilterExpression[];
+  options: T | ((code: string, id: string) => T);
+}
+interface FlowConfig {
+  /**
+   * Filter for Flow transformation pipeline.
+   */
+  filter?: rolldown.HookFilter | TopLevelFilterExpression[];
+}
+interface ExperimentalConfig {
+  /**
+   * Enables the native (rust) transform pipeline, which replaces the
+   * legacy JS-side codegen marker, Flow strip, and SWC/babel preset
+   * machinery with a single built-in `rollipopReactNativePlugin`.
+   *
+   * This is a breaking change for projects that customised the legacy
+   * pipeline via `transformer.flow.filter`, `reactNative.codegen.filter`,
+   * or `runtimeTarget`. Opt in once you have validated builds locally.
+   *
+   * Defaults to `false`.
+   */
+  nativeTransformPipeline?: boolean;
+  /**
+   * Flow handling configuration for the native transform pipeline.
+   *
+   * Only applied when `experimental.nativeTransformPipeline` is enabled.
+   */
+  flow?: RollipopReactNativeFlowConfig;
+  /**
+   * `react-native-worklets` transformation configuration.
+   *
+   * Only applied when `experimental.nativeTransformPipeline` is enabled.
+   */
+  worklets?: RollipopReactNativeWorkletsConfig;
+}
+interface SerializerConfig {
+  /**
+   * Paths to prelude files.
+   *
+   * Prelude files are imported in the top of the entry module.
+   */
+  prelude?: string[];
+  /**
+   * Polyfills to include in the output bundle.
+   *
+   * Polyfills are injected in the top of the output bundle.
+   */
+  polyfills?: Polyfill[];
+  /**
+   * A string to prepend to the bundle before `renderChunk` hook.
+   */
+  banner?: rolldown.OutputOptions['banner'];
+  /**
+   * A string to append to the bundle before `renderChunk` hook.
+   */
+  footer?: rolldown.OutputOptions['footer'];
+  /**
+   * A string to prepend to the bundle after `renderChunk` hook and minification.
+   */
+  postBanner?: rolldown.OutputOptions['postBanner'];
+  /**
+   * A string to append to the bundle after `renderChunk` hook and minification.
+   */
+  postFooter?: rolldown.OutputOptions['postFooter'];
+  /**
+   * A string to prepend inside any format-specific wrapper.
+   */
+  intro?: rolldown.OutputOptions['intro'];
+  /**
+   * A string to append inside any format-specific wrapper.
+   */
+  outro?: rolldown.OutputOptions['outro'];
+  /**
+   * When `true`, creates shim variables for missing exports instead of throwing an error.
+   *
+   * Defaults to: `false`
+   */
+  shimMissingExports?: rolldown.InputOptions['shimMissingExports'];
+}
+type Polyfill = string | PolyfillWithCode | PolyfillWithPath;
+type PolyfillWithCode = {
+  type: PolyfillType;
+  code: string;
+};
+type PolyfillWithPath = {
+  type: PolyfillType;
+  path: string;
+};
+type PolyfillType = 'plain' | 'iife';
+type OptimizationConfig = rolldown.OptimizationOptions & {
+  /**
+   * Controls tree-shaking (dead code elimination).
+   *
+   * When `false`, tree-shaking will be disabled. When `true`, it is equivalent to setting each options to the default value.
+   *
+   * Defaults to: `true`
+   */
+  treeshake?: rolldown.InputOptions['treeshake'];
+  /**
+   * Control code minification.
+   *
+   * - `true`: Enable full minification including code compression and dead code elimination
+   * - `false`: Disable minification (default)
+   * - `'dce-only'`: Only perform dead code elimination without code compression
+   * - `MinifyOptions`: Fine-grained control over minification settings
+   *
+   * Defaults to: `false`
+   */
+  minify?: rolldown.OutputOptions['minify'];
+  /**
+   * Control whether to enable lazy barrel optimization.
+   *
+   * Lazy barrel optimization avoids compiling unused re-export modules in side-effect-free barrel modules,
+   * significantly improving build performance for large codebases with many barrel modules.
+   *
+   * Defaults to: `false`
+   *
+   * @see {@link https://rolldown.rs/in-depth/lazy-barrel-optimization | Lazy Barrel Documentation}
+   */
+  lazyBarrel?: RolldownExperimentalOptions['lazyBarrel'];
+};
+type WatcherConfig = DevWatchOptions;
+interface DevModeConfig {
+  /**
+   * Hot Module Replacement configurations.
+   * This feature is only available in `development` mode.
+   *
+   * Defaults to `true`.
+   */
+  hmr?: boolean | HmrConfig;
+}
+interface HmrConfig {
+  /**
+   * Source code of the HMR runtime implementation.
+   *
+   * Defaults to: using `rollipop/hmr-runtime` as a default implementation.
+   */
+  runtimeImplement?: string;
+  /**
+   * Source code of the HMR client implementation.
+   *
+   * Defaults to: using `rollipop/hmr-client` as a default implementation.
+   */
+  clientImplement?: string;
+}
+interface ReactNativeConfig {
+  /**
+   * Path to React Native package.
+   *
+   * Defaults to: resolving `react-native` package from `projectRoot`.
+   */
+  reactNativePath?: string;
+  /**
+   * Codegen specific configuration.
+   *
+   * Only applied when `experimental.nativeTransformPipeline` is **disabled** (the
+   * default). With the native pipeline enabled, the rust-side plugin
+   * handles codegen marking internally.
+   */
+  codegen?: CodegenConfig;
+  /**
+   * Path to asset registry file.
+   *
+   * Defaults to: `react-native/Libraries/Image/AssetRegistry.js`
+   */
+  assetRegistryPath?: string | ((root: string) => MaybePromise<string>);
+  /**
+   * Path to HMR client file.
+   *
+   * Defaults to: `react-native/Libraries/Utilities/HMRClient.js`
+   */
+  hmrClientPath?: string | ((root: string) => MaybePromise<string>);
+  /**
+   * Reserved global identifiers of React Native.
+   *
+   * Defaults to: Global identifier list of React Native 0.83
+   */
+  globalIdentifiers?: string[];
+}
+interface CodegenConfig {
+  /**
+   * Filter for codegen transformation pipeline.
+   */
+  filter?: rolldown.HookFilter | TopLevelFilterExpression[];
+}
+interface TerminalConfig {
+  /**
+   * Status of the terminal.
+   *
+   * Defaults to: `process.stderr.isTTY ? 'progress' : 'compat'`
+   */
+  status?: 'none' | 'compat' | 'progress';
+  /**
+   * Extra commands to display in the interactive mode.
+   */
+  extraCommands?: InteractiveCommand[];
+}
+interface RolldownConfig {
+  input?: rolldown.InputOptions;
+  output?: rolldown.OutputOptions;
+}
+//#endregion
+export { BabelTransformConfig, CodegenConfig, Config, DevModeConfig, ExperimentalConfig, FlowConfig, HmrConfig, OptimizationConfig, PluginOption, Polyfill, PolyfillType, PolyfillWithCode, PolyfillWithPath, ReactNativeConfig, ResolverConfig, RolldownConfig, type RollipopReactNativeFlowConfig, type RollipopReactNativeWorkletsConfig, SerializerConfig, SwcTransformConfig, TerminalConfig, TransformRule, TransformerConfig, WatcherConfig };

package/dist/constants.d.ts

@@ -0,0 +1,35 @@
+declare namespace constants_d_exports {
+  export { DEFAULT_ASSET_EXTENSIONS, DEFAULT_ASSET_REGISTRY_PATH, DEFAULT_ENV_FILE, DEFAULT_ENV_PREFIX, DEFAULT_HMR_CLIENT_PATH, DEFAULT_IMAGE_EXTENSIONS, DEFAULT_REACT_NATIVE_GLOBAL_IDENTIFIERS, DEFAULT_RESOLVER_ALIAS_FIELDS, DEFAULT_RESOLVER_CONDITION_NAMES, DEFAULT_RESOLVER_MAIN_FIELDS, DEFAULT_RUNTIME_TARGET, DEFAULT_SOURCE_EXTENSIONS, GLOBAL_IDENTIFIER, IMAGE_EXTENSIONS, ROLLIPOP_VERSION };
+}
+/**
+ * @see `vite.config.ts`
+ */
+declare global {
+  var __ROLLIPOP_VERSION__: string;
+}
+declare const ROLLIPOP_VERSION: string;
+declare const GLOBAL_IDENTIFIER = "global";
+/**
+ * @see {@link https://github.com/facebook/metro/blob/0.81.x/docs/Configuration.md#resolvermainfields}
+ */
+declare const DEFAULT_RESOLVER_MAIN_FIELDS: string[];
+declare const DEFAULT_RESOLVER_ALIAS_FIELDS: string[][];
+declare const DEFAULT_RESOLVER_CONDITION_NAMES: string[];
+/**
+ * Unlike the Metro bundler configuration, this prioritizes resolving TypeScript and ESM first.
+ *
+ * @see {@link https://github.com/facebook/metro/blob/0.81.x/packages/metro-config/src/defaults/defaults.js}
+ * @see {@link https://github.com/facebook/metro/blob/0.81.x/packages/metro-file-map/src/workerExclusionList.js}
+ */
+declare const DEFAULT_SOURCE_EXTENSIONS: string[];
+declare const DEFAULT_IMAGE_EXTENSIONS: string[];
+declare const IMAGE_EXTENSIONS: string[];
+declare const DEFAULT_ASSET_EXTENSIONS: string[];
+declare const DEFAULT_ASSET_REGISTRY_PATH = "react-native/Libraries/Image/AssetRegistry.js";
+declare const DEFAULT_HMR_CLIENT_PATH = "react-native/Libraries/Utilities/HMRClient.js";
+declare const DEFAULT_REACT_NATIVE_GLOBAL_IDENTIFIERS: string[];
+declare const DEFAULT_ENV_PREFIX = "ROLLIPOP_";
+declare const DEFAULT_ENV_FILE = ".env";
+declare const DEFAULT_RUNTIME_TARGET = "hermes-v1";
+//#endregion
+export { constants_d_exports };