@oxlint/migrate 0.0.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025-present VoidZero Inc. & Contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,40 @@
+# oxlint-migrate
+
+Generates a `.oxlintrc.json` from a existing eslint v9 configuration
+
+🚧 Still under development
+
+## Usage
+
+`npx oxlint-migrate <optional-eslint-v9-config-path>`
+
+When no config file provided, we look at the default eslint config filenames in the current directory.
+
+### User Flow
+
+- Upgrade `oxlint` and `oxlint-migrate` to the same version.
+- Execute `npx oxlint-migrate`
+- (Optional): Disable supported rules via [eslint-plugin-oxlint](https://github.com/oxc-project/eslint-plugin-oxlint)
+
+## Contributing
+
+### Generate rules
+
+Generates the rules from installed oxlint version
+
+```shell
+pnpm generate
+pnpm format
+```
+
+### Vitest + Integration Test
+
+```shell
+pnpm vitest
+```
+
+### Manual Testing
+
+```shell
+pnpm manual-test
+```

package/dist/bin/autoDetectConfigFile.mjs

@@ -0,0 +1,21 @@
+import { existsSync } from "fs";
+import path from "node:path";
+const FLAT_CONFIG_FILENAMES = [
+  "eslint.config.js",
+  "eslint.config.mjs",
+  "eslint.config.cjs",
+  "eslint.config.ts",
+  "eslint.config.mts",
+  "eslint.config.cts"
+];
+const getAutodetectedEslintConfigName = (cwd) => {
+  for (const filename of FLAT_CONFIG_FILENAMES) {
+    const filePath = path.join(cwd, filename);
+    if (existsSync(filePath)) {
+      return filePath;
+    }
+  }
+};
+export {
+  getAutodetectedEslintConfigName
+};

package/dist/bin/oxlint-migrate.mjs

@@ -0,0 +1,26 @@
+#!/usr/bin/env node
+import { program } from "commander";
+import { getAutodetectedEslintConfigName } from "./autoDetectConfigFile.mjs";
+import { existsSync, renameSync, writeFileSync } from "fs";
+import main from "../src/index.mjs";
+import path from "path";
+program.name("oxlint-migrate").version("0.0.0").argument("<eslint-config>", "The path to the eslint v9 config file");
+program.parse();
+let [filePath] = program.args;
+let cwd = process.cwd();
+if (filePath === "") {
+  filePath = getAutodetectedEslintConfigName(cwd) ?? "";
+} else {
+  filePath = path.join(cwd, filePath);
+}
+if (!existsSync(filePath)) {
+  program.error(`eslint config file not found: ${filePath}`);
+} else {
+  const eslintConfigs = await import(filePath);
+  const oxlintConfig = "default" in eslintConfigs ? await main(eslintConfigs.default, console.warn) : await main(eslintConfigs, console.warn);
+  const oxlintFilePath = path.join(cwd, ".oxlintrc.json");
+  if (existsSync(oxlintFilePath)) {
+    renameSync(oxlintFilePath, `${oxlintFilePath}.bak`);
+  }
+  writeFileSync(oxlintFilePath, JSON.stringify(oxlintConfig, null, 2));
+}

package/dist/src/cleanup.d.ts

@@ -0,0 +1,2 @@
+import { OxlintConfigOrOverride } from './types.js';
+export declare const cleanUpOxlintConfig: (config: OxlintConfigOrOverride) => void;

package/dist/src/cleanup.mjs

@@ -0,0 +1,127 @@
+import { removeGlobalsWithAreCoveredByEnv, ES_VERSIONS } from "./env_globals.mjs";
+const isEqualDeep = (a, b) => {
+  if (a === b) {
+    return true;
+  }
+  const bothAreObjects = a && b && typeof a === "object" && typeof b === "object";
+  return Boolean(
+    bothAreObjects && Object.keys(a).length === Object.keys(b).length && Object.entries(a).every(([k, v]) => isEqualDeep(v, b[k]))
+  );
+};
+const TS_ESLINT_DEFAULT_OVERRIDE = {
+  files: ["**/*.ts", "**/*.tsx", "**/*.mts", "**/*.cts"],
+  rules: {
+    "constructor-super": "off",
+    "getter-return": "off",
+    "no-class-assign": "off",
+    "no-const-assign": "off",
+    "no-dupe-class-members": "off",
+    "no-dupe-keys": "off",
+    "no-func-assign": "off",
+    "no-import-assign": "off",
+    "no-new-native-nonconstructor": "off",
+    "no-obj-calls": "off",
+    "no-redeclare": "off",
+    "no-setter-return": "off",
+    "no-this-before-super": "off",
+    "no-undef": "off",
+    "no-unreachable": "off",
+    "no-unsafe-negation": "off",
+    "no-var": "error",
+    "prefer-rest-params": "error",
+    "prefer-spread": "error"
+  }
+};
+const cleanUpDefaultTypeScriptOverridesForEslint = (config) => {
+  if (config.overrides === void 0) {
+    return;
+  }
+  const indexesToDelete = [];
+  for (const index in config.overrides) {
+    const override = config.overrides[index];
+    if (isEqualDeep(override, TS_ESLINT_DEFAULT_OVERRIDE)) {
+      indexesToDelete.push(index);
+    }
+  }
+  indexesToDelete.forEach((index) => delete config.overrides[index]);
+  if (Object.keys(config.overrides).length === 0) {
+    delete config.overrides;
+  }
+};
+const cleanUpUselessOverridesEntries = (config) => {
+  if (config.overrides === void 0) {
+    return;
+  }
+  config.overrides = config.overrides.filter(
+    (overrides) => Object.keys(overrides).length > 0
+  );
+  if (config.plugins !== void 0) {
+    for (const override of config.overrides) {
+      if (override.plugins === void 0) {
+        continue;
+      }
+      override.plugins = override.plugins.filter(
+        (overridePlugin) => !config.plugins.includes(overridePlugin)
+      );
+      if (override.plugins.length === 0) {
+        delete override.plugins;
+      }
+    }
+  }
+  if (config.env !== void 0) {
+    for (const override of config.overrides) {
+      if (override.env === void 0) {
+        continue;
+      }
+      for (const [overrideEnv, overrideEnvConfig] of Object.entries(
+        override.env
+      )) {
+        if (overrideEnv in config.env && config.env[overrideEnv] === overrideEnvConfig) {
+          delete override.env[overrideEnv];
+        }
+      }
+      if (Object.keys(override.env).length === 0) {
+        delete override.env;
+      }
+    }
+  }
+  if (config.overrides.length === 0) {
+    delete config.overrides;
+  }
+};
+const cleanUpOxlintConfig = (config) => {
+  removeGlobalsWithAreCoveredByEnv(config);
+  if (config.globals !== void 0 && Object.keys(config.globals).length === 0) {
+    delete config.globals;
+  }
+  if (config.env !== void 0) {
+    delete config.env.es3;
+    delete config.env.es5;
+    delete config.env.es2015;
+    let detected = false;
+    for (const esVersion of ES_VERSIONS.reverse()) {
+      if (detected) {
+        delete config.env[`es${esVersion}`];
+      } else if (config.env[`es${esVersion}`] === true) {
+        detected = true;
+      }
+    }
+  }
+  if (config.rules !== void 0 && Object.keys(config.rules).length === 0) {
+    delete config.rules;
+  }
+  if ("files" in config) {
+    if (config.plugins !== void 0 && Object.keys(config.plugins).length === 0) {
+      delete config.plugins;
+    }
+    if (Object.keys(config).length === 1) {
+      delete config.files;
+    }
+  } else {
+    cleanUpDefaultTypeScriptOverridesForEslint(config);
+    cleanUpUselessOverridesEntries(config);
+  }
+};
+export {
+  cleanUpOxlintConfig
+};

package/dist/src/constants.d.ts

@@ -0,0 +1 @@
+export declare const rulesPrefixesForPlugins: Record<string, string>;

package/dist/src/constants.mjs

@@ -0,0 +1,17 @@
+const rulesPrefixesForPlugins = {
+  import: "import",
+  jest: "jest",
+  jsdoc: "jsdoc",
+  "jsx-a11y": "jsx-a11y",
+  "@next/next": "nextjs",
+  node: "node",
+  promise: "promise",
+  react: "react",
+  "react-perf": "react",
+  "@typescript-eslint": "typescript",
+  unicorn: "unicorn",
+  vitest: "vitest"
+};
+export {
+  rulesPrefixesForPlugins
+};

package/dist/src/env_globals.d.ts

@@ -0,0 +1,6 @@
+import { OxlintConfig, OxlintConfigOrOverride, Reporter } from './types.js';
+import { Linter } from 'eslint';
+export declare const ES_VERSIONS: number[];
+export declare const removeGlobalsWithAreCoveredByEnv: (config: OxlintConfig) => void;
+export declare const detectEnvironmentByGlobals: (config: OxlintConfig) => void;
+export declare const transformEnvAndGlobals: (eslintConfig: Linter.Config, targetConfig: OxlintConfigOrOverride, reporter?: Reporter) => void;

package/dist/src/env_globals.mjs

@@ -0,0 +1,125 @@
+import globals from "globals";
+const ES_VERSIONS = [
+  6,
+  2016,
+  2017,
+  2018,
+  2019,
+  2020,
+  2021,
+  2022,
+  2023,
+  2024,
+  2025
+];
+const OTHER_SUPPORTED_ENVS = [
+  "browser",
+  "node",
+  "shared-node-browser",
+  "worker",
+  "serviceworker",
+  "commonjs",
+  "amd",
+  "mocha",
+  "jasmine",
+  "jest",
+  "phantomjs",
+  "jquery",
+  "qunit",
+  "prototypejs",
+  "shelljs",
+  "meteor",
+  "mongo",
+  "protractor",
+  "applescript",
+  "nashorn",
+  "atomtest",
+  "embertest",
+  "webextensions",
+  "greasemonkey"
+];
+const SUPPORTED_ESLINT_PARSERS = ["typescript-eslint/parser"];
+const normalizeGlobValue = (value) => {
+  if (value === "readable" || value === "readonly" || value === false) {
+    return false;
+  }
+  if (value === "off") {
+    return void 0;
+  }
+  return true;
+};
+const removeGlobalsWithAreCoveredByEnv = (config) => {
+  if (config.globals === void 0 || config.env === void 0) {
+    return;
+  }
+  for (const [env, entries] of Object.entries(globals)) {
+    if (config.env[env] === true) {
+      for (const entry of Object.keys(entries)) {
+        if (normalizeGlobValue(config.globals[entry]) === entries[entry]) {
+          delete config.globals[entry];
+        }
+      }
+    }
+  }
+};
+const detectEnvironmentByGlobals = (config) => {
+  if (config.globals === void 0) {
+    return;
+  }
+  for (const [env, entries] of Object.entries(globals)) {
+    if (!env.startsWith("es") && !OTHER_SUPPORTED_ENVS.includes(env)) {
+      continue;
+    }
+    let search = Object.keys(entries);
+    let matches = search.filter(
+      (entry) => (
+        // @ts-ignore -- we already checked for undefined
+        entry in config.globals && // @ts-ignore -- filtering makes the key to any
+        normalizeGlobValue(config.globals[entry]) === entries[entry]
+      )
+    );
+    if (search.length === matches.length) {
+      if (config.env === void 0) {
+        config.env = {};
+      }
+      config.env[env] = true;
+    }
+  }
+};
+const transformEnvAndGlobals = (eslintConfig, targetConfig, reporter) => {
+  if (eslintConfig.languageOptions?.parser !== void 0 && !SUPPORTED_ESLINT_PARSERS.includes(
+    eslintConfig.languageOptions.parser.meta?.name
+  )) {
+    reporter !== void 0 && reporter(
+      "special parser detected: " + eslintConfig.languageOptions.parser.meta?.name
+    );
+  }
+  if (eslintConfig.languageOptions?.globals !== void 0) {
+    if (targetConfig.globals === void 0) {
+      targetConfig.globals = {};
+    }
+    Object.assign(targetConfig.globals, eslintConfig.languageOptions.globals);
+  }
+  if (eslintConfig.languageOptions?.ecmaVersion !== void 0) {
+    if (targetConfig.globals === void 0) {
+      targetConfig.globals = {};
+    }
+    if (eslintConfig.languageOptions?.ecmaVersion === "latest") {
+      if (targetConfig.env === void 0) {
+        targetConfig.env = {};
+      }
+      targetConfig.env[`es${ES_VERSIONS[ES_VERSIONS.length - 1]}`] = true;
+    } else if (ES_VERSIONS.includes(eslintConfig.languageOptions?.ecmaVersion)) {
+      if (targetConfig.env === void 0) {
+        targetConfig.env = {};
+      }
+      targetConfig.env[`es${eslintConfig.languageOptions?.ecmaVersion}`] = true;
+    }
+  }
+};
+export {
+  ES_VERSIONS,
+  detectEnvironmentByGlobals,
+  removeGlobalsWithAreCoveredByEnv,
+  transformEnvAndGlobals
+};

package/dist/src/env_globals.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/src/generated/rules.d.ts

@@ -0,0 +1,2 @@
+declare const rules: string[];
+export default rules;

package/dist/src/generated/rules.mjs

@@ -0,0 +1,529 @@
+const rules = [
+  "array-callback-return",
+  "constructor-super",
+  "default-case",
+  "default-case-last",
+  "default-param-last",
+  "eqeqeq",
+  "for-direction",
+  "func-names",
+  "getter-return",
+  "guard-for-in",
+  "max-classes-per-file",
+  "max-lines",
+  "max-params",
+  "new-cap",
+  "no-useless-call",
+  "no-extra-label",
+  "no-multi-assign",
+  "no-nested-ternary",
+  "no-labels",
+  "no-lone-blocks",
+  "no-restricted-imports",
+  "no-object-constructor",
+  "no-duplicate-imports",
+  "no-alert",
+  "no-array-constructor",
+  "no-async-promise-executor",
+  "no-await-in-loop",
+  "no-bitwise",
+  "no-caller",
+  "no-case-declarations",
+  "no-class-assign",
+  "no-compare-neg-zero",
+  "no-cond-assign",
+  "no-console",
+  "no-const-assign",
+  "no-constant-binary-expression",
+  "no-constant-condition",
+  "no-constructor-return",
+  "no-continue",
+  "no-control-regex",
+  "no-debugger",
+  "no-delete-var",
+  "no-div-regex",
+  "no-dupe-class-members",
+  "no-dupe-else-if",
+  "no-dupe-keys",
+  "no-duplicate-case",
+  "no-else-return",
+  "no-empty-character-class",
+  "no-empty-function",
+  "no-empty-pattern",
+  "no-empty-static-block",
+  "no-empty",
+  "no-eq-null",
+  "no-eval",
+  "no-ex-assign",
+  "no-extend-native",
+  "no-extra-boolean-cast",
+  "no-fallthrough",
+  "no-func-assign",
+  "no-global-assign",
+  "no-import-assign",
+  "no-inner-declarations",
+  "no-invalid-regexp",
+  "no-irregular-whitespace",
+  "no-iterator",
+  "no-label-var",
+  "no-loss-of-precision",
+  "no-magic-numbers",
+  "no-negated-condition",
+  "no-multi-str",
+  "no-new-func",
+  "no-new-native-nonconstructor",
+  "no-new-wrappers",
+  "no-new",
+  "no-nonoctal-decimal-escape",
+  "no-obj-calls",
+  "no-plusplus",
+  "no-proto",
+  "no-prototype-builtins",
+  "no-redeclare",
+  "no-regex-spaces",
+  "no-restricted-globals",
+  "no-return-assign",
+  "no-script-url",
+  "no-self-assign",
+  "no-self-compare",
+  "no-setter-return",
+  "no-shadow-restricted-names",
+  "no-sparse-arrays",
+  "no-template-curly-in-string",
+  "no-ternary",
+  "no-this-before-super",
+  "no-throw-literal",
+  "no-undef",
+  "no-undefined",
+  "no-unexpected-multiline",
+  "no-unreachable",
+  "no-unsafe-finally",
+  "no-unsafe-negation",
+  "no-unsafe-optional-chaining",
+  "no-unused-expressions",
+  "no-unused-labels",
+  "no-unused-private-class-members",
+  "no-unused-vars",
+  "no-useless-catch",
+  "no-useless-concat",
+  "no-useless-constructor",
+  "no-useless-escape",
+  "no-useless-rename",
+  "no-var",
+  "no-void",
+  "no-with",
+  "prefer-promise-reject-errors",
+  "prefer-exponentiation-operator",
+  "prefer-numeric-literals",
+  "prefer-object-has-own",
+  "prefer-object-spread",
+  "prefer-rest-params",
+  "prefer-spread",
+  "radix",
+  "require-await",
+  "require-yield",
+  "sort-imports",
+  "sort-keys",
+  "sort-vars",
+  "symbol-description",
+  "unicode-bom",
+  "use-isnan",
+  "valid-typeof",
+  "vars-on-top",
+  "yoda",
+  "import/default",
+  "import/export",
+  "import/first",
+  "import/no-named-default",
+  "import/no-namespace",
+  "import/max-dependencies",
+  "import/named",
+  "import/namespace",
+  "import/no-amd",
+  "import/no-commonjs",
+  "import/no-cycle",
+  "import/no-default-export",
+  "import/no-duplicates",
+  "import/no-dynamic-require",
+  "import/no-named-as-default",
+  "import/no-named-as-default-member",
+  "import/no-self-import",
+  "import/no-webpack-loader-syntax",
+  "import/unambiguous",
+  "jest/consistent-test-it",
+  "jest/expect-expect",
+  "jest/max-expects",
+  "jest/max-nested-describe",
+  "jest/no-alias-methods",
+  "jest/no-commented-out-tests",
+  "jest/no-conditional-expect",
+  "jest/no-conditional-in-test",
+  "jest/no-confusing-set-timeout",
+  "jest/no-deprecated-functions",
+  "jest/no-disabled-tests",
+  "jest/no-done-callback",
+  "jest/no-duplicate-hooks",
+  "jest/no-export",
+  "jest/no-focused-tests",
+  "jest/no-hooks",
+  "jest/no-identical-title",
+  "jest/no-interpolation-in-snapshots",
+  "jest/no-jasmine-globals",
+  "jest/no-large-snapshots",
+  "jest/no-mocks-import",
+  "jest/no-restricted-jest-methods",
+  "jest/no-restricted-matchers",
+  "jest/no-standalone-expect",
+  "jest/no-test-prefixes",
+  "jest/no-test-return-statement",
+  "jest/no-untyped-mock-factory",
+  "jest/prefer-each",
+  "jest/prefer-called-with",
+  "jest/prefer-comparison-matcher",
+  "jest/prefer-equality-matcher",
+  "jest/prefer-expect-resolves",
+  "jest/prefer-hooks-in-order",
+  "jest/prefer-hooks-on-top",
+  "jest/prefer-jest-mocked",
+  "jest/prefer-lowercase-title",
+  "jest/prefer-mock-promise-shorthand",
+  "jest/prefer-spy-on",
+  "jest/prefer-strict-equal",
+  "jest/prefer-to-be",
+  "jest/prefer-to-contain",
+  "jest/prefer-to-have-length",
+  "jest/prefer-todo",
+  "jest/require-hook",
+  "jest/require-to-throw-message",
+  "jest/require-top-level-describe",
+  "jest/valid-describe-callback",
+  "jest/valid-expect",
+  "jest/valid-title",
+  "jsdoc/check-access",
+  "jsdoc/check-property-names",
+  "jsdoc/check-tag-names",
+  "jsdoc/empty-tags",
+  "jsdoc/implements-on-classes",
+  "jsdoc/no-defaults",
+  "jsdoc/require-param",
+  "jsdoc/require-param-description",
+  "jsdoc/require-param-name",
+  "jsdoc/require-param-type",
+  "jsdoc/require-property",
+  "jsdoc/require-property-description",
+  "jsdoc/require-property-name",
+  "jsdoc/require-property-type",
+  "jsdoc/require-returns",
+  "jsdoc/require-returns-description",
+  "jsdoc/require-returns-type",
+  "jsdoc/require-yields",
+  "jsx-a11y/alt-text",
+  "jsx-a11y/anchor-has-content",
+  "jsx-a11y/anchor-is-valid",
+  "jsx-a11y/aria-activedescendant-has-tabindex",
+  "jsx-a11y/aria-props",
+  "jsx-a11y/aria-role",
+  "jsx-a11y/aria-unsupported-elements",
+  "jsx-a11y/autocomplete-valid",
+  "jsx-a11y/click-events-have-key-events",
+  "jsx-a11y/heading-has-content",
+  "jsx-a11y/html-has-lang",
+  "jsx-a11y/iframe-has-title",
+  "jsx-a11y/img-redundant-alt",
+  "jsx-a11y/label-has-associated-control",
+  "jsx-a11y/lang",
+  "jsx-a11y/media-has-caption",
+  "jsx-a11y/mouse-events-have-key-events",
+  "jsx-a11y/no-noninteractive-tabindex",
+  "jsx-a11y/no-access-key",
+  "jsx-a11y/no-aria-hidden-on-focusable",
+  "jsx-a11y/no-autofocus",
+  "jsx-a11y/no-distracting-elements",
+  "jsx-a11y/no-redundant-roles",
+  "jsx-a11y/prefer-tag-over-role",
+  "jsx-a11y/role-has-required-aria-props",
+  "jsx-a11y/role-supports-aria-props",
+  "jsx-a11y/scope",
+  "jsx-a11y/tabindex-no-positive",
+  "jsx-a11y/anchor-ambiguous-text",
+  "@next/next/google-font-display",
+  "@next/next/google-font-preconnect",
+  "@next/next/inline-script-id",
+  "@next/next/next-script-for-ga",
+  "@next/next/no-assign-module-variable",
+  "@next/next/no-async-client-component",
+  "@next/next/no-before-interactive-script-outside-document",
+  "@next/next/no-css-tags",
+  "@next/next/no-document-import-in-page",
+  "@next/next/no-duplicate-head",
+  "@next/next/no-head-element",
+  "@next/next/no-head-import-in-document",
+  "@next/next/no-img-element",
+  "@next/next/no-page-custom-font",
+  "@next/next/no-script-component-in-head",
+  "@next/next/no-styled-jsx-in-document",
+  "@next/next/no-sync-scripts",
+  "@next/next/no-title-in-document-head",
+  "@next/next/no-typos",
+  "@next/next/no-unwanted-polyfillio",
+  "node/no-exports-assign",
+  "node/no-new-require",
+  "oxc/approx-constant",
+  "oxc/bad-array-method-on-arguments",
+  "oxc/bad-bitwise-operator",
+  "oxc/bad-char-at-comparison",
+  "oxc/bad-comparison-sequence",
+  "oxc/bad-min-max-func",
+  "oxc/bad-object-literal-comparison",
+  "oxc/bad-replace-all-arg",
+  "oxc/const-comparisons",
+  "oxc/double-comparisons",
+  "oxc/erasing-op",
+  "oxc/misrefactored-assign-op",
+  "oxc/missing-throw",
+  "oxc/no-accumulating-spread",
+  "oxc/no-async-await",
+  "oxc/no-async-endpoint-handlers",
+  "oxc/no-barrel-file",
+  "oxc/no-const-enum",
+  "oxc/no-map-spread",
+  "oxc/no-optional-chaining",
+  "oxc/no-rest-spread-properties",
+  "oxc/number-arg-out-of-range",
+  "oxc/only-used-in-recursion",
+  "oxc/uninvoked-array-callback",
+  "promise/avoid-new",
+  "promise/catch-or-return",
+  "promise/no-promise-in-callback",
+  "promise/no-callback-in-promise",
+  "promise/no-new-statics",
+  "promise/no-return-in-finally",
+  "promise/param-names",
+  "promise/prefer-await-to-callbacks",
+  "promise/prefer-await-to-then",
+  "promise/spec-only",
+  "promise/valid-params",
+  "react/button-has-type",
+  "react/checked-requires-onchange-or-readonly",
+  "react-hooks/exhaustive-deps",
+  "react/iframe-missing-sandbox",
+  "react/jsx-boolean-value",
+  "react/jsx-curly-brace-presence",
+  "react/jsx-key",
+  "react/jsx-no-comment-textnodes",
+  "react/jsx-no-duplicate-props",
+  "react/jsx-no-script-url",
+  "react/jsx-no-target-blank",
+  "react/jsx-no-undef",
+  "react/jsx-no-useless-fragment",
+  "react/jsx-props-no-spread-multi",
+  "react/no-array-index-key",
+  "react/no-children-prop",
+  "react/no-danger-with-children",
+  "react/no-danger",
+  "react/no-direct-mutation-state",
+  "react/no-find-dom-node",
+  "react/no-is-mounted",
+  "react/no-render-return-value",
+  "react/no-set-state",
+  "react/no-string-refs",
+  "react/no-unescaped-entities",
+  "react/no-unknown-property",
+  "react/prefer-es6-class",
+  "react/react-in-jsx-scope",
+  "react/require-render-return",
+  "react-hooks/rules-of-hooks",
+  "react/self-closing-comp",
+  "react/style-prop-object",
+  "react/void-dom-elements-no-children",
+  "react-perf/jsx-no-jsx-as-prop",
+  "react-perf/jsx-no-new-array-as-prop",
+  "react-perf/jsx-no-new-function-as-prop",
+  "react-perf/jsx-no-new-object-as-prop",
+  "@typescript-eslint/adjacent-overload-signatures",
+  "@typescript-eslint/array-type",
+  "@typescript-eslint/ban-ts-comment",
+  "@typescript-eslint/ban-tslint-comment",
+  "@typescript-eslint/ban-types",
+  "@typescript-eslint/consistent-generic-constructors",
+  "@typescript-eslint/consistent-indexed-object-style",
+  "@typescript-eslint/consistent-type-definitions",
+  "@typescript-eslint/consistent-type-imports",
+  "@typescript-eslint/explicit-function-return-type",
+  "@typescript-eslint/no-inferrable-types",
+  "@typescript-eslint/no-confusing-non-null-assertion",
+  "@typescript-eslint/no-duplicate-enum-values",
+  "@typescript-eslint/no-dynamic-delete",
+  "@typescript-eslint/no-empty-interface",
+  "@typescript-eslint/no-empty-object-type",
+  "@typescript-eslint/no-explicit-any",
+  "@typescript-eslint/no-extra-non-null-assertion",
+  "@typescript-eslint/no-extraneous-class",
+  "@typescript-eslint/no-import-type-side-effects",
+  "@typescript-eslint/no-misused-new",
+  "@typescript-eslint/no-namespace",
+  "@typescript-eslint/no-non-null-asserted-nullish-coalescing",
+  "@typescript-eslint/no-non-null-asserted-optional-chain",
+  "@typescript-eslint/no-non-null-assertion",
+  "@typescript-eslint/no-require-imports",
+  "@typescript-eslint/no-this-alias",
+  "@typescript-eslint/no-unnecessary-type-constraint",
+  "@typescript-eslint/no-unsafe-declaration-merging",
+  "@typescript-eslint/no-unsafe-function-type",
+  "@typescript-eslint/no-useless-empty-export",
+  "@typescript-eslint/no-var-requires",
+  "@typescript-eslint/no-wrapper-object-types",
+  "@typescript-eslint/prefer-as-const",
+  "@typescript-eslint/prefer-enum-initializers",
+  "@typescript-eslint/prefer-for-of",
+  "@typescript-eslint/prefer-function-type",
+  "@typescript-eslint/prefer-literal-enum-member",
+  "@typescript-eslint/prefer-namespace-keyword",
+  "@typescript-eslint/prefer-ts-expect-error",
+  "@typescript-eslint/triple-slash-reference",
+  "unicorn/catch-error-name",
+  "unicorn/consistent-empty-array-spread",
+  "unicorn/consistent-existence-index-check",
+  "unicorn/consistent-function-scoping",
+  "unicorn/empty-brace-spaces",
+  "unicorn/error-message",
+  "unicorn/escape-case",
+  "unicorn/explicit-length-check",
+  "unicorn/filename-case",
+  "unicorn/new-for-builtins",
+  "unicorn/no-abusive-eslint-disable",
+  "unicorn/no-anonymous-default-export",
+  "unicorn/no-array-for-each",
+  "unicorn/no-array-reduce",
+  "unicorn/no-await-expression-member",
+  "unicorn/no-await-in-promise-methods",
+  "unicorn/no-console-spaces",
+  "unicorn/no-document-cookie",
+  "unicorn/no-empty-file",
+  "unicorn/no-hex-escape",
+  "unicorn/no-instanceof-array",
+  "unicorn/no-invalid-remove-event-listener",
+  "unicorn/no-length-as-slice-end",
+  "unicorn/no-lonely-if",
+  "unicorn/no-magic-array-flat-depth",
+  "unicorn/no-negation-in-equality-check",
+  "unicorn/no-nested-ternary",
+  "unicorn/no-new-array",
+  "unicorn/no-new-buffer",
+  "unicorn/no-null",
+  "unicorn/no-object-as-default-parameter",
+  "unicorn/no-process-exit",
+  "unicorn/no-single-promise-in-promise-methods",
+  "unicorn/no-static-only-class",
+  "unicorn/no-thenable",
+  "unicorn/no-this-assignment",
+  "unicorn/no-typeof-undefined",
+  "unicorn/no-unnecessary-await",
+  "unicorn/no-unreadable-array-destructuring",
+  "unicorn/no-unreadable-iife",
+  "unicorn/no-useless-fallback-in-spread",
+  "unicorn/no-useless-length-check",
+  "unicorn/no-useless-promise-resolve-reject",
+  "unicorn/no-useless-spread",
+  "unicorn/no-useless-switch-case",
+  "unicorn/no-useless-undefined",
+  "unicorn/no-zero-fractions",
+  "unicorn/number-literal-case",
+  "unicorn/numeric-separators-style",
+  "unicorn/prefer-spread",
+  "unicorn/prefer-add-event-listener",
+  "unicorn/prefer-array-flat",
+  "unicorn/prefer-array-flat-map",
+  "unicorn/prefer-array-some",
+  "unicorn/prefer-blob-reading-methods",
+  "unicorn/prefer-code-point",
+  "unicorn/prefer-date-now",
+  "unicorn/prefer-dom-node-append",
+  "unicorn/prefer-dom-node-dataset",
+  "unicorn/prefer-dom-node-remove",
+  "unicorn/prefer-dom-node-text-content",
+  "unicorn/prefer-event-target",
+  "unicorn/prefer-includes",
+  "unicorn/prefer-logical-operator-over-ternary",
+  "unicorn/prefer-math-min-max",
+  "unicorn/prefer-math-trunc",
+  "unicorn/prefer-modern-dom-apis",
+  "unicorn/prefer-modern-math-apis",
+  "unicorn/prefer-native-coercion-functions",
+  "unicorn/prefer-negative-index",
+  "unicorn/prefer-node-protocol",
+  "unicorn/prefer-number-properties",
+  "unicorn/prefer-optional-catch-binding",
+  "unicorn/prefer-prototype-methods",
+  "unicorn/prefer-query-selector",
+  "unicorn/prefer-reflect-apply",
+  "unicorn/prefer-regexp-test",
+  "unicorn/prefer-set-has",
+  "unicorn/prefer-set-size",
+  "unicorn/prefer-string-raw",
+  "unicorn/prefer-string-replace-all",
+  "unicorn/prefer-string-slice",
+  "unicorn/prefer-string-starts-ends-with",
+  "unicorn/prefer-string-trim-start-end",
+  "unicorn/prefer-structured-clone",
+  "unicorn/prefer-type-error",
+  "unicorn/require-array-join-separator",
+  "unicorn/require-number-to-fixed-digits-argument",
+  "unicorn/switch-case-braces",
+  "unicorn/text-encoding-identifier-case",
+  "unicorn/throw-new-error",
+  "vitest/no-conditional-tests",
+  "vitest/no-import-node-test",
+  "vitest/prefer-to-be-falsy",
+  "vitest/prefer-to-be-object",
+  "vitest/prefer-to-be-truthy",
+  "vitest/require-local-test-context-for-concurrent-snapshots",
+  "@typescript-eslint/default-param-last",
+  "@typescript-eslint/max-params",
+  "@typescript-eslint/no-restricted-imports",
+  "@typescript-eslint/no-array-constructor",
+  "@typescript-eslint/no-dupe-class-members",
+  "@typescript-eslint/no-empty-function",
+  "@typescript-eslint/no-loss-of-precision",
+  "@typescript-eslint/no-magic-numbers",
+  "unicorn/no-negated-condition",
+  "@typescript-eslint/no-redeclare",
+  "@typescript-eslint/no-unused-expressions",
+  "@typescript-eslint/no-unused-vars",
+  "@typescript-eslint/no-useless-constructor",
+  "vitest/consistent-test-it",
+  "vitest/expect-expect",
+  "vitest/max-expects",
+  "vitest/max-nested-describe",
+  "vitest/no-alias-methods",
+  "vitest/no-commented-out-tests",
+  "vitest/no-conditional-expect",
+  "vitest/no-conditional-in-test",
+  "vitest/no-disabled-tests",
+  "vitest/no-duplicate-hooks",
+  "vitest/no-focused-tests",
+  "vitest/no-hooks",
+  "vitest/no-identical-title",
+  "vitest/no-interpolation-in-snapshots",
+  "vitest/no-restricted-jest-methods",
+  "vitest/no-restricted-matchers",
+  "vitest/no-test-prefixes",
+  "vitest/no-test-return-statement",
+  "vitest/prefer-each",
+  "vitest/prefer-comparison-matcher",
+  "vitest/prefer-equality-matcher",
+  "vitest/prefer-expect-resolves",
+  "vitest/prefer-hooks-in-order",
+  "vitest/prefer-hooks-on-top",
+  "vitest/prefer-mock-promise-shorthand",
+  "vitest/prefer-strict-equal",
+  "vitest/prefer-to-have-length",
+  "vitest/prefer-todo",
+  "vitest/require-to-throw-message",
+  "vitest/require-top-level-describe",
+  "vitest/valid-describe-callback",
+  "vitest/valid-expect"
+];
+export {
+  rules as default
+};

package/dist/src/ignorePatterns.d.ts

@@ -0,0 +1,3 @@
+import { Linter } from 'eslint';
+import { OxlintConfigOrOverride, Reporter } from './types.js';
+export declare const transformIgnorePatterns: (eslintConfig: Linter.Config, targetConfig: OxlintConfigOrOverride, reporter: Reporter) => void;

package/dist/src/ignorePatterns.mjs

@@ -0,0 +1,19 @@
+const transformIgnorePatterns = (eslintConfig, targetConfig, reporter) => {
+  if (eslintConfig.ignores === void 0) {
+    return;
+  }
+  if ("files" in targetConfig) {
+    reporter !== void 0 && reporter("ignore list inside overrides is not supported");
+    return;
+  }
+  if (targetConfig.ignorePatterns === void 0) {
+    targetConfig.ignorePatterns = [];
+  }
+  targetConfig.ignorePatterns.push(...eslintConfig.ignores);
+  eslintConfig.ignores.filter((ignore) => ignore.startsWith("!")).forEach(
+    (ignore) => reporter !== void 0 && reporter(`ignore allow list is currently not supported: ${ignore}`)
+  );
+};
+export {
+  transformIgnorePatterns
+};

package/dist/src/index.d.ts

@@ -0,0 +1,4 @@
+import { Linter } from 'eslint';
+import { OxlintConfig, Reporter } from './types.js';
+declare const main: (configs: Linter.Config | Linter.Config[] | Promise<Linter.Config> | Promise<Linter.Config[]>, reporter?: Reporter) => Promise<OxlintConfig>;
+export default main;

package/dist/src/index.mjs

@@ -0,0 +1,54 @@
+import { transformEnvAndGlobals, detectEnvironmentByGlobals } from "./env_globals.mjs";
+import { cleanUpOxlintConfig } from "./cleanup.mjs";
+import { transformIgnorePatterns } from "./ignorePatterns.mjs";
+import { transformRuleEntry, detectNeededRulesPlugins } from "./plugins_rules.mjs";
+const buildConfig = (configs, reporter) => {
+  const oxlintConfig = {
+    // disable all plugins and check later
+    plugins: [],
+    env: {
+      builtin: true
+    },
+    categories: {
+      // default category
+      correctness: "off"
+    }
+  };
+  const overrides = [];
+  for (const config of configs) {
+    if (config.name?.startsWith("oxlint/")) {
+      continue;
+    }
+    let targetConfig;
+    if (config.files === void 0) {
+      targetConfig = oxlintConfig;
+    } else {
+      targetConfig = {
+        files: Array.isArray(config.files) ? config.files : [config.files]
+      };
+      overrides.push(targetConfig);
+    }
+    if (config.plugins !== void 0) ;
+    if (config.settings !== void 0) ;
+    transformIgnorePatterns(config, targetConfig, reporter);
+    transformRuleEntry(config, targetConfig, reporter);
+    transformEnvAndGlobals(config, targetConfig, reporter);
+    if ("files" in targetConfig) {
+      detectNeededRulesPlugins(targetConfig, reporter);
+      detectEnvironmentByGlobals(targetConfig);
+      cleanUpOxlintConfig(targetConfig);
+    }
+  }
+  oxlintConfig.overrides = overrides;
+  detectNeededRulesPlugins(oxlintConfig, reporter);
+  detectEnvironmentByGlobals(oxlintConfig);
+  cleanUpOxlintConfig(oxlintConfig);
+  return oxlintConfig;
+};
+const main = async (configs, reporter = void 0) => {
+  const resolved = await Promise.resolve(configs);
+  return Array.isArray(resolved) ? buildConfig(resolved, reporter) : buildConfig([resolved], reporter);
+};
+export {
+  main as default
+};

package/dist/src/index.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/src/plugins_rules.d.ts

@@ -0,0 +1,4 @@
+import { Linter } from 'eslint';
+import { OxlintConfigOrOverride, Reporter } from './types.js';
+export declare const transformRuleEntry: (eslintConfig: Linter.Config, targetConfig: OxlintConfigOrOverride, reporter: Reporter) => void;
+export declare const detectNeededRulesPlugins: (targetConfig: OxlintConfigOrOverride, reporter: Reporter) => void;

package/dist/src/plugins_rules.mjs

@@ -0,0 +1,48 @@
+import rules from "./generated/rules.mjs";
+import { rulesPrefixesForPlugins } from "./constants.mjs";
+const isValueInSet = (value, validSet) => validSet.includes(value) || Array.isArray(value) && validSet.includes(value[0]);
+const isActiveValue = (value) => isValueInSet(value, ["error", "warn", 1, 2]);
+const transformRuleEntry = (eslintConfig, targetConfig, reporter) => {
+  if (eslintConfig.rules === void 0) {
+    return;
+  }
+  if (targetConfig.rules === void 0) {
+    targetConfig.rules = {};
+  }
+  for (const [rule, config] of Object.entries(eslintConfig.rules)) {
+    if (rules.includes(rule)) {
+      targetConfig.rules[rule] = config;
+    } else {
+      if (isActiveValue(config)) {
+        reporter !== void 0 && reporter(`unsupported rule: ${rule}`);
+      }
+    }
+  }
+};
+const detectNeededRulesPlugins = (targetConfig, reporter) => {
+  if (targetConfig.rules === void 0) {
+    return;
+  }
+  if (targetConfig.plugins === void 0) {
+    targetConfig.plugins = [];
+  }
+  for (const rule of Object.keys(targetConfig.rules)) {
+    if (!rule.includes("/")) {
+      continue;
+    }
+    let found = false;
+    for (const [prefix, plugin] of Object.entries(rulesPrefixesForPlugins)) {
+      if (rule.startsWith(`${prefix}/`) && !targetConfig.plugins.includes(plugin)) {
+        targetConfig.plugins.push(plugin);
+        found = true;
+      }
+    }
+    if (!found) {
+      reporter !== void 0 && reporter(`unsupported plugin for rule: ${rule}`);
+    }
+  }
+};
+export {
+  detectNeededRulesPlugins,
+  transformRuleEntry
+};

package/dist/src/types.d.ts

@@ -0,0 +1,24 @@
+import { Linter } from 'eslint';
+type OxlintConfigPlugins = string[];
+type OxlintConfigCategories = Record<string, unknown>;
+type OxlintConfigEnv = Record<string, boolean>;
+type OxlintConfigIgnorePatterns = string[];
+export type OxlintConfigOverride = {
+    files: string[];
+    env?: OxlintConfigEnv;
+    globals?: Linter.Globals;
+    plugins?: OxlintConfigPlugins;
+    rules?: Partial<Linter.RulesRecord>;
+};
+export type OxlintConfig = {
+    env?: OxlintConfigEnv;
+    globals?: Linter.Globals;
+    plugins?: OxlintConfigPlugins;
+    categories?: OxlintConfigCategories;
+    rules?: Partial<Linter.RulesRecord>;
+    overrides?: OxlintConfigOverride[];
+    ignorePatterns?: OxlintConfigIgnorePatterns;
+};
+export type OxlintConfigOrOverride = OxlintConfig | OxlintConfigOverride;
+export type Reporter = ((warning: string) => void) | undefined;
+export {};

package/package.json

@@ -0,0 +1,50 @@
+{
+  "name": "@oxlint/migrate",
+  "version": "0.0.1",
+  "description": "",
+  "main": "index.js",
+  "type": "module",
+  "bin": {
+    "oxlint-migrate": "./dist/bin/oxlint-migrate.mjs"
+  },
+  "files": [
+    "dist/*",
+    "README.md"
+  ],
+  "keywords": [
+    "oxc",
+    "oxlint",
+    "eslint",
+    "rules"
+  ],
+  "author": "Sysix <sysix@sysix-coding.de>",
+  "license": "MIT",
+  "devDependencies": {
+    "@oxc-node/core": "^0.0.19",
+    "@types/node": "^22.13.1",
+    "eslint": "^9.20.1",
+    "husky": "^9.1.7",
+    "lint-staged": "^15.4.3",
+    "oxlint": "^0.15.10",
+    "prettier": "^3.5.0",
+    "typescript": "^5.7.3",
+    "vite": "^6.1.0",
+    "vite-plugin-dts": "^4.5.0",
+    "vitest": "^3.0.5"
+  },
+  "lint-staged": {
+    "*": "prettier --ignore-unknown --write"
+  },
+  "dependencies": {
+    "commander": "^13.1.0",
+    "globals": "^15.14.0"
+  },
+  "scripts": {
+    "generate": "node --import @oxc-node/core/register ./scripts/generate.ts",
+    "format": "npx prettier --write .",
+    "type-check": "tsc --noEmit",
+    "test": "vitest",
+    "build": "vite build",
+    "manual-test": "pnpm build; chmod +x dist/bin/oxlint-migrate.mjs; npx . integration_test/projects/autoprefixer.eslint.config.mjs"
+  }
+}