@oxlint/migrate 1.32.0 → 1.34.0

package/dist/src/ignorePatterns.d.ts

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

package/dist/src/ignorePatterns.mjs

@@ -1,20 +0,0 @@
-const transformIgnorePatterns = (eslintConfig, targetConfig, options) => {
-  if (eslintConfig.ignores === void 0) {
-    return;
-  }
-  if ("files" in targetConfig) {
-    options?.reporter?.report("ignore list inside overrides is not supported");
-    return;
-  }
-  if (targetConfig.ignorePatterns === void 0) {
-    targetConfig.ignorePatterns = [];
-  }
-  for (const ignores of eslintConfig.ignores) {
-    if (!targetConfig.ignorePatterns.includes(ignores)) {
-      targetConfig.ignorePatterns.push(ignores);
-    }
-  }
-};
-export {
-  transformIgnorePatterns
-};

package/dist/src/index.d.ts

@@ -1,4 +0,0 @@
-import { Linter } from 'eslint';
-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/jsPlugins.d.ts

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

package/dist/src/jsPlugins.mjs

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

package/dist/src/js_plugin_fixes.d.ts

@@ -1,5 +0,0 @@
-import { Linter } from 'eslint';
-type PossibleConfigs = Linter.Config | Linter.Config[] | Promise<Linter.Config> | Promise<Linter.Config[]>;
-export default function fixForJsPlugins(configs: PossibleConfigs): PossibleConfigs;
-export declare const preFixForJsPlugins: () => Promise<() => void>;
-export {};

package/dist/src/js_plugin_fixes.mjs

@@ -1,39 +0,0 @@
-const fixForAntfuEslintConfig = (config) => {
-  if ("renamePlugins" in config && typeof config.renamePlugins === "function") {
-    return config.renamePlugins({
-      ts: "@typescript-eslint",
-      test: "vitest",
-      next: "@next/next",
-      style: "@stylistic"
-    });
-  }
-  return config;
-};
-const fixForNextEslintConfig = async () => {
-  if ("Deno" in globalThis || "Bun" in globalThis) {
-    return () => {
-    };
-  }
-  const Module = await import("module");
-  const mod = Module.default || Module;
-  const originalLoad = mod._load;
-  mod._load = function(request, ...args) {
-    if (request && request.includes("@rushstack/eslint-patch")) {
-      return {};
-    }
-    return originalLoad.apply(mod, [request, ...args]);
-  };
-  return () => {
-    mod._load = originalLoad;
-  };
-};
-function fixForJsPlugins(configs) {
-  return fixForAntfuEslintConfig(configs);
-}
-const preFixForJsPlugins = () => {
-  return fixForNextEslintConfig();
-};
-export {
-  fixForJsPlugins as default,
-  preFixForJsPlugins
-};

package/dist/src/overrides.d.ts

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

package/dist/src/overrides.mjs

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

package/dist/src/plugins_rules.mjs

@@ -1,251 +0,0 @@
-import * as rules from "./generated/rules.mjs";
-import { nurseryRules } from "./generated/rules.mjs";
-import { typescriptTypeAwareRules, rulesPrefixesForPlugins, typescriptRulesExtendEslintRules } from "./constants.mjs";
-import { enableJsPluginRule } from "./jsPlugins.mjs";
-const allRules = Object.values(rules).flat();
-const isValueInSet = (value, validSet) => validSet.includes(value) || Array.isArray(value) && validSet.includes(value[0]);
-const isActiveValue = (value) => isValueInSet(value, ["error", "warn", 1, 2]);
-const isOffValue = (value) => isValueInSet(value, ["off", 0]);
-const isWarnValue = (value) => isValueInSet(value, ["warn", 1]);
-const isErrorValue = (value) => isValueInSet(value, ["error", 2]);
-const normalizeSeverityValue = (value) => {
-  if (value === void 0) {
-    return value;
-  }
-  if (isWarnValue(value)) {
-    if (Array.isArray(value)) {
-      value[0] = "warn";
-      return value;
-    }
-    return "warn";
-  } else if (isErrorValue(value)) {
-    if (Array.isArray(value)) {
-      value[0] = "error";
-      return value;
-    }
-    return "error";
-  }
-  if (isOffValue(value)) {
-    if (Array.isArray(value)) {
-      value[0] = "off";
-      return value;
-    }
-    return "off";
-  }
-  return void 0;
-};
-const transformRuleEntry = (eslintConfig, targetConfig, options) => {
-  if (eslintConfig.rules === void 0) {
-    return;
-  }
-  if (targetConfig.rules === void 0) {
-    targetConfig.rules = {};
-  }
-  for (const [rule, config] of Object.entries(eslintConfig.rules)) {
-    if (allRules.includes(rule)) {
-      if (!options?.withNursery && nurseryRules.includes(rule)) {
-        options?.reporter?.report(
-          `unsupported rule, but in development: ${rule}`
-        );
-        continue;
-      }
-      if (!options?.typeAware && typescriptTypeAwareRules.includes(rule)) {
-        options?.reporter?.report(
-          `type-aware rule detected, but \`--type-aware\` is not enabled: ${rule}`
-        );
-        continue;
-      }
-      if (options?.merge) {
-        if (!(rule in targetConfig.rules)) {
-          targetConfig.rules[rule] = normalizeSeverityValue(config);
-        }
-      } else {
-        targetConfig.rules[rule] = normalizeSeverityValue(config);
-      }
-    } else {
-      if (options?.jsPlugins) {
-        if (isActiveValue(config) && !enableJsPluginRule(
-          targetConfig,
-          rule,
-          normalizeSeverityValue(config)
-        )) {
-          options?.reporter?.report(`unsupported rule: ${rule}`);
-        }
-      } else if (isActiveValue(config)) {
-        options?.reporter?.report(`unsupported rule: ${rule}`);
-      }
-    }
-  }
-};
-const detectNeededRulesPlugins = (targetConfig) => {
-  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;
-    }
-    for (const [prefix, plugin] of Object.entries(rulesPrefixesForPlugins)) {
-      if (rule.startsWith(`${prefix}/`) && !targetConfig.plugins.includes(plugin)) {
-        targetConfig.plugins.push(plugin);
-      }
-    }
-  }
-  if ("files" in targetConfig && targetConfig.plugins.length === 0) {
-    delete targetConfig.plugins;
-  }
-};
-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;
-      }
-      override.plugins = override.plugins.filter(
-        (overridePlugin) => !config.plugins.includes(overridePlugin)
-      );
-      if (override.plugins.length === 0) {
-        delete override.plugins;
-      }
-    }
-  }
-};
-const cleanUpUselessOverridesRules = (config) => {
-  if (config.rules === void 0 || config.overrides === void 0) {
-    return;
-  }
-  const filesPatternMap = /* @__PURE__ */ new Map();
-  for (const [i, override] of config.overrides.entries()) {
-    if (override.files === void 0) {
-      continue;
-    }
-    const filesKey = JSON.stringify(override.files);
-    let entry = filesPatternMap.get(filesKey);
-    if (!entry) {
-      entry = {
-        firstIndex: i,
-        finalRules: {},
-        indicesToRemove: []
-      };
-      filesPatternMap.set(filesKey, entry);
-    } else {
-      entry.indicesToRemove.push(i);
-    }
-    if (override.rules) {
-      Object.assign(entry.finalRules, override.rules);
-    }
-  }
-  for (const entry of filesPatternMap.values()) {
-    const firstOverride = config.overrides[entry.firstIndex];
-    firstOverride.rules = entry.finalRules;
-    if (firstOverride.rules) {
-      for (const [rule, settings] of Object.entries(firstOverride.rules)) {
-        if (config.rules[rule] === settings) {
-          delete firstOverride.rules[rule];
-        }
-      }
-      if (Object.keys(firstOverride.rules).length === 0) {
-        delete firstOverride.rules;
-      }
-    }
-    for (const indexToRemove of entry.indicesToRemove) {
-      delete config.overrides[indexToRemove].rules;
-    }
-  }
-};
-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 getEnabledCategories = (config) => {
-  if (config.categories === void 0) {
-    return ["correctness"];
-  }
-  const categories = Object.entries(config.categories).filter(([, severity]) => severity === "warn" || severity === "error").map(([category]) => category);
-  if (Object.keys(config.categories).includes("correctness")) {
-    return categories;
-  }
-  return [...categories, "correctness"];
-};
-const isRuleInEnabledCategory = (rule, enabledCategories) => {
-  for (const category of enabledCategories) {
-    if (`${category}Rules` in rules && // @ts-expect-error -- ts can not resolve the type
-    rules[`${category}Rules`].includes(rule)) {
-      return true;
-    }
-  }
-  return false;
-};
-const cleanUpDisabledRootRules = (config) => {
-  if (config.rules === void 0) {
-    return;
-  }
-  const enabledCategories = getEnabledCategories(config);
-  for (const [rule, settings] of Object.entries(config.rules)) {
-    if (isOffValue(settings) && !isRuleInEnabledCategory(rule, enabledCategories)) {
-      delete config.rules[rule];
-    }
-  }
-};
-const replaceTypescriptAliasRules = (config) => {
-  if (config.rules === void 0) {
-    return;
-  }
-  for (const rule of Object.keys(config.rules)) {
-    const prefix = "@typescript-eslint/";
-    if (!rule.startsWith(prefix)) {
-      continue;
-    }
-    const eslintRule = rule.slice(prefix.length);
-    if (!typescriptRulesExtendEslintRules.includes(eslintRule)) {
-      continue;
-    }
-    config.rules[eslintRule] = config.rules[rule];
-    delete config.rules[rule];
-  }
-  if (Object.keys(config.rules).length === 0) {
-    delete config.rules;
-  }
-};
-const replaceNodePluginName = (config) => {
-  if (config.rules === void 0) {
-    return;
-  }
-  for (const rule of Object.keys(config.rules)) {
-    const prefix = "n/";
-    if (!rule.startsWith(prefix)) {
-      continue;
-    }
-    const nodeRule = `node/${rule.slice(prefix.length)}`;
-    config.rules[nodeRule] = config.rules[rule];
-    delete config.rules[rule];
-  }
-};
-export {
-  cleanUpDisabledRootRules,
-  cleanUpRulesWhichAreCoveredByCategory,
-  cleanUpUselessOverridesPlugins,
-  cleanUpUselessOverridesRules,
-  detectNeededRulesPlugins,
-  replaceNodePluginName,
-  replaceTypescriptAliasRules,
-  transformRuleEntry
-};

package/dist/src/reporter.d.ts

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

package/dist/src/reporter.mjs

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

package/dist/src/types.d.ts

@@ -1,39 +0,0 @@
-import { Linter } from 'eslint';
-type OxlintConfigPlugins = string[];
-type OxlintConfigJsPlugins = 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;
-    jsPlugins?: OxlintConfigJsPlugins;
-    categories?: OxlintConfigCategories;
-    rules?: Partial<Linter.RulesRecord>;
-};
-export type OxlintConfig = {
-    $schema?: string;
-    env?: OxlintConfigEnv;
-    globals?: Linter.Globals;
-    plugins?: OxlintConfigPlugins;
-    jsPlugins?: OxlintConfigJsPlugins;
-    categories?: OxlintConfigCategories;
-    rules?: Partial<Linter.RulesRecord>;
-    overrides?: OxlintConfigOverride[];
-    ignorePatterns?: OxlintConfigIgnorePatterns;
-};
-export type OxlintConfigOrOverride = OxlintConfig | OxlintConfigOverride;
-export type Reporter = {
-    report(message: string): void;
-    getReports(): string[];
-};
-export type Options = {
-    reporter?: Reporter;
-    merge?: boolean;
-    withNursery?: boolean;
-    typeAware?: boolean;
-    jsPlugins?: boolean;
-};
-export {};

package/dist/src/utilities.d.ts

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

package/dist/src/utilities.mjs

@@ -1,12 +0,0 @@
-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/dist/src/walker/comments/index.d.ts

@@ -1,2 +0,0 @@
-import { Options } from '../../types.js';
-export default function replaceComments(comment: string, type: 'Line' | 'Block', options: Options): string;

package/dist/src/walker/comments/index.mjs

@@ -1,20 +0,0 @@
-import replaceRuleDirectiveComment from "./replaceRuleDirectiveComment.mjs";
-function replaceComments(comment, type, options) {
-  const originalComment = comment;
-  comment = comment.trim();
-  if (comment.startsWith("eslint-")) {
-    return replaceRuleDirectiveComment(originalComment, type, options);
-  } else if (type === "Block") {
-    if (comment.startsWith("eslint ")) {
-      throw new Error(
-        "changing eslint rules with inline comment is not supported"
-      );
-    } else if (comment.startsWith("global ")) {
-      throw new Error("changing globals with inline comment is not supported");
-    }
-  }
-  return originalComment;
-}
-export {
-  replaceComments as default
-};

package/dist/src/walker/comments/replaceRuleDirectiveComment.d.ts

@@ -1,2 +0,0 @@
-import { Options } from '../../types.js';
-export default function replaceRuleDirectiveComment(comment: string, type: 'Line' | 'Block', options: Options): string;

package/dist/src/walker/comments/replaceRuleDirectiveComment.mjs

@@ -1,59 +0,0 @@
-import * as rules from "../../generated/rules.mjs";
-import { nurseryRules } from "../../generated/rules.mjs";
-const allRules = Object.values(rules).flat();
-function replaceRuleDirectiveComment(comment, type, options) {
-  const originalComment = comment;
-  comment = comment.split(" -- ")[0].trimStart();
-  if (!comment.startsWith("eslint-")) {
-    return originalComment;
-  }
-  comment = comment.substring(7);
-  if (comment.startsWith("enable")) {
-    comment = comment.substring(6);
-  } else if (comment.startsWith("disable")) {
-    comment = comment.substring(7);
-    if (type === "Line") {
-      if (comment.startsWith("-next-line")) {
-        comment = comment.substring(10);
-      } else if (comment.startsWith("-line")) {
-        comment = comment.substring(5);
-      }
-    }
-  } else {
-    return originalComment;
-  }
-  if (!comment.startsWith(" ")) {
-    return originalComment;
-  }
-  comment = comment.trimStart();
-  if (comment.length === 0) {
-    return originalComment;
-  }
-  while (comment.length) {
-    let foundRule = false;
-    for (const rule of allRules) {
-      if (comment.startsWith(rule)) {
-        if (!options.withNursery && nurseryRules.includes(rule)) {
-          continue;
-        }
-        foundRule = true;
-        comment = comment.substring(rule.length).trimStart();
-        break;
-      }
-    }
-    if (!foundRule) {
-      return originalComment;
-    }
-    if (!comment.length) {
-      break;
-    }
-    if (!comment.startsWith(", ")) {
-      return originalComment;
-    }
-    comment = comment.substring(1).trimStart();
-  }
-  return originalComment.replace(/eslint-/, "oxlint-");
-}
-export {
-  replaceRuleDirectiveComment as default
-};

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

@@ -1,10 +0,0 @@
-import { Options } from '../types.js';
-export declare const walkAndReplaceProjectFiles: (
-/** all projects files to check */
-projectFiles: string[], 
-/** function for reading the file */
-readFileSync: (filePath: string) => string | undefined, 
-/** function for writing the file */
-writeFile: (filePath: string, content: string) => Promise<void>, 
-/** options for the walker, for `reporter` and `withNurseryRules` */
-options: Options) => Promise<void[]>;

package/dist/src/walker/index.mjs

@@ -1,19 +0,0 @@
-import replaceCommentsInFile from "./replaceCommentsInFile.mjs";
-const walkAndReplaceProjectFiles = (projectFiles, readFileSync, writeFile, options) => {
-  return Promise.all(
-    projectFiles.map((file) => {
-      const sourceText = readFileSync(file);
-      if (!sourceText) {
-        return Promise.resolve();
-      }
-      const newSourceText = replaceCommentsInFile(file, sourceText, options);
-      if (newSourceText === sourceText) {
-        return Promise.resolve();
-      }
-      return writeFile(file, newSourceText);
-    })
-  );
-};
-export {
-  walkAndReplaceProjectFiles
-};

package/dist/src/walker/partialSourceTextLoader.d.ts

@@ -1,10 +0,0 @@
-export type PartialSourceText = {
-    sourceText: string;
-    offset: number;
-    lang?: 'js' | 'jsx' | 'ts' | 'tsx';
-    sourceType?: 'script' | 'module';
-};
-export default function partialSourceTextLoader(absoluteFilePath: string, fileContent: string): PartialSourceText[];
-export declare function partialVueSourceTextLoader(sourceText: string): PartialSourceText[];
-export declare function partialSvelteSourceTextLoader(sourceText: string): PartialSourceText[];
-export declare function partialAstroSourceTextLoader(sourceText: string): PartialSourceText[];