@oxlint/migrate 1.42.0 → 1.46.0

package/README.md

@@ -24,6 +24,7 @@ When no config file is provided, the script searches for the default ESLint conf
 | `--type-aware`              | Include type aware rules, which are supported with `oxlint --type-aware` and [oxlint-tsgolint](https://github.com/oxc-project/tsgolint)     |
 | `--with-nursery`            | Include oxlint rules which are currently under development                                                                                  |
 | `--js-plugins`              | \*\* Include ESLint plugins via `jsPlugins` key.                                                                                            |
+| `--details`                 | List rules that could not be migrated to oxlint                                                                                             |
 | `--output-file <file>`      | The oxlint configuration file where ESLint v9 rules will be written to, default: `.oxlintrc.json`                                           |
 | `--replace-eslint-comments` | Search in the project files for ESLint comments and replaces them with oxlint. Some ESLint comments are not supported and will be reported. |
 
@@ -43,31 +44,18 @@ Tested ESLint Plugins with `oxlint` can be found in this [Oxc Discussion](https:
 
 ### TypeScript ESLint Configuration Files
 
-For Deno and Bun, TypeScript configuration files, like `eslint.config.mts`, are natively supported.
-For Node.js, you must install [jiti](https://www.npmjs.com/package/jiti) as a dev dependency.
+TypeScript configuration files, like `eslint.config.mts`, are supported in the following environments:
 
-## Contributing
-
-### Generate rules
+- **Deno and Bun**: TypeScript configuration files are natively supported.
+- **Node.js >=22.18.0**: TypeScript configuration files are supported natively with built-in type-stripping enabled by default.
+- **Node.js >=22.6.0**: TypeScript configuration files can be used by setting `NODE_OPTIONS=--experimental-strip-types`.
+- **Node.js <22.6.0**: TypeScript configuration files can be used by setting `NODE_OPTIONS=--import @oxc-node/core/register` and installing [@oxc-node/core](https://www.npmjs.com/package/@oxc-node/core) as a dev dependency.
 
-Generates the rules from installed oxlint version
+If you attempt to use a TypeScript configuration file without the proper setup for your Node.js version, Node.js will throw an error when trying to import the file.
 
-```shell
-pnpm generate
-pnpm format
-```
-
-### Unit + Integration Test
-
-```shell
-pnpm vitest
-```
-
-### Manual Testing
+## Contributing
 
-```shell
-pnpm manual-test
-```
+See [CONTRIBUTING.md](./CONTRIBUTING.md) for details on how to contribute to this project.
 
 ## Caveats
 
@@ -75,9 +63,11 @@ The migration tool has been tested to work quite well for simple ESLint flat con
 
 Here are some known caveats to be aware of:
 
-**`settings` field not migrated**
+**`settings` field migration**
+
+The `settings` field (e.g. for setting the React version) is migrated for known oxlint-supported plugins: `jsx-a11y`, `next`, `react`, `jsdoc`, and `vitest`. By default, other settings keys are skipped since they aren't supported by oxlint. If using the `--js-plugins` flag, other settings keys will also be migrated in order to support JS Plugins.
 
-The `settings` field (e.g. for setting the React version) is not migrated to the oxlint config yet. You may need to copy it over manually if you have any settings specified.
+Note: Oxlint does not support `settings` in override configs. If your ESLint config has settings in configs with `files` patterns, those settings will be skipped and a warning will be shown.
 
 Not all `settings` options are supported by oxlint, and so rule behavior in certain edge-cases may differ. See [the Settings docs](https://oxc.rs/docs/guide/usage/linter/config-file-reference.html#settings) for more info.
 

package/dist/bin/oxlint-migrate.mjs

@@ -1,5 +1,6 @@
 #!/usr/bin/env node
-import { i as rules_exports, n as preFixForJsPlugins, r as nurseryRules, t as src_default } from "../src-BiX8O61Z.mjs";
+import { a as preFixForJsPlugins, f as nurseryRules, p as rules_exports, u as isOffValue } from "../settings-C8UlaScv.mjs";
+import main from "../src/index.mjs";
 import { program } from "commander";
 import { existsSync, readFileSync, renameSync, writeFileSync } from "node:fs";
 import path from "node:path";
@@ -17,9 +18,9 @@ const FLAT_CONFIG_FILENAMES = [
 	"eslint.config.mts",
 	"eslint.config.cts"
 ];
-const getAutodetectedEslintConfigName = (cwd$1) => {
+const getAutodetectedEslintConfigName = (cwd) => {
 	for (const filename of FLAT_CONFIG_FILENAMES) {
-		const filePath = path.join(cwd$1, filename);
+		const filePath = path.join(cwd, filename);
 		if (existsSync(filePath)) return filePath;
 	}
 };
@@ -27,20 +28,12 @@ const loadESLintConfig = async (filePath) => {
 	if (filePath.endsWith("json")) throw new Error(`json format is not supported. @oxlint/migrate only supports the eslint flat configuration`);
 	let url = pathToFileURL(filePath).toString();
 	if (!existsSync(filePath)) throw new Error(`eslint config file not found: ${filePath}`);
-	if ("Bun" in globalThis || "Deno" in globalThis) return import(url);
-	if (filePath.endsWith(".ts") || filePath.endsWith(".mts") || filePath.endsWith(".cts")) {
-		const { createJiti } = await import("jiti");
-		return createJiti(filePath, {
-			interopDefault: false,
-			moduleCache: false
-		}).import(url);
-	}
 	return import(url);
 };
 
 //#endregion
 //#region package.json
-var version = "1.42.0";
+var version = "1.46.0";
 
 //#endregion
 //#region src/walker/comments/replaceRuleDirectiveComment.ts
@@ -211,8 +204,8 @@ function partialAstroSourceTextLoader(sourceText) {
 			pos = frontmatterEndDelimiter + 3;
 		}
 	}
-	results.push(...extractScriptBlocks(sourceText, pos, Number.MAX_SAFE_INTEGER, false).map((sourceText$1) => {
-		return Object.assign(sourceText$1, {
+	results.push(...extractScriptBlocks(sourceText, pos, Number.MAX_SAFE_INTEGER, false).map((sourceText) => {
+		return Object.assign(sourceText, {
 			lang: `ts`,
 			sourceType: `module`
 		});
@@ -227,7 +220,7 @@ const getComments = (absoluteFilePath, partialSourceText, options) => {
 		lang: partialSourceText.lang,
 		sourceType: partialSourceText.sourceType
 	});
-	if (parserResult.errors.length > 0) options.reporter?.report(`${absoluteFilePath}: failed to parse`);
+	if (parserResult.errors.length > 0) options.reporter?.addWarning(`${absoluteFilePath}: failed to parse`);
 	return parserResult.comments;
 };
 function replaceCommentsInSourceText(absoluteFilePath, partialSourceText, options) {
@@ -241,7 +234,7 @@ function replaceCommentsInSourceText(absoluteFilePath, partialSourceText, option
 		}
 	} catch (error) {
 		if (error instanceof Error) {
-			options.reporter?.report(`${absoluteFilePath}, char offset ${comment.start + partialSourceText.offset}: ${error.message}`);
+			options.reporter?.addWarning(`${absoluteFilePath}, char offset ${comment.start + partialSourceText.offset}: ${error.message}`);
 			continue;
 		}
 		throw error;
@@ -258,13 +251,13 @@ function replaceCommentsInFile(absoluteFilePath, fileContent, options) {
 
 //#endregion
 //#region src/walker/index.ts
-const walkAndReplaceProjectFiles = (projectFiles, readFileSync$1, writeFile$1, options) => {
+const walkAndReplaceProjectFiles = (projectFiles, readFileSync, writeFile, options) => {
 	return Promise.all(projectFiles.map((file) => {
-		const sourceText = readFileSync$1(file);
+		const sourceText = readFileSync(file);
 		if (!sourceText) return Promise.resolve();
 		const newSourceText = replaceCommentsInFile(file, sourceText, options);
 		if (newSourceText === sourceText) return Promise.resolve();
-		return writeFile$1(file, newSourceText);
+		return writeFile(file, newSourceText);
 	}));
 };
 
@@ -281,20 +274,18 @@ const getAllProjectFiles = () => {
 //#endregion
 //#region src/reporter.ts
 var DefaultReporter = class {
-	reports = /* @__PURE__ */ new Set();
+	warnings = /* @__PURE__ */ new Set();
 	skippedRules = new Map([
 		["nursery", /* @__PURE__ */ new Set()],
 		["type-aware", /* @__PURE__ */ new Set()],
-		["unsupported", /* @__PURE__ */ new Set()]
+		["unsupported", /* @__PURE__ */ new Set()],
+		["js-plugins", /* @__PURE__ */ new Set()]
 	]);
-	report(message) {
-		this.reports.add(message);
-	}
-	remove(message) {
-		this.reports.delete(message);
+	addWarning(message) {
+		this.warnings.add(message);
 	}
-	getReports() {
-		return Array.from(this.reports);
+	getWarnings() {
+		return Array.from(this.warnings);
 	}
 	markSkipped(rule, category) {
 		this.skippedRules.get(category)?.add(rule);
@@ -306,6 +297,7 @@ var DefaultReporter = class {
 		const result = {
 			nursery: [],
 			"type-aware": [],
+			"js-plugins": [],
 			unsupported: []
 		};
 		for (const [category, rules] of this.skippedRules) result[category] = Array.from(rules);
@@ -313,6 +305,92 @@ var DefaultReporter = class {
 	}
 };
 
+//#endregion
+//#region bin/output-formatter.ts
+const CATEGORY_METADATA = {
+	nursery: {
+		label: "Nursery",
+		description: "Experimental:"
+	},
+	"type-aware": {
+		label: "Type-aware",
+		description: "Requires TS info:"
+	},
+	"js-plugins": {
+		label: "JS Plugins",
+		description: "Requires JS plugins:"
+	},
+	unsupported: { label: "Unsupported" }
+};
+const MAX_LABEL_LENGTH = Math.max(...Object.values(CATEGORY_METADATA).map((meta) => meta.label.length));
+/**
+* Formats a category summary as either inline (with example) or vertical list
+*/
+function formatCategorySummary(count, category, rules, showAll) {
+	const meta = CATEGORY_METADATA[category];
+	if (!showAll) {
+		const maxRules = 3;
+		const exampleList = rules.slice(0, maxRules).join(", ");
+		const suffix = count > maxRules ? ", and more" : "";
+		const prefix = meta.description ? `${meta.description} ` : "";
+		return `     - ${String(count).padStart(3)} ${meta.label.padEnd(MAX_LABEL_LENGTH)} (${prefix}${exampleList}${suffix})\n`;
+	}
+	let output = `     - ${count} ${meta.label}\n`;
+	for (const rule of rules) output += `       - ${rule}\n`;
+	return output;
+}
+/**
+* Detects which CLI flags are missing and could enable more rules
+*/
+function detectMissingFlags(byCategory, cliOptions) {
+	const missingFlags = [];
+	if (byCategory.nursery.length > 0 && !cliOptions.withNursery) missingFlags.push("--with-nursery");
+	if (byCategory["type-aware"].length > 0 && !cliOptions.typeAware) missingFlags.push("--type-aware");
+	if (byCategory["js-plugins"].length > 0 && !cliOptions.jsPlugins) missingFlags.push("--js-plugins");
+	return missingFlags;
+}
+/**
+* Formats the complete migration output message
+*/
+function formatMigrationOutput(data) {
+	let output = "";
+	const showAll = data.cliOptions.details || false;
+	if (data.enabledRulesCount === 0) output += `\n⚠️ ${data.outputFileName} created with no rules enabled.\n`;
+	else output += `\n✨ ${data.outputFileName} created with ${data.enabledRulesCount} rules.\n`;
+	const byCategory = data.skippedRulesByCategory;
+	const nurseryCount = byCategory.nursery.length;
+	const typeAwareCount = byCategory["type-aware"].length;
+	const unsupportedCount = byCategory.unsupported.length;
+	const jsPluginsCount = byCategory["js-plugins"].length;
+	const totalSkipped = nurseryCount + typeAwareCount + unsupportedCount + jsPluginsCount;
+	if (totalSkipped > 0) {
+		output += `\n   Skipped ${totalSkipped} rules:\n`;
+		if (nurseryCount > 0) output += formatCategorySummary(nurseryCount, "nursery", byCategory.nursery, showAll);
+		if (typeAwareCount > 0) output += formatCategorySummary(typeAwareCount, "type-aware", byCategory["type-aware"], showAll);
+		if (jsPluginsCount > 0) output += formatCategorySummary(jsPluginsCount, "js-plugins", byCategory["js-plugins"], showAll);
+		if (unsupportedCount > 0) output += formatCategorySummary(unsupportedCount, "unsupported", byCategory.unsupported, showAll);
+		if (!showAll) {
+			const maxExamples = 3;
+			if (nurseryCount > maxExamples || typeAwareCount > maxExamples || unsupportedCount > maxExamples || jsPluginsCount > maxExamples) output += `\n     Tip: Use --details to see the full list.\n`;
+		}
+		const missingFlags = detectMissingFlags(byCategory, data.cliOptions);
+		if (missingFlags.length > 0) {
+			const eslintConfigArg = data.eslintConfigPath ? ` ${path.basename(data.eslintConfigPath)}` : "";
+			output += `\n👉 Re-run with flags to include more:\n`;
+			output += `     npx @oxlint/migrate${eslintConfigArg} ${missingFlags.join(" ")}\n`;
+		}
+	}
+	if (data.enabledRulesCount > 0) {
+		output += `\n🚀 Next:\n`;
+		output += `     npx oxlint .\n`;
+	}
+	return output;
+}
+function displayMigrationResult(outputMessage, warnings) {
+	console.log(outputMessage);
+	for (const warning of warnings) console.warn(warning);
+}
+
 //#endregion
 //#region bin/oxlint-migrate.ts
 const cwd = process.cwd();
@@ -323,7 +401,22 @@ const getFileContent = (absoluteFilePath) => {
 		return;
 	}
 };
-program.name("oxlint-migrate").version(version).argument("[eslint-config]", "The path to the eslint v9 config file").option("--output-file <file>", "The oxlint configuration file where to eslint v9 rules will be written to", ".oxlintrc.json").option("--merge", "Merge eslint configuration with an existing .oxlintrc.json configuration", false).option("--with-nursery", "Include oxlint rules which are currently under development", false).option("--replace-eslint-comments", "Search in the project files for eslint comments and replaces them with oxlint. Some eslint comments are not supported and will be reported.").option("--type-aware", "Includes supported type-aware rules. Needs the same flag in `oxlint` to enable it.").option("--js-plugins", "Tries to convert unsupported oxlint plugins with `jsPlugins`.").action(async (filePath) => {
+/**
+* Count enabled rules (excluding "off" rules) from both rules and overrides
+*/
+const countEnabledRules = (config) => {
+	const enabledRules = /* @__PURE__ */ new Set();
+	if (config.rules) {
+		for (const [ruleName, ruleValue] of Object.entries(config.rules)) if (!isOffValue(ruleValue)) enabledRules.add(ruleName);
+	}
+	if (config.overrides && Array.isArray(config.overrides)) {
+		for (const override of config.overrides) if (override.rules) {
+			for (const [ruleName, ruleValue] of Object.entries(override.rules)) if (!isOffValue(ruleValue)) enabledRules.add(ruleName);
+		}
+	}
+	return enabledRules.size;
+};
+program.name("oxlint-migrate").version(version).argument("[eslint-config]", "The path to the eslint v9 config file").option("--output-file <file>", "The oxlint configuration file where to eslint v9 rules will be written to", ".oxlintrc.json").option("--merge", "Merge eslint configuration with an existing .oxlintrc.json configuration", false).option("--with-nursery", "Include oxlint rules which are currently under development", false).option("--replace-eslint-comments", "Search in the project files for eslint comments and replaces them with oxlint. Some eslint comments are not supported and will be reported.").option("--type-aware", "Includes supported type-aware rules. Needs the same flag in `oxlint` to enable it.").option("--js-plugins", "Tries to convert unsupported oxlint plugins with `jsPlugins`.").option("--details", "List rules that could not be migrated to oxlint.", false).action(async (filePath) => {
 	const cliOptions = program.opts();
 	const oxlintFilePath = path.join(cwd, cliOptions.outputFile);
 	const reporter = new DefaultReporter();
@@ -335,7 +428,7 @@ program.name("oxlint-migrate").version(version).argument("[eslint-config]", "The
 		jsPlugins: !!cliOptions.jsPlugins
 	};
 	if (cliOptions.replaceEslintComments) {
-		await walkAndReplaceProjectFiles(await getAllProjectFiles(), (filePath$1) => getFileContent(filePath$1), (filePath$1, content) => writeFile(filePath$1, content, "utf-8"), options);
+		await walkAndReplaceProjectFiles(await getAllProjectFiles(), (filePath) => getFileContent(filePath), (filePath, content) => writeFile(filePath, content, "utf-8"), options);
 		return;
 	}
 	if (filePath === void 0) filePath = getAutodetectedEslintConfigName(cwd);
@@ -349,10 +442,22 @@ program.name("oxlint-migrate").version(version).argument("[eslint-config]", "The
 		encoding: "utf8",
 		flag: "r"
 	}));
-	const oxlintConfig = "default" in eslintConfigs ? await src_default(eslintConfigs.default, config, options) : await src_default(eslintConfigs, config, options);
+	const oxlintConfig = "default" in eslintConfigs ? await main(eslintConfigs.default, config, options) : await main(eslintConfigs, config, options);
 	if (existsSync(oxlintFilePath)) renameSync(oxlintFilePath, `${oxlintFilePath}.bak`);
 	writeFileSync(oxlintFilePath, JSON.stringify(oxlintConfig, null, 2));
-	for (const report of reporter.getReports()) console.warn(report);
+	const enabledRulesCount = countEnabledRules(oxlintConfig);
+	displayMigrationResult(formatMigrationOutput({
+		outputFileName: cliOptions.outputFile,
+		enabledRulesCount,
+		skippedRulesByCategory: reporter.getSkippedRulesByCategory(),
+		cliOptions: {
+			withNursery: !!cliOptions.withNursery,
+			typeAware: !!cliOptions.typeAware,
+			details: !!cliOptions.details,
+			jsPlugins: !!cliOptions.jsPlugins
+		},
+		eslintConfigPath: filePath
+	}), reporter.getWarnings());
 });
 program.parse();