@oxlint/migrate 1.55.0 → 1.57.0

package/README.md

@@ -114,8 +114,4 @@ Depending on how this is implemented by the given config, these behaviors may no
 
 The JS Plugins API supports almost all ESLint v9+ plugins for linting JS/TS/JSX/TSX files, but there are still some minor holes in support. See the [JS Plugins documentation](https://oxc.rs/docs/guide/usage/linter/js-plugins.html) for specifics.
 
-For example, if you currently use `eslint-plugin-prettier`, it will not work as a JS Plugin, as we do not support custom parsers for JS Plugins. To replace the functionality of `eslint-plugin-prettier`, you can use `prettier --check` in CI and/or your git pre-commit hooks to ensure code formatting is enforced.
-
-You could also consider [replacing Prettier with Oxfmt](https://oxc.rs/docs/guide/usage/formatter/migrate-from-prettier.html).
-
-Note that `eslint-config-prettier` is different from the prettier plugin, and _will_ be migrated fine, as it's just a config to disable formatting-related ESLint rules, not an actual plugin.
+For example, if you currently use `eslint-plugin-svelte`, only some of its rules will work via JS Plugin, as Oxlint does not yet fully support custom file formats like `.svelte`. This means that Oxlint will only be able to lint the script blocks in your `.svelte` files, and not the template blocks where many of the `eslint-plugin-svelte` rules apply.

package/dist/bin/oxlint-migrate.mjs

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-import { a as nurseryRules, i as buildUnsupportedRuleExplanations, n as preFixForJsPlugins, o as rules_exports, r as isOffValue, t as main } from "../src-DJ9UxHkF.mjs";
+import { a as nurseryRules, i as buildUnsupportedRuleExplanations, n as preFixForJsPlugins, o as rules_exports, r as isOffValue, t as main } from "../src-DEzNNXJD.mjs";
 import { program } from "commander";
 import { existsSync, readFileSync, renameSync, writeFileSync } from "node:fs";
 import path from "node:path";
@@ -30,7 +30,7 @@ const loadESLintConfig = async (filePath) => {
 };
 //#endregion
 //#region package.json
-var version = "1.55.0";
+var version = "1.57.0";
 //#endregion
 //#region src/walker/comments/replaceRuleDirectiveComment.ts
 const allRules = Object.values(rules_exports).flat();

package/dist/src/index.d.mts

@@ -1,3 +1,698 @@
+//#region node_modules/.pnpm/oxlint@1.57.0_oxlint-tsgolint@0.17.1/node_modules/oxlint/dist/index.d.ts
+//#region src-js/package/config.generated.d.ts
+type AllowWarnDeny = ("allow" | "off" | "warn" | "error" | "deny") | number;
+type GlobalValue = "readonly" | "writable" | "off";
+type ExternalPluginEntry = string | {
+  /**
+   * Custom name/alias for the plugin.
+   *
+   * Note: The following plugin names are reserved because they are implemented natively in Rust within oxlint and cannot be used for JS plugins:
+   * - react (includes react-hooks)
+   * - unicorn
+   * - typescript (includes @typescript-eslint)
+   * - oxc
+   * - import (includes import-x)
+   * - jsdoc
+   * - jest
+   * - vitest
+   * - jsx-a11y
+   * - nextjs
+   * - react-perf
+   * - promise
+   * - node
+   * - vue
+   * - eslint
+   *
+   * If you need to use the JavaScript version of any of these plugins, provide a custom alias to avoid conflicts.
+   */
+  name: string;
+  /**
+   * Path or package name of the plugin
+   */
+  specifier: string;
+};
+/**
+ * A set of glob patterns.
+ */
+type GlobSet = string[];
+type LintPluginOptionsSchema = "eslint" | "react" | "unicorn" | "typescript" | "oxc" | "import" | "jsdoc" | "jest" | "vitest" | "jsx-a11y" | "nextjs" | "react-perf" | "promise" | "node" | "vue";
+type LintPlugins = LintPluginOptionsSchema[];
+type DummyRule = AllowWarnDeny | unknown[];
+type OxlintOverrides = OxlintOverride[];
+type TagNamePreference = string | {
+  message: string;
+  replacement: string;
+  [k: string]: unknown;
+} | {
+  message: string;
+  [k: string]: unknown;
+} | boolean;
+type OneOrManyFor_String = string | string[];
+type CustomComponent = string | {
+  attribute: string;
+  name: string;
+  [k: string]: unknown;
+} | {
+  attributes: string[];
+  name: string;
+  [k: string]: unknown;
+};
+/**
+ * Oxlint Configuration File
+ *
+ * This configuration is aligned with ESLint v8's configuration schema (`eslintrc.json`).
+ *
+ * Usage: `oxlint -c oxlintrc.json`
+ *
+ * Example
+ *
+ * `.oxlintrc.json`
+ *
+ * ```json
+ * {
+ *   "$schema": "./node_modules/oxlint/configuration_schema.json",
+ *   "plugins": [
+ *     "import",
+ *     "typescript",
+ *     "unicorn"
+ *   ],
+ *   "env": {
+ *     "browser": true
+ *   },
+ *   "globals": {
+ *     "foo": "readonly"
+ *   },
+ *   "settings": {
+ *     "react": {
+ *       "version": "18.2.0"
+ *     },
+ *     "custom": {
+ *       "option": true
+ *     }
+ *   },
+ *   "rules": {
+ *     "eqeqeq": "warn",
+ *     "import/no-cycle": "error",
+ *     "react/self-closing-comp": [
+ *       "error",
+ *       {
+ *         "html": false
+ *       }
+ *     ]
+ *   },
+ *   "overrides": [
+ *     {
+ *       "files": [
+ *         "*.test.ts",
+ *         "*.spec.ts"
+ *       ],
+ *       "rules": {
+ *         "@typescript-eslint/no-explicit-any": "off"
+ *       }
+ *     }
+ *   ]
+ * }
+ * ```
+ *
+ * `oxlint.config.ts`
+ *
+ * ```ts
+ * import { defineConfig } from "oxlint";
+ *
+ * export default defineConfig({
+ * plugins: ["import", "typescript", "unicorn"],
+ * env: {
+ * "browser": true
+ * },
+ * globals: {
+ * "foo": "readonly"
+ * },
+ * settings: {
+ * react: {
+ * version: "18.2.0"
+ * },
+ * custom: { option: true }
+ * },
+ * rules: {
+ * "eqeqeq": "warn",
+ * "import/no-cycle": "error",
+ * "react/self-closing-comp": ["error", { "html": false }]
+ * },
+ * overrides: [
+ * {
+ * files: ["*.test.ts", "*.spec.ts"],
+ * rules: {
+ * "@typescript-eslint/no-explicit-any": "off"
+ * }
+ * }
+ * ]
+ * });
+ * ```
+ */
+interface Oxlintrc$1 {
+  /**
+   * Schema URI for editor tooling.
+   */
+  $schema?: string;
+  categories?: RuleCategories;
+  /**
+   * Environments enable and disable collections of global variables.
+   */
+  env?: OxlintEnv;
+  /**
+   * Paths of configuration files that this configuration file extends (inherits from). The files
+   * are resolved relative to the location of the configuration file that contains the `extends`
+   * property. The configuration files are merged from the first to the last, with the last file
+   * overriding the previous ones.
+   */
+  extends?: string[];
+  /**
+   * Enabled or disabled specific global variables.
+   */
+  globals?: OxlintGlobals;
+  /**
+   * Globs to ignore during linting. These are resolved from the configuration file path.
+   */
+  ignorePatterns?: string[];
+  /**
+   * JS plugins, allows usage of ESLint plugins with Oxlint.
+   *
+   * Read more about JS plugins in
+   * [the docs](https://oxc.rs/docs/guide/usage/linter/js-plugins.html).
+   *
+   * Note: JS plugins are in alpha and not subject to semver.
+   *
+   * Examples:
+   *
+   * Basic usage with a local plugin path.
+   *
+   * ```json
+   * {
+   *   "jsPlugins": [
+   *     "./custom-plugin.js"
+   *   ],
+   *   "rules": {
+   *     "custom/rule-name": "warn"
+   *   }
+   * }
+   * ```
+   *
+   * Using a built-in Rust plugin alongside a JS plugin with the same name
+   * by giving the JS plugin an alias.
+   *
+   * ```json
+   * {
+   *   "plugins": [
+   *     "import"
+   *   ],
+   *   "jsPlugins": [
+   *     {
+   *       "name": "import-js",
+   *       "specifier": "eslint-plugin-import"
+   *     }
+   *   ],
+   *   "rules": {
+   *     "import/no-cycle": "error",
+   *     "import-js/no-unresolved": "warn"
+   *   }
+   * }
+   * ```
+   */
+  jsPlugins?: null | ExternalPluginEntry[];
+  /**
+   * Oxlint config options.
+   */
+  options?: OxlintOptions;
+  /**
+   * Add, remove, or otherwise reconfigure rules for specific files or groups of files.
+   */
+  overrides?: OxlintOverrides;
+  /**
+   * Enabled built-in plugins for Oxlint.
+   * You can view the list of available plugins on
+   * [the website](https://oxc.rs/docs/guide/usage/linter/plugins.html#supported-plugins).
+   *
+   * NOTE: Setting the `plugins` field will overwrite the base set of plugins.
+   * The `plugins` array should reflect all of the plugins you want to use.
+   */
+  plugins?: LintPlugins;
+  /**
+   * Example
+   *
+   * `.oxlintrc.json`
+   *
+   * ```json
+   * {
+   *   "$schema": "./node_modules/oxlint/configuration_schema.json",
+   *   "rules": {
+   *     "eqeqeq": "warn",
+   *     "import/no-cycle": "error",
+   *     "prefer-const": [
+   *       "error",
+   *       {
+   *         "ignoreReadBeforeAssign": true
+   *       }
+   *     ]
+   *   }
+   * }
+   * ```
+   *
+   * See [Oxlint Rules](https://oxc.rs/docs/guide/usage/linter/rules.html) for the list of
+   * rules.
+   */
+  rules?: DummyRuleMap;
+  /**
+   * Plugin-specific configuration for both built-in and custom plugins.
+   * This includes settings for built-in plugins such as `react` and `jsdoc`
+   * as well as configuring settings for JS custom plugins loaded via `jsPlugins`.
+   */
+  settings?: OxlintPluginSettings;
+}
+/**
+ * Configure an entire category of rules all at once.
+ *
+ * Rules enabled or disabled this way will be overwritten by individual rules in the `rules` field.
+ *
+ * Example
+ * ```json
+ * {
+ *   "$schema": "./node_modules/oxlint/configuration_schema.json",
+ *   "categories": {
+ *     "correctness": "warn"
+ *   },
+ *   "rules": {
+ *     "eslint/no-unused-vars": "error"
+ *   }
+ * }
+ * ```
+ */
+interface RuleCategories {
+  correctness?: AllowWarnDeny;
+  nursery?: AllowWarnDeny;
+  pedantic?: AllowWarnDeny;
+  perf?: AllowWarnDeny;
+  restriction?: AllowWarnDeny;
+  style?: AllowWarnDeny;
+  suspicious?: AllowWarnDeny;
+}
+/**
+ * Predefine global variables.
+ *
+ * Environments specify what global variables are predefined.
+ * See [ESLint's list of environments](https://eslint.org/docs/v8.x/use/configure/language-options#specifying-environments)
+ * for what environments are available and what each one provides.
+ */
+interface OxlintEnv {
+  [k: string]: boolean;
+}
+/**
+ * Add or remove global variables.
+ *
+ * For each global variable, set the corresponding value equal to `"writable"`
+ * to allow the variable to be overwritten or `"readonly"` to disallow overwriting.
+ *
+ * Globals can be disabled by setting their value to `"off"`. For example, in
+ * an environment where most Es2015 globals are available but `Promise` is unavailable,
+ * you might use this config:
+ *
+ * ```json
+ * {
+ *   "$schema": "./node_modules/oxlint/configuration_schema.json",
+ *   "env": {
+ *     "es6": true
+ *   },
+ *   "globals": {
+ *     "Promise": "off"
+ *   }
+ * }
+ * ```
+ *
+ * You may also use `"readable"` or `false` to represent `"readonly"`, and
+ * `"writeable"` or `true` to represent `"writable"`.
+ */
+interface OxlintGlobals {
+  [k: string]: GlobalValue;
+}
+/**
+ * Options for the linter.
+ */
+interface OxlintOptions {
+  /**
+   * Ensure warnings produce a non-zero exit code.
+   *
+   * Equivalent to passing `--deny-warnings` on the CLI.
+   */
+  denyWarnings?: boolean;
+  /**
+   * Specify a warning threshold. Exits with an error status if warnings exceed this value.
+   *
+   * Equivalent to passing `--max-warnings` on the CLI.
+   */
+  maxWarnings?: number;
+  /**
+   * Report unused disable directives (e.g. `// oxlint-disable-line` or `// eslint-disable-line`).
+   *
+   * Equivalent to passing `--report-unused-disable-directives-severity` on the CLI.
+   * CLI flags take precedence over this value when both are set.
+   * Only supported in the root configuration file.
+   */
+  reportUnusedDisableDirectives?: AllowWarnDeny;
+  /**
+   * Enable rules that require type information.
+   *
+   * Equivalent to passing `--type-aware` on the CLI.
+   *
+   * Note that this requires the `oxlint-tsgolint` package to be installed.
+   */
+  typeAware?: boolean;
+  /**
+   * Enable experimental type checking (includes TypeScript compiler diagnostics).
+   *
+   * Equivalent to passing `--type-check` on the CLI.
+   *
+   * Note that this requires the `oxlint-tsgolint` package to be installed.
+   */
+  typeCheck?: boolean;
+}
+interface OxlintOverride {
+  /**
+   * Environments enable and disable collections of global variables.
+   */
+  env?: OxlintEnv;
+  /**
+   * A list of glob patterns to override.
+   *
+   * ## Example
+   * `[ "*.test.ts", "*.spec.ts" ]`
+   */
+  files: GlobSet;
+  /**
+   * Enabled or disabled specific global variables.
+   */
+  globals?: OxlintGlobals;
+  /**
+   * JS plugins for this override, allows usage of ESLint plugins with Oxlint.
+   *
+   * Read more about JS plugins in
+   * [the docs](https://oxc.rs/docs/guide/usage/linter/js-plugins.html).
+   *
+   * Note: JS plugins are in alpha and not subject to semver.
+   */
+  jsPlugins?: null | ExternalPluginEntry[];
+  /**
+   * Optionally change what plugins are enabled for this override. When
+   * omitted, the base config's plugins are used.
+   */
+  plugins?: LintPlugins;
+  rules?: DummyRuleMap;
+}
+/**
+ * See [Oxlint Rules](https://oxc.rs/docs/guide/usage/linter/rules.html)
+ */
+interface DummyRuleMap {
+  [k: string]: DummyRule;
+}
+/**
+ * Configure the behavior of linter plugins.
+ *
+ * Here's an example if you're using Next.js in a monorepo:
+ *
+ * ```json
+ * {
+ *   "settings": {
+ *     "next": {
+ *       "rootDir": "apps/dashboard/"
+ *     },
+ *     "react": {
+ *       "linkComponents": [
+ *         {
+ *           "name": "Link",
+ *           "linkAttribute": "to"
+ *         }
+ *       ]
+ *     },
+ *     "jsx-a11y": {
+ *       "components": {
+ *         "Link": "a",
+ *         "Button": "button"
+ *       }
+ *     }
+ *   }
+ * }
+ * ```
+ */
+interface OxlintPluginSettings {
+  jsdoc?: JSDocPluginSettings;
+  "jsx-a11y"?: JSXA11YPluginSettings;
+  next?: NextPluginSettings;
+  react?: ReactPluginSettings;
+  vitest?: VitestPluginSettings;
+  [k: string]: unknown;
+}
+interface JSDocPluginSettings {
+  /**
+   * Only for `require-(yields|returns|description|example|param|throws)` rule
+   */
+  augmentsExtendsReplacesDocs?: boolean;
+  /**
+   * Only for `require-param-type` and `require-param-description` rule
+   */
+  exemptDestructuredRootsFromChecks?: boolean;
+  /**
+   * For all rules but NOT apply to `empty-tags` rule
+   */
+  ignoreInternal?: boolean;
+  /**
+   * For all rules but NOT apply to `check-access` and `empty-tags` rule
+   */
+  ignorePrivate?: boolean;
+  /**
+   * Only for `require-(yields|returns|description|example|param|throws)` rule
+   */
+  ignoreReplacesDocs?: boolean;
+  /**
+   * Only for `require-(yields|returns|description|example|param|throws)` rule
+   */
+  implementsReplacesDocs?: boolean;
+  /**
+   * Only for `require-(yields|returns|description|example|param|throws)` rule
+   */
+  overrideReplacesDocs?: boolean;
+  tagNamePreference?: {
+    [k: string]: TagNamePreference;
+  };
+  [k: string]: unknown;
+}
+/**
+ * Configure JSX A11y plugin rules.
+ *
+ * See
+ * [eslint-plugin-jsx-a11y](https://github.com/jsx-eslint/eslint-plugin-jsx-a11y#configurations)'s
+ * configuration for a full reference.
+ */
+interface JSXA11YPluginSettings {
+  /**
+   * Map of attribute names to their DOM equivalents.
+   * This is useful for non-React frameworks that use different attribute names.
+   *
+   * Example:
+   *
+   * ```json
+   * {
+   *   "settings": {
+   *     "jsx-a11y": {
+   *       "attributes": {
+   *         "for": [
+   *           "htmlFor",
+   *           "for"
+   *         ]
+   *       }
+   *     }
+   *   }
+   * }
+   * ```
+   */
+  attributes?: {
+    [k: string]: string[];
+  };
+  /**
+   * To have your custom components be checked as DOM elements, you can
+   * provide a mapping of your component names to the DOM element name.
+   *
+   * Example:
+   *
+   * ```json
+   * {
+   *   "settings": {
+   *     "jsx-a11y": {
+   *       "components": {
+   *         "Link": "a",
+   *         "IconButton": "button"
+   *       }
+   *     }
+   *   }
+   * }
+   * ```
+   */
+  components?: {
+    [k: string]: string;
+  };
+  /**
+   * An optional setting that define the prop your code uses to create polymorphic components.
+   * This setting will be used to determine the element type in rules that
+   * require semantic context.
+   *
+   * For example, if you set the `polymorphicPropName` to `as`, then this element:
+   *
+   * ```jsx
+   * <Box as="h3">Hello</Box>
+   * ```
+   *
+   * Will be treated as an `h3`. If not set, this component will be treated
+   * as a `Box`.
+   */
+  polymorphicPropName?: string;
+  [k: string]: unknown;
+}
+/**
+ * Configure Next.js plugin rules.
+ */
+interface NextPluginSettings {
+  /**
+   * The root directory of the Next.js project.
+   *
+   * This is particularly useful when you have a monorepo and your Next.js
+   * project is in a subfolder.
+   *
+   * Example:
+   *
+   * ```json
+   * {
+   *   "settings": {
+   *     "next": {
+   *       "rootDir": "apps/dashboard/"
+   *     }
+   *   }
+   * }
+   * ```
+   */
+  rootDir?: OneOrManyFor_String;
+  [k: string]: unknown;
+}
+/**
+ * Configure React plugin rules.
+ *
+ * Derived from [eslint-plugin-react](https://github.com/jsx-eslint/eslint-plugin-react#configuration-legacy-eslintrc-)
+ */
+interface ReactPluginSettings {
+  /**
+   * Functions that wrap React components and should be treated as HOCs.
+   *
+   * Example:
+   *
+   * ```jsonc
+   * {
+   * "settings": {
+   * "react": {
+   * "componentWrapperFunctions": ["observer", "withRouter"]
+   * }
+   * }
+   * }
+   * ```
+   */
+  componentWrapperFunctions?: string[];
+  /**
+   * Components used as alternatives to `<form>` for forms, such as `<Formik>`.
+   *
+   * Example:
+   *
+   * ```jsonc
+   * {
+   * "settings": {
+   * "react": {
+   * "formComponents": [
+   * "CustomForm",
+   * // OtherForm is considered a form component and has an endpoint attribute
+   * { "name": "OtherForm", "formAttribute": "endpoint" },
+   * // allows specifying multiple properties if necessary
+   * { "name": "Form", "formAttribute": ["registerEndpoint", "loginEndpoint"] }
+   * ]
+   * }
+   * }
+   * }
+   * ```
+   */
+  formComponents?: CustomComponent[];
+  /**
+   * Components used as alternatives to `<a>` for linking, such as `<Link>`.
+   *
+   * Example:
+   *
+   * ```jsonc
+   * {
+   * "settings": {
+   * "react": {
+   * "linkComponents": [
+   * "HyperLink",
+   * // Use `linkAttribute` for components that use a different prop name
+   * // than `href`.
+   * { "name": "MyLink", "linkAttribute": "to" },
+   * // allows specifying multiple properties if necessary
+   * { "name": "Link", "linkAttribute": ["to", "href"] }
+   * ]
+   * }
+   * }
+   * }
+   * ```
+   */
+  linkComponents?: CustomComponent[];
+  /**
+   * React version to use for version-specific rules.
+   *
+   * Accepts semver versions (e.g., "18.2.0", "17.0").
+   *
+   * Example:
+   *
+   * ```jsonc
+   * {
+   * "settings": {
+   * "react": {
+   * "version": "18.2.0"
+   * }
+   * }
+   * }
+   * ```
+   */
+  version?: string;
+  [k: string]: unknown;
+}
+/**
+ * Configure Vitest plugin rules.
+ *
+ * See [eslint-plugin-vitest](https://github.com/vitest-dev/eslint-plugin-vitest)'s
+ * configuration for a full reference.
+ */
+interface VitestPluginSettings {
+  /**
+   * Whether to enable typecheck mode for Vitest rules.
+   * When enabled, some rules will skip certain checks for describe blocks
+   * to accommodate TypeScript type checking scenarios.
+   */
+  typecheck?: boolean;
+  [k: string]: unknown;
+} //#endregion
+//#region src-js/package/config.d.ts
+type Oxlintrc = Omit<Oxlintrc$1, "$schema" | "extends">;
+interface OxlintConfig$1 extends Oxlintrc {
+  extends?: OxlintConfig$1[];
+}
+/**
+ * Define an Oxlint configuration with type inference.
+ *
+ * @param config - Oxlint configuration
+ * @returns Config unchanged
+ */
+//#endregion
 //#region src/types.d.ts
 /**
  * ESLint type definitions compatible with ESLint 9 and 10.
@@ -97,39 +792,12 @@ declare namespace ESLint {
     [key: string]: any;
   }
 }
-type OxlintConfigPlugins = string[];
-type OxlintConfigJsPlugins = string[];
-type OxlintConfigCategories = Partial<Record<Category, unknown>>;
-type OxlintConfigEnv = Record<string, boolean>;
-type OxlintConfigIgnorePatterns = string[];
-type OxlintConfigGlobalsValue = 'readonly' | 'writable' | 'off';
-type OxlintSupportedSettingsKey = 'jsx-a11y' | 'next' | 'react' | 'jsdoc' | 'vitest';
-type OxlintSettings = { [K in OxlintSupportedSettingsKey]?: Record<string, unknown> } & Record<string, Record<string, unknown> | undefined>;
-type OxlintOptions = {
-  typeAware?: boolean;
-  typeCheck?: boolean;
-};
-type OxlintConfigOverride = {
-  files: string[];
-  env?: OxlintConfigEnv;
-  globals?: Record<string, OxlintConfigGlobalsValue>;
-  plugins?: OxlintConfigPlugins;
-  jsPlugins?: OxlintConfigJsPlugins;
-  categories?: OxlintConfigCategories;
-  rules?: Partial<ESLint.RulesRecord>;
-};
-type OxlintConfig = {
+type OxlintConfig = Omit<OxlintConfig$1, 'overrides'> & {
   $schema?: string;
-  env?: OxlintConfigEnv;
-  globals?: Record<string, OxlintConfigGlobalsValue>;
-  plugins?: OxlintConfigPlugins;
-  jsPlugins?: OxlintConfigJsPlugins;
-  categories?: OxlintConfigCategories;
-  rules?: Partial<ESLint.RulesRecord>;
   overrides?: OxlintConfigOverride[];
-  ignorePatterns?: OxlintConfigIgnorePatterns;
-  settings?: OxlintSettings;
-  options?: OxlintOptions;
+};
+type OxlintConfigOverride = OxlintOverride & {
+  categories?: RuleCategories;
 };
 type RuleSkippedCategory = 'nursery' | 'type-aware' | 'not-implemented' | 'unsupported' | 'js-plugins';
 type SkippedCategoryGroup = Record<RuleSkippedCategory, string[]>;
@@ -147,7 +815,6 @@ type Options = {
   typeAware?: boolean;
   jsPlugins?: boolean;
 };
-type Category = 'style' | 'correctness' | 'nursery' | 'suspicious' | 'pedantic' | 'perf' | 'restriction';
 //#endregion
 //#region src/index.d.ts
 declare const main: (configs: ESLint.Config | ESLint.Config[] | Promise<ESLint.Config> | Promise<ESLint.Config[]>, oxlintConfig?: OxlintConfig, options?: Options) => Promise<OxlintConfig>;

package/dist/src/index.mjs

@@ -1,2 +1,2 @@
-import { t as main } from "../src-DJ9UxHkF.mjs";
+import { t as main } from "../src-DEzNNXJD.mjs";
 export { main as default };

package/dist/{src-DJ9UxHkF.mjs → src-DEzNNXJD.mjs}

@@ -64,14 +64,14 @@ const normalizeGlobValue = (value) => {
 	return true;
 };
 const removeGlobalsWithAreCoveredByEnv = (config) => {
-	if (config.globals === void 0 || config.env === void 0) return;
+	if (config.globals === void 0 || config.globals === null || config.env === void 0 || config.env === null) 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];
 	}
 	if (Object.keys(config.globals).length === 0) delete config.globals;
 };
 const transformBoolGlobalToString = (config) => {
-	if (config.globals === void 0) return;
+	if (config.globals === void 0 || config.globals === null) return;
 	for (const [entry, value] of Object.entries(config.globals)) config.globals[entry] = transformEslintGlobalAccessToOxlintGlobalValue(value);
 };
 const transformEslintGlobalAccessToOxlintGlobalValue = (global) => {
@@ -86,7 +86,7 @@ const THRESHOLD_ENVS = [
 	"worker"
 ];
 const detectEnvironmentByGlobals = (config) => {
-	if (config.globals === void 0) return;
+	if (config.globals === void 0 || config.globals === null) return;
 	for (const [env, entries] of Object.entries(globals)) {
 		if (!env.startsWith("es") && !OTHER_SUPPORTED_ENVS.includes(env)) continue;
 		if (env.startsWith("es") && !ES_VERSIONS.includes(parseInt(env.replace(/^es/, "")))) continue;
@@ -94,7 +94,7 @@ const detectEnvironmentByGlobals = (config) => {
 		let matches = search.filter((entry) => entry in config.globals && normalizeGlobValue(config.globals[entry]) === entries[entry]);
 		const useThreshold = THRESHOLD_ENVS.includes(env);
 		if (useThreshold && matches.length / search.length >= .97 || !useThreshold && matches.length === search.length) {
-			if (config.env === void 0) config.env = {};
+			if (config.env === void 0 || config.env === null) config.env = {};
 			config.env[env] = true;
 		}
 	}
@@ -102,27 +102,27 @@ const detectEnvironmentByGlobals = (config) => {
 const transformEnvAndGlobals = (eslintConfig, targetConfig, options) => {
 	if (eslintConfig.languageOptions?.parser !== void 0 && eslintConfig.languageOptions?.parser !== null && typeof eslintConfig.languageOptions.parser === "object" && "meta" in eslintConfig.languageOptions.parser && !SUPPORTED_ESLINT_PARSERS.includes(eslintConfig.languageOptions.parser.meta?.name)) options?.reporter?.addWarning("special parser detected: " + eslintConfig.languageOptions.parser.meta?.name);
 	if (eslintConfig.languageOptions?.globals !== void 0 && eslintConfig.languageOptions?.globals !== null) {
-		if (targetConfig.globals === void 0) targetConfig.globals = {};
+		if (targetConfig.globals === void 0 || targetConfig.globals === null) targetConfig.globals = {};
 		if (options?.merge) {
 			for (const [global, globalSetting] of Object.entries(eslintConfig.languageOptions.globals)) if (!(global in targetConfig.globals)) targetConfig.globals[global] = transformEslintGlobalAccessToOxlintGlobalValue(globalSetting);
 		} else for (const [global, globalSetting] of Object.entries(eslintConfig.languageOptions.globals)) targetConfig.globals[global] = transformEslintGlobalAccessToOxlintGlobalValue(globalSetting);
 	}
 	if (eslintConfig.languageOptions?.ecmaVersion !== void 0) {
 		if (eslintConfig.languageOptions.ecmaVersion === "latest") {
-			if (targetConfig.env === void 0) targetConfig.env = {};
+			if (targetConfig.env === void 0 || targetConfig.env === null) targetConfig.env = {};
 			const latestVersion = `es${ES_VERSIONS[ES_VERSIONS.length - 1]}`;
 			if (!(latestVersion in targetConfig.env)) targetConfig.env[latestVersion] = true;
 		} else if (typeof eslintConfig.languageOptions.ecmaVersion === "number" && ES_VERSIONS.includes(eslintConfig.languageOptions.ecmaVersion)) {
-			if (targetConfig.env === void 0) targetConfig.env = {};
+			if (targetConfig.env === void 0 || targetConfig.env === null) targetConfig.env = {};
 			const targetVersion = `es${eslintConfig.languageOptions.ecmaVersion}`;
 			if (!(targetVersion in targetConfig.env)) targetConfig.env[targetVersion] = true;
 		}
 	}
 };
 const cleanUpUselessOverridesEnv = (config) => {
-	if (config.env === void 0 || config.overrides === void 0) return;
+	if (config.env === void 0 || config.env === null || config.overrides === void 0 || config.overrides === null) return;
 	for (const override of config.overrides) {
-		if (override.env === void 0) continue;
+		if (override.env === void 0 || override.env === null) 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;
 	}
@@ -148,7 +148,7 @@ const cleanUpSupersetEnvs = (config) => {
 		for (const subsetEnv of subsetEnvs) if (config.env[subsetEnv] === config.env[supersetEnv]) delete config.env[subsetEnv];
 	}
 	if (config.overrides !== void 0) for (const override of config.overrides) {
-		if (override.env === void 0) continue;
+		if (override.env === void 0 || override.env === null) continue;
 		for (const [supersetEnv, subsetEnvs] of Object.entries(SUPERSET_ENVS)) {
 			const supersetInOverride = supersetEnv in override.env;
 			const supersetInMain = config.env !== void 0 && supersetEnv in config.env;
@@ -440,6 +440,7 @@ const styleRules = [
 	"unicorn/catch-error-name",
 	"unicorn/consistent-date-clone",
 	"unicorn/consistent-existence-index-check",
+	"unicorn/custom-error-definition",
 	"unicorn/empty-brace-spaces",
 	"unicorn/error-message",
 	"unicorn/filename-case",
@@ -489,6 +490,7 @@ const styleRules = [
 	"vitest/prefer-describe-function-title",
 	"vitest/prefer-expect-type-of",
 	"vitest/prefer-import-in-mock",
+	"vitest/prefer-strict-boolean-matchers",
 	"vitest/prefer-to-be-falsy",
 	"vitest/prefer-to-be-object",
 	"vitest/prefer-to-be-truthy",
@@ -640,6 +642,7 @@ const restrictionRules = [
 	"jsdoc/check-access",
 	"jsdoc/empty-tags",
 	"jsx-a11y/anchor-ambiguous-text",
+	"node/handle-callback-err",
 	"node/no-new-require",
 	"node/no-path-concat",
 	"node/no-process-env",
@@ -701,6 +704,7 @@ const restrictionRules = [
 	"import-x/no-relative-parent-imports",
 	"import-x/no-webpack-loader-syntax",
 	"import-x/unambiguous",
+	"n/handle-callback-err",
 	"n/no-new-require",
 	"n/no-path-concat",
 	"n/no-process-env",
@@ -1185,12 +1189,12 @@ const enableJsPluginRule = (targetConfig, rule, ruleEntry, plugins) => {
 	const pluginName = extractPluginId(rule);
 	if (pluginName === void 0) return false;
 	if (ignorePlugins.has(pluginName)) return false;
-	if (targetConfig.jsPlugins === void 0) targetConfig.jsPlugins = [];
+	if (targetConfig.jsPlugins === void 0 || targetConfig.jsPlugins === null) targetConfig.jsPlugins = [];
 	const metaName = plugins?.[pluginName]?.meta?.name;
 	const eslintPluginName = metaName ? resolveFromMetaName(metaName) : resolveEslintPluginName(pluginName);
 	if (!targetConfig.jsPlugins.includes(eslintPluginName)) targetConfig.jsPlugins.push(eslintPluginName);
 	const resolvedRule = resolveJsPluginRuleName(rule, plugins);
-	targetConfig.rules = targetConfig.rules || {};
+	targetConfig.rules = targetConfig.rules ?? {};
 	targetConfig.rules[resolvedRule] = ruleEntry;
 	return true;
 };
@@ -1594,6 +1598,8 @@ function buildUnsupportedRuleExplanations() {
 //#region src/plugins_rules.ts
 const allRules = Object.values(rules_exports).flat();
 const unsupportedRuleExplanations = buildUnsupportedRuleExplanations();
+const OXFMT_SORTING_DOCS_URL = "https://oxc.rs/docs/guide/usage/formatter/sorting.html";
+const oxfmtImportSortingRules = new Set(["sort-imports", "perfectionist/sort-imports"]);
 /**
 * checks if value is validSet, or if validSet is an array, check if value is first value of it
 */
@@ -1610,6 +1616,10 @@ const isActiveValue = (value) => isValueInSet(value, [
 const isOffValue = (value) => isValueInSet(value, ["off", 0]);
 const isWarnValue = (value) => isValueInSet(value, ["warn", 1]);
 const isErrorValue = (value) => isValueInSet(value, ["error", 2]);
+const isOxfmtImportSortingRule = (rule) => oxfmtImportSortingRules.has(rule);
+const addOxfmtImportSortingWarning = (options) => {
+	options?.reporter?.addWarning("ESLint import-sorting rules like `sort-imports` were not migrated because they conflict with Oxfmt's import sorting.\nUse Oxfmt's `sortImports` formatter option instead. It is based on `eslint-plugin-perfectionist/sort-imports`, is disabled by default, and will need to be enabled.\n" + OXFMT_SORTING_DOCS_URL);
+};
 const normalizeSeverityValue = (value) => {
 	if (value === void 0) return value;
 	if (isWarnValue(value)) {
@@ -1673,6 +1683,10 @@ const transformRuleEntry = (eslintConfig, targetConfig, baseConfig, options, ove
 	for (const [originalRule, config] of Object.entries(eslintConfig.rules)) {
 		const rule = options?.typeAware && eslintRulesToTypescriptEquivalents[originalRule] !== void 0 ? eslintRulesToTypescriptEquivalents[originalRule] : originalRule;
 		const normalizedConfig = normalizeSeverityValue(config);
+		if (isOxfmtImportSortingRule(rule)) {
+			if (isActiveValue(normalizedConfig)) addOxfmtImportSortingWarning(options);
+			continue;
+		}
 		if (!options?.merge) {
 			removePreviousOverrideRule(rule, eslintConfig, overrides);
 			if (options?.jsPlugins) {
@@ -1733,7 +1747,7 @@ const transformRuleEntry = (eslintConfig, targetConfig, baseConfig, options, ove
 };
 const detectNeededRulesPlugins = (targetConfig) => {
 	if (targetConfig.rules === void 0) return;
-	if (targetConfig.plugins === void 0) targetConfig.plugins = [];
+	if (targetConfig.plugins === void 0 || targetConfig.plugins === null) targetConfig.plugins = [];
 	for (const rule of Object.keys(targetConfig.rules)) {
 		if (!rule.includes("/")) continue;
 		for (const [prefix, plugin] of Object.entries(rulesPrefixesForPlugins)) if (rule.startsWith(`${prefix}/`) && !targetConfig.plugins.includes(plugin)) targetConfig.plugins.push(plugin);
@@ -1742,8 +1756,8 @@ const detectNeededRulesPlugins = (targetConfig) => {
 };
 const cleanUpUselessOverridesPlugins = (config) => {
 	if (config.overrides === void 0) return;
-	if (config.plugins !== void 0) for (const override of config.overrides) {
-		if (override.plugins === void 0) continue;
+	if (config.plugins !== void 0 && config.plugins !== null) for (const override of config.overrides) {
+		if (override.plugins === void 0 || override.plugins === null) continue;
 		override.plugins = override.plugins.filter((overridePlugin) => !config.plugins.includes(overridePlugin));
 		if (override.plugins.length === 0) delete override.plugins;
 	}
@@ -1908,8 +1922,8 @@ const cleanUpOxlintConfig = (config) => {
 	replaceNodePluginName(config);
 	replaceReactRefreshPluginName(config);
 	cleanUpRulesWhichAreCoveredByCategory(config);
-	if (config.globals !== void 0 && Object.keys(config.globals).length === 0) delete config.globals;
-	if (config.env !== void 0) {
+	if (config.globals !== void 0 && config.globals !== null && Object.keys(config.globals).length === 0) delete config.globals;
+	if (config.env !== void 0 && config.env !== null) {
 		delete config.env.es3;
 		delete config.env.es5;
 		delete config.env.es2015;
@@ -2168,6 +2182,19 @@ const warnSettingsInOverride = (eslintConfig, options) => {
 };
 //#endregion
 //#region src/index.ts
+const KEY_ORDER = [
+	"$schema",
+	"plugins",
+	"jsPlugins",
+	"categories",
+	"options",
+	"env",
+	"globals",
+	"settings",
+	"ignorePatterns",
+	"rules",
+	"overrides"
+];
 const buildConfig = (configs, oxlintConfig, options) => {
 	if (oxlintConfig === void 0) if (options?.merge) oxlintConfig = {
 		plugins: [
@@ -2223,7 +2250,7 @@ const buildConfig = (configs, oxlintConfig, options) => {
 			typeAware: true
 		};
 	}
-	return oxlintConfig;
+	return Object.fromEntries(KEY_ORDER.filter((key) => key in oxlintConfig).map((key) => [key, oxlintConfig[key]]));
 };
 const main = async (configs, oxlintConfig, options) => {
 	const resolved = await Promise.resolve(fixForJsPlugins(configs));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@oxlint/migrate",
-  "version": "1.55.0",
+  "version": "1.57.0",
   "description": "Generates a `.oxlintrc.json` from a existing eslint flat config",
   "keywords": [
     "eslint",
@@ -41,13 +41,13 @@
   "dependencies": {
     "commander": "^14.0.0",
     "globals": "^17.0.0",
-    "oxc-parser": "^0.116.0",
+    "oxc-parser": "^0.121.0",
     "tinyglobby": "^0.2.14"
   },
   "devDependencies": {
     "@antfu/eslint-config": "^7.0.0",
     "@e18e/eslint-plugin": "^0.2.0",
-    "@eslint-react/eslint-plugin": "^2.13.0",
+    "@eslint-react/eslint-plugin": "^3.0.0",
     "@eslint/js": "^10.0.0",
     "@logux/eslint-config": "^57.0.0",
     "@oxc-node/core": "^0.0.35",
@@ -76,16 +76,16 @@
     "eslint-plugin-react-hooks": "^7.0.1",
     "eslint-plugin-react-perf": "^3.3.3",
     "eslint-plugin-react-refresh": "^0.5.0",
-    "eslint-plugin-react-web-api": "^2.13.0",
+    "eslint-plugin-react-web-api": "^3.0.0",
     "eslint-plugin-regexp": "^3.0.0",
     "eslint-plugin-tsdoc": "^0.5.0",
     "eslint-plugin-unicorn": "^63.0.0",
     "husky": "^9.1.7",
     "lint-staged": "^16.1.2",
     "next": "^16.0.0",
-    "oxfmt": "^0.36.0",
-    "oxlint": "^1.55.0",
-    "oxlint-tsgolint": "^0.16.0",
+    "oxfmt": "^0.41.0",
+    "oxlint": "^1.57.0",
+    "oxlint-tsgolint": "^0.17.0",
     "tsdown": "^0.21.0",
     "typescript-eslint": "^8.35.0",
     "vitest": "^4.0.0"
@@ -93,5 +93,5 @@
   "lint-staged": {
     "*": "oxfmt --no-error-on-unmatched-pattern"
   },
-  "packageManager": "pnpm@10.30.3"
+  "packageManager": "pnpm@10.32.1"
 }