@oxlint/migrate 1.24.0 → 1.26.0

package/README.md

@@ -21,6 +21,7 @@ When no config file provided, the script searches for the default eslint config
 | `--merge`                   | \* merge eslint configuration with an existing .oxlintrc.json configuration                                                                 |
 | `--type-aware`              | Include type aware rules, which are supported with `oxlint --type-aware`                                                                    |
 | `--with-nursery`            | Include oxlint rules which are currently under development                                                                                  |
+| `--js-plugins`              | \*\* Include ESLint plugins via `jsPlugins` key.                                                                                            |
 | `--output-file <file>`      | The oxlint configuration file where to 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. |
 
@@ -28,6 +29,10 @@ When no config file provided, the script searches for the default eslint config
 Else we need to disable each rule `plugin/categories` combination, which is not covered by your eslint configuration.
 This behavior can change in the future.
 
+\*\* WARNING: Tries to guess the plugin name. Should work with most of the plugin names.
+Not every ESLint API is integrated with `oxlint`.
+Tested ESLint Plugins with `oxlint` can be found in this [Oxc Discussion](https://github.com/oxc-project/oxc/discussions/14862).
+
 ### User Flow
 
 - Upgrade `oxlint` and `@oxlint/migrate` to the same version.

package/dist/bin/oxlint-migrate.mjs

@@ -9,6 +9,7 @@ import { walkAndReplaceProjectFiles } from "../src/walker/index.mjs";
 import { getAllProjectFiles } from "./project-loader.mjs";
 import { writeFile } from "node:fs/promises";
 import { preFixForJsPlugins } from "../src/js_plugin_fixes.mjs";
+import { DefaultReporter } from "../src/reporter.mjs";
 const cwd = process.cwd();
 const getFileContent = (absoluteFilePath) => {
   try {
@@ -35,14 +36,19 @@ program.name("oxlint-migrate").version(packageJson.version).argument("[eslint-co
 ).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) => {
   const cliOptions = program.opts();
   const oxlintFilePath = path.join(cwd, cliOptions.outputFile);
+  const reporter = new DefaultReporter();
   const options = {
-    reporter: console.warn,
+    reporter,
     merge: !!cliOptions.merge,
     withNursery: !!cliOptions.withNursery,
-    typeAware: !!cliOptions.typeAware
+    typeAware: !!cliOptions.typeAware,
+    jsPlugins: !!cliOptions.jsPlugins
   };
   if (cliOptions.replaceEslintComments) {
     await walkAndReplaceProjectFiles(
@@ -75,5 +81,8 @@ program.name("oxlint-migrate").version(packageJson.version).argument("[eslint-co
     renameSync(oxlintFilePath, `${oxlintFilePath}.bak`);
   }
   writeFileSync(oxlintFilePath, JSON.stringify(oxlintConfig, null, 2));
+  for (const report of reporter.getReports()) {
+    console.warn(report);
+  }
 });
 program.parse();

package/dist/package.json.mjs

@@ -1,4 +1,4 @@
-const version = "1.24.0";
+const version = "1.26.0";
 const packageJson = {
   version
 };

package/dist/src/cleanup.mjs

@@ -1,5 +1,5 @@
 import { removeGlobalsWithAreCoveredByEnv, transformBoolGlobalToString, ES_VERSIONS, cleanUpUselessOverridesEnv } from "./env_globals.mjs";
-import { replaceTypescriptAliasRules, replaceNodePluginName, cleanUpRulesWhichAreCoveredByCategory, cleanUpUselessOverridesRules, cleanUpUselessOverridesPlugins } from "./plugins_rules.mjs";
+import { replaceTypescriptAliasRules, replaceNodePluginName, cleanUpRulesWhichAreCoveredByCategory, cleanUpDisabledRootRules, cleanUpUselessOverridesRules, cleanUpUselessOverridesPlugins } from "./plugins_rules.mjs";
 import { isEqualDeep } from "./utilities.mjs";
 const TS_ESLINT_DEFAULT_OVERRIDE = {
   files: ["**/*.ts", "**/*.tsx", "**/*.mts", "**/*.cts"],
@@ -81,6 +81,7 @@ const cleanUpOxlintConfig = (config) => {
   }
   if (!("files" in config)) {
     cleanUpUselessOverridesEntries(config);
+    cleanUpDisabledRootRules(config);
   }
 };
 export {

package/dist/src/env_globals.mjs

@@ -111,7 +111,7 @@ const transformEnvAndGlobals = (eslintConfig, targetConfig, options) => {
     // @ts-ignore
     eslintConfig.languageOptions.parser.meta?.name
   )) {
-    options?.reporter !== void 0 && options.reporter(
+    options?.reporter?.report(
       "special parser detected: " + // @ts-ignore
       eslintConfig.languageOptions.parser.meta?.name
     );

package/dist/src/generated/rules.mjs

@@ -35,6 +35,7 @@ const pedanticRules = [
   "jsdoc/require-returns-description",
   "jsdoc/require-returns-type",
   "react/checked-requires-onchange-or-readonly",
+  "react/jsx-no-target-blank",
   "react/jsx-no-useless-fragment",
   "react/no-unescaped-entities",
   "react-hooks/rules-of-hooks",
@@ -42,6 +43,7 @@ const pedanticRules = [
   "@typescript-eslint/ban-types",
   "@typescript-eslint/no-misused-promises",
   "@typescript-eslint/no-confusing-void-expression",
+  "@typescript-eslint/no-deprecated",
   "@typescript-eslint/no-mixed-enums",
   "@typescript-eslint/no-unsafe-argument",
   "@typescript-eslint/no-unsafe-assignment",
@@ -57,6 +59,7 @@ const pedanticRules = [
   "@typescript-eslint/require-await",
   "@typescript-eslint/restrict-plus-operands",
   "@typescript-eslint/return-await",
+  "@typescript-eslint/strict-boolean-expressions",
   "@typescript-eslint/switch-exhaustiveness-check",
   "unicorn/consistent-assert",
   "unicorn/consistent-empty-array-spread",
@@ -215,6 +218,7 @@ const styleRules = [
   "react/no-set-state",
   "react/prefer-es6-class",
   "react/self-closing-comp",
+  "react/state-in-constructor",
   "@typescript-eslint/adjacent-overload-signatures",
   "@typescript-eslint/array-type",
   "@typescript-eslint/ban-tslint-comment",
@@ -268,9 +272,9 @@ const styleRules = [
   "vitest/prefer-to-be-falsy",
   "vitest/prefer-to-be-object",
   "vitest/prefer-to-be-truthy",
-  "vue/define-props-destructuring",
   "vue/define-emits-declaration",
   "vue/define-props-declaration",
+  "vue/define-props-destructuring",
   "vue/require-typed-ref",
   "@typescript-eslint/default-param-last",
   "@typescript-eslint/init-declarations",
@@ -594,7 +598,6 @@ const correctnessRules = [
   "react/forward-ref-uses-ref",
   "react/jsx-key",
   "react/jsx-no-duplicate-props",
-  "react/jsx-no-target-blank",
   "react/jsx-no-undef",
   "react/jsx-props-no-spread-multi",
   "react/no-children-prop",

package/dist/src/ignorePatterns.mjs

@@ -3,7 +3,7 @@ const transformIgnorePatterns = (eslintConfig, targetConfig, options) => {
     return;
   }
   if ("files" in targetConfig) {
-    options?.reporter !== void 0 && options.reporter("ignore list inside overrides is not supported");
+    options?.reporter?.report("ignore list inside overrides is not supported");
     return;
   }
   if (targetConfig.ignorePatterns === void 0) {

package/dist/src/index.mjs

@@ -59,13 +59,13 @@ const buildConfig = (configs, oxlintConfig, options) => {
     transformRuleEntry(config, targetConfig, options);
     transformEnvAndGlobals(config, targetConfig, options);
     if ("files" in targetConfig) {
-      detectNeededRulesPlugins(targetConfig, options);
+      detectNeededRulesPlugins(targetConfig);
       detectEnvironmentByGlobals(targetConfig);
       cleanUpOxlintConfig(targetConfig);
     }
   }
   oxlintConfig.overrides = overrides;
-  detectNeededRulesPlugins(oxlintConfig, options);
+  detectNeededRulesPlugins(oxlintConfig);
   detectEnvironmentByGlobals(oxlintConfig);
   cleanUpOxlintConfig(oxlintConfig);
   return oxlintConfig;

package/dist/src/jsPlugins.d.ts

@@ -0,0 +1,3 @@
+import { Linter } from 'eslint';
+import { OxlintConfigOrOverride } from './types.js';
+export declare const enableJsPluginRule: (targetConfig: OxlintConfigOrOverride, rule: string, ruleEntry: Linter.RuleEntry | undefined) => boolean;

package/dist/src/jsPlugins.mjs

@@ -0,0 +1,52 @@
+import { rulesPrefixesForPlugins } from "./constants.mjs";
+const ignorePlugins = /* @__PURE__ */ new Set([
+  ...Object.keys(rulesPrefixesForPlugins),
+  ...Object.values(rulesPrefixesForPlugins),
+  "local"
+  // ToDo: handle local plugin rules
+]);
+const guessEslintPluginName = (pluginName) => {
+  if (pluginName.startsWith("@")) {
+    const [scope, maybeSub] = pluginName.split("/");
+    if (maybeSub) {
+      return `${scope}/eslint-plugin-${maybeSub}`;
+    }
+    return `${scope}/eslint-plugin`;
+  }
+  return `eslint-plugin-${pluginName}`;
+};
+const extractPluginId = (ruleId) => {
+  const firstSlash = ruleId.indexOf("/");
+  if (firstSlash === -1) {
+    return;
+  }
+  if (ruleId.startsWith("@")) {
+    const secondSlash = ruleId.indexOf("/", firstSlash + 1);
+    if (secondSlash !== -1) {
+      return ruleId.substring(0, secondSlash);
+    }
+  }
+  return ruleId.substring(0, firstSlash);
+};
+const enableJsPluginRule = (targetConfig, rule, ruleEntry) => {
+  const pluginName = extractPluginId(rule);
+  if (pluginName === void 0) {
+    return false;
+  }
+  if (ignorePlugins.has(pluginName)) {
+    return false;
+  }
+  if (targetConfig.jsPlugins === void 0) {
+    targetConfig.jsPlugins = [];
+  }
+  const eslintPluginName = guessEslintPluginName(pluginName);
+  if (!targetConfig.jsPlugins.includes(eslintPluginName)) {
+    targetConfig.jsPlugins.push(eslintPluginName);
+  }
+  targetConfig.rules = targetConfig.rules || {};
+  targetConfig.rules[rule] = ruleEntry;
+  return true;
+};
+export {
+  enableJsPluginRule
+};

package/dist/src/js_plugin_fixes.mjs

@@ -3,7 +3,8 @@ const fixForAntfuEslintConfig = (config) => {
     return config.renamePlugins({
       ts: "@typescript-eslint",
       test: "vitest",
-      next: "@next/next"
+      next: "@next/next",
+      style: "@stylistic"
     });
   }
   return config;

package/dist/src/plugins_rules.d.ts

@@ -1,10 +1,11 @@
 import { Linter } from 'eslint';
 import { Options, OxlintConfig, OxlintConfigOrOverride } from './types.js';
 export declare const transformRuleEntry: (eslintConfig: Linter.Config, targetConfig: OxlintConfigOrOverride, options?: Options) => void;
-export declare const detectNeededRulesPlugins: (targetConfig: OxlintConfigOrOverride, options?: Options) => void;
+export declare const detectNeededRulesPlugins: (targetConfig: OxlintConfigOrOverride) => void;
 export declare const cleanUpUselessOverridesPlugins: (config: OxlintConfig) => void;
 export declare const cleanUpUselessOverridesRules: (config: OxlintConfig) => void;
 export declare const cleanUpRulesWhichAreCoveredByCategory: (config: OxlintConfigOrOverride) => void;
+export declare const cleanUpDisabledRootRules: (config: OxlintConfig) => void;
 export declare const replaceTypescriptAliasRules: (config: OxlintConfigOrOverride) => void;
 /**
  * Oxlint support them only under the node plugin name

package/dist/src/plugins_rules.mjs

@@ -1,6 +1,7 @@
 import * as rules from "./generated/rules.mjs";
 import { nurseryRules } from "./generated/rules.mjs";
 import { typescriptTypeAwareRules, rulesPrefixesForPlugins, typescriptRulesExtendEslintRules } from "./constants.mjs";
+import { enableJsPluginRule } from "./jsPlugins.mjs";
 const allRules = Object.values(rules).flat();
 const isValueInSet = (value, validSet) => validSet.includes(value) || Array.isArray(value) && validSet.includes(value[0]);
 const isActiveValue = (value) => isValueInSet(value, ["error", "warn", 1, 2]);
@@ -43,11 +44,13 @@ const transformRuleEntry = (eslintConfig, targetConfig, options) => {
   for (const [rule, config] of Object.entries(eslintConfig.rules)) {
     if (allRules.includes(rule)) {
       if (!options?.withNursery && nurseryRules.includes(rule)) {
-        options?.reporter !== void 0 && options.reporter(`unsupported rule, but in development: ${rule}`);
+        options?.reporter?.report(
+          `unsupported rule, but in development: ${rule}`
+        );
         continue;
       }
       if (!options?.typeAware && typescriptTypeAwareRules.includes(rule)) {
-        options?.reporter !== void 0 && options.reporter(
+        options?.reporter?.report(
           `type-aware rule detected, but \`--type-aware\` is not enabled: ${rule}`
         );
         continue;
@@ -60,13 +63,21 @@ const transformRuleEntry = (eslintConfig, targetConfig, options) => {
         targetConfig.rules[rule] = normalizeSeverityValue(config);
       }
     } else {
-      if (isActiveValue(config)) {
-        options?.reporter !== void 0 && options.reporter(`unsupported rule: ${rule}`);
+      if (options?.jsPlugins) {
+        if (isActiveValue(config) && !enableJsPluginRule(
+          targetConfig,
+          rule,
+          normalizeSeverityValue(config)
+        )) {
+          options?.reporter?.report(`unsupported rule: ${rule}`);
+        }
+      } else if (isActiveValue(config)) {
+        options?.reporter?.report(`unsupported rule: ${rule}`);
       }
     }
   }
 };
-const detectNeededRulesPlugins = (targetConfig, options) => {
+const detectNeededRulesPlugins = (targetConfig) => {
   if (targetConfig.rules === void 0) {
     return;
   }
@@ -77,18 +88,11 @@ const detectNeededRulesPlugins = (targetConfig, options) => {
     if (!rule.includes("/")) {
       continue;
     }
-    let found = false;
     for (const [prefix, plugin] of Object.entries(rulesPrefixesForPlugins)) {
-      if (rule.startsWith(`${prefix}/`)) {
-        if (!targetConfig.plugins.includes(plugin)) {
-          targetConfig.plugins.push(plugin);
-        }
-        found = true;
+      if (rule.startsWith(`${prefix}/`) && !targetConfig.plugins.includes(plugin)) {
+        targetConfig.plugins.push(plugin);
       }
     }
-    if (!found) {
-      options?.reporter !== void 0 && options.reporter(`unsupported plugin for rule: ${rule}`);
-    }
   }
   if ("files" in targetConfig && targetConfig.plugins.length === 0) {
     delete targetConfig.plugins;
@@ -146,6 +150,36 @@ const cleanUpRulesWhichAreCoveredByCategory = (config) => {
     }
   }
 };
+const getEnabledCategories = (config) => {
+  if (config.categories === void 0) {
+    return ["correctness"];
+  }
+  const categories = Object.entries(config.categories).filter(([, severity]) => severity === "warn" || severity === "error").map(([category]) => category);
+  if (Object.keys(config.categories).includes("correctness")) {
+    return categories;
+  }
+  return [...categories, "correctness"];
+};
+const isRuleInEnabledCategory = (rule, enabledCategories) => {
+  for (const category of enabledCategories) {
+    if (`${category}Rules` in rules && // @ts-expect-error -- ts can not resolve the type
+    rules[`${category}Rules`].includes(rule)) {
+      return true;
+    }
+  }
+  return false;
+};
+const cleanUpDisabledRootRules = (config) => {
+  if (config.rules === void 0) {
+    return;
+  }
+  const enabledCategories = getEnabledCategories(config);
+  for (const [rule, settings] of Object.entries(config.rules)) {
+    if (isOffValue(settings) && !isRuleInEnabledCategory(rule, enabledCategories)) {
+      delete config.rules[rule];
+    }
+  }
+};
 const replaceTypescriptAliasRules = (config) => {
   if (config.rules === void 0) {
     return;
@@ -181,6 +215,7 @@ const replaceNodePluginName = (config) => {
   }
 };
 export {
+  cleanUpDisabledRootRules,
   cleanUpRulesWhichAreCoveredByCategory,
   cleanUpUselessOverridesPlugins,
   cleanUpUselessOverridesRules,

package/dist/src/reporter.d.ts

@@ -0,0 +1,10 @@
+import { Reporter } from './types.js';
+export declare class DefaultReporter implements Reporter {
+    private reports;
+    report(message: string): void;
+    getReports(): string[];
+}
+export declare class SilentReporter implements Reporter {
+    report(_message: string): void;
+    getReports(): string[];
+}

package/dist/src/reporter.mjs

@@ -0,0 +1,12 @@
+class DefaultReporter {
+  reports = /* @__PURE__ */ new Set();
+  report(message) {
+    this.reports.add(message);
+  }
+  getReports() {
+    return Array.from(this.reports);
+  }
+}
+export {
+  DefaultReporter
+};

package/dist/src/types.d.ts

@@ -1,5 +1,6 @@
 import { Linter } from 'eslint';
 type OxlintConfigPlugins = string[];
+type OxlintConfigJsPlugins = string[];
 type OxlintConfigCategories = Record<string, unknown>;
 type OxlintConfigEnv = Record<string, boolean>;
 type OxlintConfigIgnorePatterns = string[];
@@ -8,6 +9,7 @@ export type OxlintConfigOverride = {
     env?: OxlintConfigEnv;
     globals?: Linter.Globals;
     plugins?: OxlintConfigPlugins;
+    jsPlugins?: OxlintConfigJsPlugins;
     categories?: OxlintConfigCategories;
     rules?: Partial<Linter.RulesRecord>;
 };
@@ -16,17 +18,22 @@ export type OxlintConfig = {
     env?: OxlintConfigEnv;
     globals?: Linter.Globals;
     plugins?: OxlintConfigPlugins;
+    jsPlugins?: OxlintConfigJsPlugins;
     categories?: OxlintConfigCategories;
     rules?: Partial<Linter.RulesRecord>;
     overrides?: OxlintConfigOverride[];
     ignorePatterns?: OxlintConfigIgnorePatterns;
 };
 export type OxlintConfigOrOverride = OxlintConfig | OxlintConfigOverride;
-type Reporter = (warning: string) => void;
+export type Reporter = {
+    report(message: string): void;
+    getReports(): string[];
+};
 export type Options = {
     reporter?: Reporter;
     merge?: boolean;
     withNursery?: boolean;
     typeAware?: boolean;
+    jsPlugins?: boolean;
 };
 export {};

package/dist/src/walker/replaceCommentsInFile.mjs

@@ -10,8 +10,8 @@ const getComments = (absoluteFilePath, partialSourceText, options) => {
       sourceType: partialSourceText.sourceType
     }
   );
-  if (parserResult.errors.length > 0 && options.reporter) {
-    options.reporter(`${absoluteFilePath}: failed to parse`);
+  if (parserResult.errors.length > 0) {
+    options.reporter?.report(`${absoluteFilePath}: failed to parse`);
   }
   return parserResult.comments;
 };
@@ -26,8 +26,8 @@ function replaceCommentsInSourceText(absoluteFilePath, partialSourceText, option
         sourceText = sourceText.slice(0, comment.start) + newComment + sourceText.slice(comment.end);
       }
     } catch (error) {
-      if (error instanceof Error && options.reporter) {
-        options.reporter(
+      if (error instanceof Error) {
+        options.reporter?.report(
           `${absoluteFilePath}, char offset ${comment.start + partialSourceText.offset}: ${error.message}`
         );
         continue;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@oxlint/migrate",
-  "version": "1.24.0",
+  "version": "1.26.0",
   "description": "Generates a `.oxlintrc.json` from a existing eslint flat config",
   "type": "module",
   "bin": {
@@ -37,10 +37,9 @@
   "author": "Sysix <sysix@sysix-coding.de>",
   "license": "MIT",
   "devDependencies": {
-    "@antfu/eslint-config": "^5.0.0",
-    "@eslint/eslintrc": "^3.3.1",
+    "@antfu/eslint-config": "^6.0.0",
     "@eslint/js": "^9.29.0",
-    "@logux/eslint-config": "^56.0.0",
+    "@logux/eslint-config": "^57.0.0",
     "@oxc-node/core": "^0.0.32",
     "@stylistic/eslint-plugin": "^5.0.0",
     "@stylistic/eslint-plugin-ts": "^4.4.1",
@@ -48,33 +47,36 @@
     "@types/node": "^24.0.4",
     "@typescript-eslint/eslint-plugin": "^8.35.0",
     "@typescript-eslint/parser": "^8.35.0",
-    "@vitest/coverage-v8": "^3.2.4",
+    "@vitest/coverage-v8": "^4.0.0",
     "eslint": "^9.29.0",
-    "eslint-config-next": "^15.5.0",
+    "eslint-config-next": "^16.0.0",
     "eslint-config-prettier": "^10.1.5",
     "eslint-plugin-header": "^3.1.1",
     "eslint-plugin-import": "^2.32.0",
     "eslint-plugin-import-x": "^4.16.0",
-    "eslint-plugin-jsdoc": "^60.0.0",
+    "eslint-plugin-jsdoc": "^61.0.0",
     "eslint-plugin-local": "^6.0.0",
+    "eslint-plugin-mocha": "^11.2.0",
     "eslint-plugin-oxlint": "^1.3.0",
+    "eslint-plugin-prettier": "^5.5.4",
     "eslint-plugin-react": "^7.37.5",
-    "eslint-plugin-react-hooks": "^5.2.0",
+    "eslint-plugin-react-hooks": "^7.0.1",
     "eslint-plugin-react-perf": "^3.3.3",
     "eslint-plugin-regexp": "^2.9.0",
-    "eslint-plugin-unicorn": "^61.0.0",
+    "eslint-plugin-tsdoc": "^0.4.0",
+    "eslint-plugin-unicorn": "^62.0.0",
     "husky": "^9.1.7",
     "jiti": "^2.4.2",
     "lint-staged": "^16.1.2",
-    "next": "^15.5.0",
-    "oxlint": "^1.24.0",
+    "next": "^16.0.0",
+    "oxlint": "^1.26.0",
     "oxlint-tsgolint": "^0.2.0",
     "prettier": "^3.6.1",
     "typescript": "^5.8.3",
     "typescript-eslint": "^8.35.0",
     "vite": "^7.0.0",
     "vite-plugin-dts": "^4.5.4",
-    "vitest": "^3.2.4"
+    "vitest": "^4.0.0"
   },
   "lint-staged": {
     "*": "prettier --ignore-unknown --write"
@@ -82,11 +84,11 @@
   "dependencies": {
     "commander": "^14.0.0",
     "globals": "^16.3.0",
-    "oxc-parser": "^0.95.0",
+    "oxc-parser": "^0.96.0",
     "tinyglobby": "^0.2.14"
   },
   "peerDependencies": {
     "jiti": "*"
   },
-  "packageManager": "pnpm@10.18.3"
+  "packageManager": "pnpm@10.20.0"
 }