@rolldown/plugin-babel 0.1.2 → 0.1.4

package/README.md

@@ -5,18 +5,18 @@ Rolldown plugin for transforming code with [Babel](https://babeljs.io/).
 ## Install
 
 ```bash
-npm install @rolldown/plugin-babel @babel/core
+pnpm install @rolldown/plugin-babel @babel/core
 ```
 
 ## Usage
 
 ```js
-import babelPlugin from '@rolldown/plugin-babel'
+import babel from '@rolldown/plugin-babel'
 
 export default {
   plugins: [
-    babelPlugin({
-      presets: [['@babel/preset-env', { targets: { chrome: '100' } }]],
+    babel({
+      plugins: ['@babel/plugin-proposal-throw-expressions'],
     }),
   ],
 }
@@ -31,8 +31,9 @@ The plugin automatically configures Babel's parser for `.jsx`, `.ts`, and `.tsx`
 ### `include`
 
 - **Type:** `string | RegExp | (string | RegExp)[]`
+- **Default:** `/\.(?:[jt]sx?|[cm][jt]s)(?:$|\?)/`
 
-If specified, only files matching the pattern will be processed.
+Only files matching the pattern will be processed.
 
 ### `exclude`
 

package/dist/index.d.mts

@@ -0,0 +1,63 @@
+import * as babel from "@babel/core";
+import { GeneralHookFilter, ModuleTypeFilter, Plugin } from "rolldown";
+import { Plugin as Plugin$1, ResolvedConfig } from "vite";
+
+//#region src/rolldownPreset.d.ts
+type PartialEnvironment = Parameters<NonNullable<Plugin$1['applyToEnvironment']>>[0];
+type RolldownBabelPreset = {
+  preset: babel.PresetItem;
+  rolldown: {
+    filter?: {
+      id?: GeneralHookFilter;
+      moduleType?: ModuleTypeFilter;
+      code?: GeneralHookFilter;
+    };
+    applyToEnvironmentHook?: (environment: PartialEnvironment) => boolean;
+    configResolvedHook?: (config: ResolvedConfig) => boolean;
+  };
+};
+type RolldownBabelPresetItem = babel.PresetItem | RolldownBabelPreset;
+declare function defineRolldownBabelPreset(preset: RolldownBabelPreset): RolldownBabelPreset;
+//#endregion
+//#region src/options.d.ts
+interface InnerTransformOptions extends Pick<babel.InputOptions, 'assumptions' | 'auxiliaryCommentAfter' | 'auxiliaryCommentBefore' | 'exclude' | 'comments' | 'compact' | 'cwd' | 'generatorOpts' | 'include' | 'parserOpts' | 'plugins' | 'retainLines' | 'shouldPrintComment' | 'targets' | 'wrapPluginVisitorMethod'> {
+  /**
+   * List of presets (a set of plugins) to load and use
+   *
+   * Default: `[]`
+   */
+  presets?: RolldownBabelPresetItem[] | undefined;
+}
+interface PluginOptions extends Omit<InnerTransformOptions, 'include' | 'exclude'> {
+  /**
+   * If specified, only files matching the pattern will be processed by babel.
+   * @default `/\.(?:[jt]sx?|[cm][jt]s)(?:$|\?)/`
+   *
+   * Note that this option receives the syntax supported by babel instead of picomatch.
+   * @see https://babeljs.io/docs/options#matchpattern
+   */
+  include?: InnerTransformOptions['include'];
+  /**
+   * If any of patterns match, babel will not process the file.
+   * @default `/[\/\\]node_modules[\/\\]/`
+   *
+   * Note that this option receives the syntax supported by babel instead of picomatch.
+   * @see https://babeljs.io/docs/options#matchpattern
+   */
+  exclude?: InnerTransformOptions['exclude'];
+  /**
+   * If false, skips source map generation. This will improve performance.
+   * @default true
+   */
+  sourceMap?: boolean;
+  /**
+   * Allows users to provide an array of options that will be merged into the current configuration one at a time.
+   * This feature is best used alongside the "test"/"include"/"exclude" options to provide conditions for which an override should apply
+   */
+  overrides?: InnerTransformOptions[] | undefined;
+}
+//#endregion
+//#region src/index.d.ts
+declare function babelPlugin(rawOptions: PluginOptions): Promise<Plugin>;
+//#endregion
+export { type RolldownBabelPreset, babelPlugin as default, defineRolldownBabelPreset };

package/dist/index.mjs

@@ -0,0 +1,374 @@
+import picomatch from "picomatch";
+import * as babel from "@babel/core";
+
+//#region src/utils.ts
+function arrayify(value) {
+	return Array.isArray(value) ? value : [value];
+}
+function filterMap(array, predicate) {
+	const newArray = [];
+	for (const [index, item] of array.entries()) {
+		const result = predicate(item, index);
+		if (result) newArray.push(result.value);
+	}
+	return newArray;
+}
+
+//#endregion
+//#region src/rolldownPreset.ts
+function compilePattern(pattern) {
+	if (pattern instanceof RegExp) return (value) => pattern.test(value);
+	return picomatch(pattern);
+}
+function compilePatterns(patterns) {
+	const matchers = patterns.map(compilePattern);
+	return (value) => matchers.some((m) => m(value));
+}
+/**
+* Pre-compile a GeneralHookFilter into a single matcher function.
+* Returns undefined when the filter matches everything.
+*/
+function compileGeneralHookFilter(filter) {
+	if (filter == null) return void 0;
+	let include;
+	let exclude;
+	if (typeof filter === "string" || filter instanceof RegExp) include = [filter];
+	else if (Array.isArray(filter)) include = filter;
+	else {
+		include = filter.include != null ? arrayify(filter.include) : void 0;
+		exclude = filter.exclude != null ? arrayify(filter.exclude) : void 0;
+	}
+	const includeMatcher = include ? compilePatterns(include) : void 0;
+	const excludeMatcher = exclude ? compilePatterns(exclude) : void 0;
+	if (includeMatcher && excludeMatcher) return (value) => !excludeMatcher(value) && includeMatcher(value);
+	if (excludeMatcher) return (value) => !excludeMatcher(value);
+	return includeMatcher;
+}
+function compileModuleTypeFilter(filter) {
+	if (filter == null) return void 0;
+	const types = Array.isArray(filter) ? filter : filter.include ?? [];
+	if (types.length === 0) return void 0;
+	const typeSet = new Set(types);
+	return (value) => typeSet.has(value);
+}
+/**
+* Pre-compile a preset's filter into a single matcher function
+* that checks all dimensions (id, moduleType, code) at once.
+* Returns undefined when the filter matches everything.
+*/
+function compilePresetFilter(filter) {
+	if (!filter) return void 0;
+	const matchId = compileGeneralHookFilter(filter.id);
+	const matchModuleType = compileModuleTypeFilter(filter.moduleType);
+	const matchCode = compileGeneralHookFilter(filter.code);
+	if (!matchId && !matchModuleType && !matchCode) return void 0;
+	return (ctx) => (!matchId || matchId(ctx.id)) && (!matchModuleType || matchModuleType(ctx.moduleType)) && (!matchCode || matchCode(ctx.code));
+}
+function defineRolldownBabelPreset(preset) {
+	return preset;
+}
+function convertToBabelPresetItem(ctx, preset, compiledFilter) {
+	if (typeof preset !== "object" || !("rolldown" in preset)) return { value: preset };
+	if (compiledFilter && !compiledFilter(ctx)) return void 0;
+	return { value: preset.preset };
+}
+
+//#endregion
+//#region src/options.ts
+const DEFAULT_INCLUDE = [/\.(?:[jt]sx?|[cm][jt]s)(?:$|\?)/];
+const DEFAULT_EXCLUDE = [/[/\\]node_modules[/\\]/];
+function resolveOptions(options) {
+	return {
+		...options,
+		include: options.include ?? DEFAULT_INCLUDE,
+		exclude: options.exclude ?? DEFAULT_EXCLUDE,
+		sourceMap: options.sourceMap ?? true
+	};
+}
+function compilePresetFilters(presets) {
+	return presets.map((preset) => typeof preset === "object" && "rolldown" in preset ? compilePresetFilter(preset.rolldown.filter) : void 0);
+}
+function filterPresetArrayWithEnvironment(presets, environment) {
+	return presets.filter((preset) => {
+		if (typeof preset !== "object" || !("rolldown" in preset)) return true;
+		if (!preset.rolldown.applyToEnvironmentHook) return true;
+		return preset.rolldown.applyToEnvironmentHook(environment);
+	});
+}
+function filterPresetsWithEnvironment(options, environment) {
+	return {
+		...options,
+		presets: options.presets ? filterPresetArrayWithEnvironment(options.presets, environment) : void 0,
+		overrides: options.overrides?.map((override) => override.presets ? {
+			...override,
+			presets: filterPresetArrayWithEnvironment(override.presets, environment)
+		} : override)
+	};
+}
+function filterPresetArray(presets, config) {
+	return presets.filter((preset) => {
+		if (typeof preset !== "object" || !("rolldown" in preset)) return true;
+		if (!preset.rolldown.configResolvedHook) return true;
+		return preset.rolldown.configResolvedHook(config);
+	});
+}
+function filterPresetsWithConfigResolved(options, config) {
+	return {
+		...options,
+		presets: options.presets ? filterPresetArray(options.presets, config) : void 0,
+		overrides: options.overrides?.map((override) => override.presets ? {
+			...override,
+			presets: filterPresetArray(override.presets, config)
+		} : override)
+	};
+}
+/**
+* Pre-compile all preset filters and return a function that
+* converts options to babel options for a given context.
+*/
+function createBabelOptionsConverter(options) {
+	const presetFilters = options.presets ? compilePresetFilters(options.presets) : void 0;
+	const overridePresetFilters = options.overrides?.map((override) => override.presets ? compilePresetFilters(override.presets) : void 0);
+	return function(ctx) {
+		return {
+			...options,
+			presets: options.presets ? filterMap(options.presets, (preset, i) => convertToBabelPresetItem(ctx, preset, presetFilters[i])) : void 0,
+			overrides: options.overrides?.map((override, i) => override.presets ? {
+				...override,
+				presets: filterMap(override.presets, (preset, j) => convertToBabelPresetItem(ctx, preset, overridePresetFilters[i][j]))
+			} : override)
+		};
+	};
+}
+
+//#endregion
+//#region src/filter.ts
+/**
+* Extract string/RegExp values from babel's ConfigApplicableTest,
+* filtering out function entries which HookFilter can't represent.
+* If any function entry is present, returns undefined because the
+* function could match anything we can't predict at the HookFilter level.
+*/
+function extractStringOrRegExp(test) {
+	if (test === void 0) return void 0;
+	const items = arrayify(test);
+	const result = [];
+	for (const item of items) {
+		if (typeof item === "function") return;
+		result.push(item);
+	}
+	return result.length > 0 ? result : void 0;
+}
+/**
+* Normalize a GeneralHookFilter into { include?, exclude? } form.
+*/
+function normalizeGeneralHookFilter(filter) {
+	if (filter == null) return {};
+	if (typeof filter === "string" || filter instanceof RegExp) return { include: [filter] };
+	if (Array.isArray(filter)) return { include: filter };
+	return {
+		include: filter.include != null ? arrayify(filter.include) : void 0,
+		exclude: filter.exclude != null ? arrayify(filter.exclude) : void 0
+	};
+}
+function isRolldownBabelPreset(preset) {
+	return typeof preset === "object" && preset !== null && "rolldown" in preset;
+}
+function normalizeModuleTypeFilter(filter) {
+	if (Array.isArray(filter)) return filter;
+	return filter.include ?? [];
+}
+function patternKey(pattern) {
+	return typeof pattern === "string" ? `s:${pattern}` : `r:${pattern.source}:${pattern.flags}`;
+}
+/**
+* Compute the intersection of arrays by key.
+* An item is kept only if it appears in every array.
+* If any array is undefined, the intersection is empty.
+*/
+function intersectArrays(arrays, keyFn) {
+	if (arrays.length === 0) return [];
+	const defined = arrays.filter((a) => a != null);
+	if (defined.length < arrays.length) return [];
+	let result = new Map(defined[0].map((p) => [keyFn(p), p]));
+	for (let i = 1; i < defined.length; i++) {
+		const keys = new Set(defined[i].map((p) => keyFn(p)));
+		for (const key of result.keys()) if (!keys.has(key)) result.delete(key);
+	}
+	return [...result.values()];
+}
+function concatArrays(a, b) {
+	if (!a) return b;
+	if (!b) return a;
+	return [...a, ...b];
+}
+/**
+* Union filter values from multiple presets for a single dimension.
+* Includes are unioned (OR). Excludes are intersected (only items in ALL presets are kept).
+*
+* @param rawFilters  Per-preset filter values. undefined = no filter (matches everything).
+* @param normalize   Converts a raw filter into { include?, exclude? } arrays.
+* @param keyFn       Serializes an item for intersection comparison.
+*/
+function unionFilters(rawFilters, normalize, keyFn) {
+	let matchAll = false;
+	const includes = [];
+	const excludeArrays = [];
+	for (const raw of rawFilters) {
+		if (raw === void 0) {
+			matchAll = true;
+			excludeArrays.push(void 0);
+			continue;
+		}
+		const n = normalize(raw);
+		if (!matchAll) if (n.include) includes.push(...n.include);
+		else matchAll = true;
+		excludeArrays.push(n.exclude);
+	}
+	return {
+		includes: matchAll ? void 0 : includes.length > 0 ? includes : void 0,
+		excludes: intersectArrays(excludeArrays, keyFn)
+	};
+}
+/**
+* Build the transform hook filter by intersecting a baseFilter (from user
+* include/exclude options) with a presetFilter (union of all RolldownBabelPreset
+* filters).
+*
+* - baseFilter constrains by id only (include/exclude from user options).
+* - presetFilter constrains by id, moduleType, and code. Includes are unioned
+*   across presets (OR), excludes are intersected (only patterns in ALL presets).
+* - The result uses user includes when present, otherwise falls back to preset
+*   includes. Excludes are combined from both (excluded by either → excluded).
+* - If the user has explicit plugins, presetFilter is skipped (plugins can match
+*   any file). Same if any preset is a plain babel preset without rolldown filters.
+*/
+function calculateTransformFilter(options) {
+	const userInclude = extractStringOrRegExp(options.include);
+	const userExclude = extractStringOrRegExp(options.exclude);
+	const baseFilter = { id: {
+		include: userInclude,
+		exclude: userExclude
+	} };
+	if (options.plugins && options.plugins.length > 0) return baseFilter;
+	const presets = options.presets;
+	if (!presets || presets.length === 0) return baseFilter;
+	for (const preset of presets) if (!isRolldownBabelPreset(preset) || !preset.rolldown.filter) return baseFilter;
+	const filters = presets.map((p) => p.rolldown.filter);
+	const idUnion = unionFilters(filters.map((f) => f.id), normalizeGeneralHookFilter, patternKey);
+	const moduleTypeUnion = unionFilters(filters.map((f) => f.moduleType), (f) => {
+		const types = normalizeModuleTypeFilter(f);
+		return { include: types.length > 0 ? types : void 0 };
+	}, (s) => s);
+	const codeUnion = unionFilters(filters.map((f) => f.code), normalizeGeneralHookFilter, patternKey);
+	const finalFilter = {};
+	const finalFilterIdInclude = userInclude ?? idUnion.includes;
+	const finalFilterIdExclude = concatArrays(userExclude, idUnion.excludes.length > 0 ? idUnion.excludes : void 0);
+	if (finalFilterIdInclude || finalFilterIdExclude) finalFilter.id = {
+		include: finalFilterIdInclude,
+		exclude: finalFilterIdExclude
+	};
+	if (moduleTypeUnion.includes) finalFilter.moduleType = moduleTypeUnion.includes;
+	if (codeUnion.includes) {
+		const finalFilterCodeExclude = codeUnion.excludes.length > 0 ? codeUnion.excludes : void 0;
+		if (finalFilterCodeExclude) finalFilter.code = {
+			include: codeUnion.includes,
+			exclude: finalFilterCodeExclude
+		};
+		else finalFilter.code = codeUnion.includes;
+	}
+	return finalFilter;
+}
+/**
+* Calculate the filters to apply to the plugin
+*/
+function calculatePluginFilters(options) {
+	return { transformFilter: calculateTransformFilter(options) };
+}
+
+//#endregion
+//#region src/index.ts
+async function babelPlugin(rawOptions) {
+	let configFilteredOptions;
+	const envState = /* @__PURE__ */ new Map();
+	const plugin = {
+		name: "@rolldown/plugin-babel",
+		configResolved(config) {
+			configFilteredOptions = filterPresetsWithConfigResolved(rawOptions, config);
+			const resolved = resolveOptions(configFilteredOptions);
+			plugin.transform.filter = calculatePluginFilters(resolved).transformFilter;
+		},
+		applyToEnvironment(environment) {
+			const envOptions = filterPresetsWithEnvironment(configFilteredOptions, environment);
+			if (!envOptions.presets?.length && !envOptions.plugins?.length && !envOptions.overrides?.some((o) => o.presets?.length || o.plugins?.length)) return false;
+			const resolved = resolveOptions(envOptions);
+			envState.set(environment.name, createBabelOptionsConverter(resolved));
+			return true;
+		},
+		outputOptions() {
+			if (this.meta.viteVersion) return;
+			const resolved = resolveOptions(rawOptions);
+			envState.set(void 0, createBabelOptionsConverter(resolved));
+			plugin.transform.filter = calculatePluginFilters(resolved).transformFilter;
+		},
+		transform: {
+			filter: void 0,
+			async handler(code, id, opts) {
+				const convertToBabelOptions = envState.get(this.environment?.name);
+				if (!convertToBabelOptions) return;
+				const babelOptions = convertToBabelOptions({
+					id,
+					moduleType: opts?.moduleType ?? "js",
+					code
+				});
+				const loadedOptions = await babel.loadOptionsAsync({
+					...babelOptions,
+					babelrc: false,
+					configFile: false,
+					parserOpts: {
+						sourceType: "module",
+						allowAwaitOutsideFunction: true,
+						...babelOptions.parserOpts
+					},
+					overrides: [
+						{
+							test: "**/*.jsx",
+							parserOpts: { plugins: ["jsx"] }
+						},
+						{
+							test: "**/*.ts",
+							parserOpts: { plugins: ["typescript"] }
+						},
+						{
+							test: "**/*.tsx",
+							parserOpts: { plugins: ["typescript", "jsx"] }
+						},
+						...babelOptions.overrides ?? []
+					],
+					filename: id
+				});
+				if (!loadedOptions || loadedOptions.plugins.length === 0) return;
+				let result;
+				try {
+					result = await babel.transformAsync(code, loadedOptions);
+				} catch (err) {
+					this.error({
+						message: `[BabelError] ${err.message}`,
+						loc: err.loc,
+						pos: err.pos,
+						cause: err,
+						pluginCode: `${err.code}:${err.reasonCode}`
+					});
+				}
+				if (result) return {
+					code: result.code ?? void 0,
+					map: result.map
+				};
+			}
+		}
+	};
+	return plugin;
+}
+
+//#endregion
+export { babelPlugin as default, defineRolldownBabelPreset };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rolldown/plugin-babel",
-  "version": "0.1.2",
+  "version": "0.1.4",
   "description": "Rolldown plugin for Babel",
   "keywords": [
     "babel",