@oxlint/migrate 0.16.0 → 0.16.2

package/README.md

@@ -16,6 +16,18 @@ npx @oxlint/migrate <optional-eslint-flat-config-path>
 
 When no config file provided, the script searches for the default eslint config filenames in the current directory.
 
+### Options
+
+| Options                | Description                                                                                          |
+| ---------------------- | ---------------------------------------------------------------------------------------------------- |
+| `--merge`              | \* merge eslint configuration with an existing .oxlintrc.json configuration                          |
+| `--with-nursery`       | Include oxlint rules which are currently under development                                           |
+| `--output-file <file>` | The oxlint configuration file where to eslint v9 rules will be written to, default: `.oxlintrc.json` |
+
+\* WARNING: When some `categories` are enabled, this tools will enable more rules with the combination of `plugins`.
+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.
+
 ### User Flow
 
 - Upgrade `oxlint` and `@oxlint/migrate` to the same version.
@@ -33,7 +45,7 @@ pnpm generate
 pnpm format
 ```
 
-### Vitest + Integration Test
+### Unit + Integration Test
 
 ```shell
 pnpm vitest

package/dist/bin/oxlint-migrate.mjs

@@ -1,13 +1,27 @@
 #!/usr/bin/env node
 import { program } from "commander";
 import { getAutodetectedEslintConfigName } from "./autoDetectConfigFile.mjs";
-import { existsSync, renameSync, writeFileSync } from "fs";
+import { existsSync, readFileSync, renameSync, writeFileSync } from "fs";
 import main from "../src/index.mjs";
 import path from "path";
 import packageJson from "../package.json.mjs";
 import { pathToFileURL } from "node:url";
-program.name("oxlint-migrate").version(packageJson.version).argument("[eslint-config]", "The path to the eslint v9 config file").action(async (filePath) => {
-  let cwd = process.cwd();
+const cwd = process.cwd();
+program.name("oxlint-migrate").version(packageJson.version).argument("[eslint-config]", "The path to the eslint v9 config file").option(
+  "--output-file <file>",
+  "The oxlint configuration file where to eslint v9 rules will be written to",
+  ".oxlintrc.json"
+).option(
+  "--merge",
+  "Merge eslint configuration with an existing .oxlintrc.json configuration",
+  false
+).option(
+  "--with-nursery",
+  "Include oxlint rules which are currently under development",
+  false
+).action(async (filePath) => {
+  const cliOptions = program.opts();
+  const oxlintFilePath = path.join(cwd, cliOptions.outputFile);
   if (filePath === void 0) {
     filePath = getAutodetectedEslintConfigName(cwd);
     if (filePath === void 0) {
@@ -20,8 +34,18 @@ program.name("oxlint-migrate").version(packageJson.version).argument("[eslint-co
     program.error(`eslint config file not found: ${filePath}`);
   } else {
     const eslintConfigs = await import(pathToFileURL(filePath).toString());
-    const oxlintConfig = "default" in eslintConfigs ? await main(eslintConfigs.default, console.warn) : await main(eslintConfigs, console.warn);
-    const oxlintFilePath = path.join(cwd, ".oxlintrc.json");
+    const options = {
+      reporter: console.warn,
+      merge: !!cliOptions.merge,
+      withNursery: !!cliOptions.withNursery
+    };
+    let config;
+    if (options.merge && existsSync(oxlintFilePath)) {
+      config = JSON.parse(
+        readFileSync(oxlintFilePath, { encoding: "utf8", flag: "r" })
+      );
+    }
+    const oxlintConfig = "default" in eslintConfigs ? await main(eslintConfigs.default, config, options) : await main(eslintConfigs, config, options);
     if (existsSync(oxlintFilePath)) {
       renameSync(oxlintFilePath, `${oxlintFilePath}.bak`);
     }

package/dist/package.json.mjs

@@ -1,4 +1,4 @@
-const version = "0.16.0";
+const version = "0.16.2";
 const packageJson = {
   version
 };

package/dist/src/cleanup.mjs

@@ -1,14 +1,6 @@
 import { removeGlobalsWithAreCoveredByEnv, transformBoolGlobalToString, ES_VERSIONS, cleanUpUselessOverridesEnv } from "./env_globals.mjs";
-import { replaceTypescriptAliasRules, replaceNodePluginName, cleanUpUselessOverridesRules, cleanUpUselessOverridesPlugins } from "./plugins_rules.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]))
-  );
-};
+import { replaceTypescriptAliasRules, replaceNodePluginName, cleanUpRulesWhichAreCoveredByCategory, cleanUpUselessOverridesRules, cleanUpUselessOverridesPlugins } from "./plugins_rules.mjs";
+import { isEqualDeep } from "./utilities.mjs";
 const TS_ESLINT_DEFAULT_OVERRIDE = {
   files: ["**/*.ts", "**/*.tsx", "**/*.mts", "**/*.cts"],
   rules: {
@@ -73,6 +65,7 @@ const cleanUpOxlintConfig = (config) => {
   transformBoolGlobalToString(config);
   replaceTypescriptAliasRules(config);
   replaceNodePluginName(config);
+  cleanUpRulesWhichAreCoveredByCategory(config);
   if (config.globals !== void 0 && Object.keys(config.globals).length === 0) {
     delete config.globals;
   }
@@ -81,7 +74,7 @@ const cleanUpOxlintConfig = (config) => {
     delete config.env.es5;
     delete config.env.es2015;
     let detected = false;
-    for (const esVersion of ES_VERSIONS.reverse()) {
+    for (const esVersion of [...ES_VERSIONS].reverse()) {
       if (detected) {
         delete config.env[`es${esVersion}`];
       } else if (config.env[`es${esVersion}`] === true) {

package/dist/src/env_globals.d.ts

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

package/dist/src/env_globals.mjs

@@ -101,11 +101,11 @@ const detectEnvironmentByGlobals = (config) => {
     }
   }
 };
-const transformEnvAndGlobals = (eslintConfig, targetConfig, reporter) => {
+const transformEnvAndGlobals = (eslintConfig, targetConfig, options) => {
   if (eslintConfig.languageOptions?.parser !== void 0 && !SUPPORTED_ESLINT_PARSERS.includes(
     eslintConfig.languageOptions.parser.meta?.name
   )) {
-    reporter !== void 0 && reporter(
+    options?.reporter !== void 0 && options.reporter(
       "special parser detected: " + eslintConfig.languageOptions.parser.meta?.name
     );
   }
@@ -113,22 +113,35 @@ const transformEnvAndGlobals = (eslintConfig, targetConfig, reporter) => {
     if (targetConfig.globals === void 0) {
       targetConfig.globals = {};
     }
-    Object.assign(targetConfig.globals, eslintConfig.languageOptions.globals);
+    if (options?.merge) {
+      for (const [global, globalSetting] of Object.entries(
+        eslintConfig.languageOptions.globals
+      )) {
+        if (!(global in targetConfig.globals)) {
+          targetConfig.globals[global] = globalSetting;
+        }
+      }
+    } else {
+      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;
+      const latestVersion = `es${ES_VERSIONS[ES_VERSIONS.length - 1]}`;
+      if (!(latestVersion in targetConfig.env)) {
+        targetConfig.env[latestVersion] = true;
+      }
     } else if (ES_VERSIONS.includes(eslintConfig.languageOptions?.ecmaVersion)) {
       if (targetConfig.env === void 0) {
         targetConfig.env = {};
       }
-      targetConfig.env[`es${eslintConfig.languageOptions?.ecmaVersion}`] = true;
+      const targetVersion = `es${eslintConfig.languageOptions?.ecmaVersion}`;
+      if (!(targetVersion in targetConfig.env)) {
+        targetConfig.env[targetVersion] = true;
+      }
     }
   }
 };

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

@@ -1,7 +1,7 @@
 export declare const pedanticRules: string[];
-export declare const nurseryRules: string[];
 export declare const styleRules: string[];
 export declare const restrictionRules: string[];
 export declare const correctnessRules: string[];
+export declare const nurseryRules: string[];
 export declare const perfRules: string[];
 export declare const suspiciousRules: string[];

package/dist/src/generated/rules.mjs

@@ -84,21 +84,6 @@ const pedanticRules = [
   "import-x/max-dependencies",
   "vitest/no-conditional-in-test"
 ];
-const nurseryRules = [
-  "constructor-super",
-  "getter-return",
-  "no-undef",
-  "no-unreachable",
-  "import/export",
-  "import/named",
-  "promise/no-return-in-finally",
-  "react-hooks/exhaustive-deps",
-  "react/require-render-return",
-  "@typescript-eslint/consistent-type-imports",
-  "@typescript-eslint/no-unnecessary-parameter-property-assignment",
-  "import-x/export",
-  "import-x/named"
-];
 const styleRules = [
   "curly",
   "default-case-last",
@@ -324,6 +309,7 @@ const restrictionRules = [
   "unicorn/no-anonymous-default-export",
   "unicorn/no-array-for-each",
   "unicorn/no-array-reduce",
+  "unicorn/no-document-cookie",
   "unicorn/no-length-as-slice-end",
   "unicorn/no-magic-array-flat-depth",
   "unicorn/no-nested-ternary",
@@ -482,6 +468,7 @@ const correctnessRules = [
   "@typescript-eslint/no-misused-new",
   "@typescript-eslint/no-non-null-asserted-optional-chain",
   "@typescript-eslint/no-this-alias",
+  "@typescript-eslint/no-unnecessary-parameter-property-assignment",
   "@typescript-eslint/no-unsafe-declaration-merging",
   "@typescript-eslint/no-useless-empty-export",
   "@typescript-eslint/no-wrapper-object-types",
@@ -489,7 +476,6 @@ const correctnessRules = [
   "@typescript-eslint/triple-slash-reference",
   "unicorn/no-invalid-fetch-options",
   "unicorn/no-await-in-promise-methods",
-  "unicorn/no-document-cookie",
   "unicorn/no-empty-file",
   "unicorn/no-invalid-remove-event-listener",
   "unicorn/no-new-array",
@@ -517,6 +503,19 @@ const correctnessRules = [
   "vitest/valid-describe-callback",
   "vitest/valid-expect"
 ];
+const nurseryRules = [
+  "getter-return",
+  "no-undef",
+  "no-unreachable",
+  "import/export",
+  "import/named",
+  "promise/no-return-in-finally",
+  "react-hooks/exhaustive-deps",
+  "react/require-render-return",
+  "@typescript-eslint/consistent-type-imports",
+  "import-x/export",
+  "import-x/named"
+];
 const perfRules = [
   "no-useless-call",
   "no-await-in-loop",
@@ -534,6 +533,7 @@ const suspiciousRules = [
   "no-unexpected-multiline",
   "no-useless-concat",
   "no-useless-constructor",
+  "import/no-empty-named-blocks",
   "import/no-absolute-path",
   "import/no-duplicates",
   "import/no-named-as-default",
@@ -554,6 +554,7 @@ const suspiciousRules = [
   "unicorn/prefer-add-event-listener",
   "unicorn/require-post-message-target-origin",
   "@typescript-eslint/no-useless-constructor",
+  "import-x/no-empty-named-blocks",
   "import-x/no-absolute-path",
   "import-x/no-duplicates",
   "import-x/no-named-as-default",

package/dist/src/ignorePatterns.d.ts

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

package/dist/src/ignorePatterns.mjs

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

package/dist/src/index.d.ts

@@ -1,4 +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>;
+import { Options, OxlintConfig } from './types.js';
+declare const main: (configs: Linter.Config | Linter.Config[] | Promise<Linter.Config> | Promise<Linter.Config[]>, oxlintConfig?: OxlintConfig, options?: Options) => Promise<OxlintConfig>;
 export default main;

package/dist/src/index.mjs

@@ -2,20 +2,41 @@ import { transformEnvAndGlobals, detectEnvironmentByGlobals } from "./env_global
 import { cleanUpOxlintConfig } from "./cleanup.mjs";
 import { transformIgnorePatterns } from "./ignorePatterns.mjs";
 import { transformRuleEntry, detectNeededRulesPlugins } from "./plugins_rules.mjs";
-const buildConfig = (configs, reporter) => {
-  const oxlintConfig = {
-    $schema: "./node_modules/oxlint/configuration_schema.json",
-    // disable all plugins and check later
-    plugins: [],
-    env: {
-      builtin: true
-    },
-    categories: {
-      // default category
-      correctness: "off"
+import { detectSameOverride } from "./overrides.mjs";
+const buildConfig = (configs, oxlintConfig, options) => {
+  if (oxlintConfig === void 0) {
+    if (options?.merge) {
+      oxlintConfig = {
+        // disable all plugins and check later
+        plugins: ["oxc", "typescript", "unicorn", "react"],
+        categories: {
+          correctness: "warn"
+        }
+      };
+    } else {
+      oxlintConfig = {
+        $schema: "./node_modules/oxlint/configuration_schema.json",
+        // disable all plugins and check later
+        plugins: [],
+        categories: {
+          // ToDo: for merge set the default category manuel when it is not found
+          // ToDo: later we can remove it again
+          // default category
+          correctness: "off"
+        }
+      };
     }
-  };
-  const overrides = [];
+  }
+  if (oxlintConfig.$schema === void 0 && options?.merge) {
+    oxlintConfig.$schema = "./node_modules/oxlint/configuration_schema.json";
+  }
+  if (oxlintConfig.env?.builtin === void 0) {
+    if (oxlintConfig.env === void 0) {
+      oxlintConfig.env = {};
+    }
+    oxlintConfig.env.builtin = true;
+  }
+  const overrides = options?.merge ? oxlintConfig.overrides ?? [] : [];
   for (const config of configs) {
     if (config.name?.startsWith("oxlint/")) {
       continue;
@@ -27,28 +48,30 @@ const buildConfig = (configs, reporter) => {
       targetConfig = {
         files: Array.isArray(config.files) ? config.files : [config.files]
       };
-      overrides.push(targetConfig);
+      const [push, result] = detectSameOverride(oxlintConfig, targetConfig);
+      if (push) {
+        overrides.push(result);
+      }
     }
-    if (config.plugins !== void 0) ;
     if (config.settings !== void 0) ;
-    transformIgnorePatterns(config, targetConfig, reporter);
-    transformRuleEntry(config, targetConfig, reporter);
-    transformEnvAndGlobals(config, targetConfig, reporter);
+    transformIgnorePatterns(config, targetConfig, options);
+    transformRuleEntry(config, targetConfig, options);
+    transformEnvAndGlobals(config, targetConfig, options);
     if ("files" in targetConfig) {
-      detectNeededRulesPlugins(targetConfig, reporter);
+      detectNeededRulesPlugins(targetConfig, options);
       detectEnvironmentByGlobals(targetConfig);
       cleanUpOxlintConfig(targetConfig);
     }
   }
   oxlintConfig.overrides = overrides;
-  detectNeededRulesPlugins(oxlintConfig, reporter);
+  detectNeededRulesPlugins(oxlintConfig, options);
   detectEnvironmentByGlobals(oxlintConfig);
   cleanUpOxlintConfig(oxlintConfig);
   return oxlintConfig;
 };
-const main = async (configs, reporter) => {
+const main = async (configs, oxlintConfig, options) => {
   const resolved = await Promise.resolve(configs);
-  return Array.isArray(resolved) ? buildConfig(resolved, reporter) : buildConfig([resolved], reporter);
+  return Array.isArray(resolved) ? buildConfig(resolved, oxlintConfig, options) : buildConfig([resolved], oxlintConfig, options);
 };
 export {
   main as default

package/dist/src/overrides.d.ts

@@ -0,0 +1,2 @@
+import { OxlintConfig, OxlintConfigOverride } from './types.js';
+export declare const detectSameOverride: (config: OxlintConfig, override: OxlintConfigOverride) => [boolean, OxlintConfigOverride];

package/dist/src/overrides.mjs

@@ -0,0 +1,16 @@
+import { isEqualDeep } from "./utilities.mjs";
+const detectSameOverride = (config, override) => {
+  if (config.overrides === void 0) {
+    return [true, override];
+  }
+  const matchedOverride = config.overrides.find(({ files, categories }) => {
+    return categories === void 0 && isEqualDeep(files, override.files);
+  });
+  if (matchedOverride !== void 0) {
+    return [false, matchedOverride];
+  }
+  return [true, override];
+};
+export {
+  detectSameOverride
+};

package/dist/src/plugins_rules.d.ts

@@ -1,9 +1,10 @@
 import { Linter } from 'eslint';
-import { OxlintConfig, 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;
+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 cleanUpUselessOverridesPlugins: (config: OxlintConfig) => void;
 export declare const cleanUpUselessOverridesRules: (config: OxlintConfig) => void;
+export declare const cleanUpRulesWhichAreCoveredByCategory: (config: OxlintConfigOrOverride) => void;
 export declare const replaceTypescriptAliasRules: (config: OxlintConfigOrOverride) => void;
 /**
  * Oxlint support them only under the node plugin name

package/dist/src/plugins_rules.mjs

@@ -33,7 +33,7 @@ const normalizeSeverityValue = (value) => {
   }
   return void 0;
 };
-const transformRuleEntry = (eslintConfig, targetConfig, reporter) => {
+const transformRuleEntry = (eslintConfig, targetConfig, options) => {
   if (eslintConfig.rules === void 0) {
     return;
   }
@@ -42,19 +42,25 @@ const transformRuleEntry = (eslintConfig, targetConfig, reporter) => {
   }
   for (const [rule, config] of Object.entries(eslintConfig.rules)) {
     if (allRules.includes(rule)) {
-      if (nurseryRules.includes(rule)) {
-        reporter !== void 0 && reporter(`unsupported rule, but in development: ${rule}`);
+      if (!options?.withNursery && nurseryRules.includes(rule)) {
+        options?.reporter !== void 0 && options.reporter(`unsupported rule, but in development: ${rule}`);
         continue;
       }
-      targetConfig.rules[rule] = normalizeSeverityValue(config);
+      if (options?.merge) {
+        if (!(rule in targetConfig.rules)) {
+          targetConfig.rules[rule] = normalizeSeverityValue(config);
+        }
+      } else {
+        targetConfig.rules[rule] = normalizeSeverityValue(config);
+      }
     } else {
       if (isActiveValue(config)) {
-        reporter !== void 0 && reporter(`unsupported rule: ${rule}`);
+        options?.reporter !== void 0 && options.reporter(`unsupported rule: ${rule}`);
       }
     }
   }
 };
-const detectNeededRulesPlugins = (targetConfig, reporter) => {
+const detectNeededRulesPlugins = (targetConfig, options) => {
   if (targetConfig.rules === void 0) {
     return;
   }
@@ -75,7 +81,7 @@ const detectNeededRulesPlugins = (targetConfig, reporter) => {
       }
     }
     if (!found) {
-      reporter !== void 0 && reporter(`unsupported plugin for rule: ${rule}`);
+      options?.reporter !== void 0 && options.reporter(`unsupported plugin for rule: ${rule}`);
     }
   }
   if ("files" in targetConfig && targetConfig.plugins.length === 0) {
@@ -118,6 +124,22 @@ const cleanUpUselessOverridesRules = (config) => {
     }
   }
 };
+const cleanUpRulesWhichAreCoveredByCategory = (config) => {
+  if (config.rules === void 0 || config.categories === void 0) {
+    return;
+  }
+  const enabledCategories = Object.entries(config.categories).filter(([, severity]) => severity === "warn" || severity === "error").map(([category]) => category);
+  for (const [rule, settings] of Object.entries(config.rules)) {
+    for (const category of enabledCategories) {
+      if (`${category}Rules` in rules && // @ts-expect-error -- ts can not resolve the type
+      rules[`${category}Rules`].includes(rule)) {
+        if (settings === config.categories[category] || Array.isArray(settings) && settings.length === 1 && settings[0] === config.categories[category]) {
+          delete config.rules[rule];
+        }
+      }
+    }
+  }
+};
 const replaceTypescriptAliasRules = (config) => {
   if (config.rules === void 0) {
     return;
@@ -153,6 +175,7 @@ const replaceNodePluginName = (config) => {
   }
 };
 export {
+  cleanUpRulesWhichAreCoveredByCategory,
   cleanUpUselessOverridesPlugins,
   cleanUpUselessOverridesRules,
   detectNeededRulesPlugins,

package/dist/src/types.d.ts

@@ -8,6 +8,7 @@ export type OxlintConfigOverride = {
     env?: OxlintConfigEnv;
     globals?: Linter.Globals;
     plugins?: OxlintConfigPlugins;
+    categories?: OxlintConfigCategories;
     rules?: Partial<Linter.RulesRecord>;
 };
 export type OxlintConfig = {
@@ -21,5 +22,10 @@ export type OxlintConfig = {
     ignorePatterns?: OxlintConfigIgnorePatterns;
 };
 export type OxlintConfigOrOverride = OxlintConfig | OxlintConfigOverride;
-export type Reporter = (warning: string) => void;
+type Reporter = (warning: string) => void;
+export type Options = {
+    reporter?: Reporter;
+    merge?: boolean;
+    withNursery?: boolean;
+};
 export {};

package/dist/src/utilities.d.ts

@@ -0,0 +1 @@
+export declare const isEqualDeep: <T>(a: T, b: T) => boolean;

package/dist/src/utilities.mjs

@@ -0,0 +1,12 @@
+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]))
+  );
+};
+export {
+  isEqualDeep
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@oxlint/migrate",
-  "version": "0.16.0",
+  "version": "0.16.2",
   "description": "Generates a `.oxlintrc.json` from a existing eslint flat config",
   "type": "module",
   "bin": {
@@ -37,7 +37,7 @@
     "@eslint/eslintrc": "^3.3.0",
     "@eslint/js": "^9.20.0",
     "@logux/eslint-config": "^55.0.0",
-    "@oxc-node/core": "^0.0.20",
+    "@oxc-node/core": "^0.0.21",
     "@stylistic/eslint-plugin": "^4.0.1",
     "@stylistic/eslint-plugin-ts": "^4.0.0",
     "@types/eslint-config-prettier": "^6.11.3",
@@ -52,12 +52,12 @@
     "eslint-plugin-import-x": "^4.6.1",
     "eslint-plugin-jsdoc": "^50.6.3",
     "eslint-plugin-local": "^6.0.0",
-    "eslint-plugin-oxlint": "^0.15.10",
+    "eslint-plugin-oxlint": "^0.16.0",
     "eslint-plugin-regexp": "^2.7.0",
     "eslint-plugin-unicorn": "^57.0.0",
     "husky": "^9.1.7",
     "lint-staged": "^15.4.3",
-    "oxlint": "^0.16.0",
+    "oxlint": "^0.16.2",
     "prettier": "^3.5.1",
     "typescript": "^5.7.3",
     "typescript-eslint": "^8.24.0",
@@ -72,5 +72,5 @@
     "commander": "^13.1.0",
     "globals": "^16.0.0"
   },
-  "packageManager": "pnpm@10.6.1"
+  "packageManager": "pnpm@10.6.3"
 }