@oxlint/migrate 1.7.0 → 1.8.0

package/README.md

@@ -16,11 +16,12 @@ When no config file provided, the script searches for the default eslint config
 
 ### 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` |
+| 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`                                        |
+| `--replace-eslint-comments` | Search in the project files for eslint comments and replaces them with oxlint. Some eslint comments are not supported and will be reported. |
 
 \* 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.

package/dist/bin/oxlint-migrate.mjs

@@ -5,7 +5,17 @@ import path from "node:path";
 import { getAutodetectedEslintConfigName, loadESLintConfig } from "./config-loader.mjs";
 import main from "../src/index.mjs";
 import packageJson from "../package.json.mjs";
+import { walkAndReplaceProjectFiles } from "../src/walker/index.mjs";
+import { getAllProjectFiles } from "./project-loader.mjs";
+import { writeFile } from "node:fs/promises";
 const cwd = process.cwd();
+const getFileContent = (absoluteFilePath) => {
+  try {
+    return readFileSync(absoluteFilePath, "utf-8");
+  } catch {
+    return void 0;
+  }
+};
 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",
@@ -18,9 +28,26 @@ program.name("oxlint-migrate").version(packageJson.version).argument("[eslint-co
   "--with-nursery",
   "Include oxlint rules which are currently under development",
   false
+).option(
+  "--replace-eslint-comments",
+  "Search in the project files for eslint comments and replaces them with oxlint. Some eslint comments are not supported and will be reported."
 ).action(async (filePath) => {
   const cliOptions = program.opts();
   const oxlintFilePath = path.join(cwd, cliOptions.outputFile);
+  const options = {
+    reporter: console.warn,
+    merge: !!cliOptions.merge,
+    withNursery: !!cliOptions.withNursery
+  };
+  if (cliOptions.replaceEslintComments) {
+    await walkAndReplaceProjectFiles(
+      await getAllProjectFiles(),
+      (filePath2) => getFileContent(filePath2),
+      (filePath2, content) => writeFile(filePath2, content, "utf-8"),
+      options
+    );
+    return;
+  }
   if (filePath === void 0) {
     filePath = getAutodetectedEslintConfigName(cwd);
   } else {
@@ -30,11 +57,6 @@ program.name("oxlint-migrate").version(packageJson.version).argument("[eslint-co
     program.error(`could not autodetect eslint config file`);
   }
   const eslintConfigs = await loadESLintConfig(filePath);
-  const options = {
-    reporter: console.warn,
-    merge: !!cliOptions.merge,
-    withNursery: !!cliOptions.withNursery
-  };
   let config;
   if (options.merge && existsSync(oxlintFilePath)) {
     config = JSON.parse(

package/dist/bin/project-loader.mjs

@@ -0,0 +1,16 @@
+import { glob } from "tinyglobby";
+const getAllProjectFiles = () => {
+  return glob(
+    [
+      "**/*.{js,cjs,mjs,ts,cts,mts,vue,astro,svelte}",
+      "!**/node_modules/**",
+      "!**/dist/**"
+    ],
+    {
+      absolute: true
+    }
+  );
+};
+export {
+  getAllProjectFiles
+};

package/dist/package.json.mjs

@@ -1,4 +1,4 @@
-const version = "1.7.0";
+const version = "1.8.0";
 const packageJson = {
   version
 };

package/dist/src/constants.mjs

@@ -9,7 +9,8 @@ const rulesPrefixesForPlugins = {
   n: "node",
   promise: "promise",
   react: "react",
-  "react-perf": "react",
+  "react-perf": "react-perf",
+  "react-hooks": "react",
   "@typescript-eslint": "typescript",
   unicorn: "unicorn",
   vitest: "vitest"

package/dist/src/generated/rules.mjs

@@ -218,7 +218,6 @@ const styleRules = [
   "unicorn/prefer-object-from-entries",
   "unicorn/prefer-array-index-of",
   "unicorn/prefer-spread",
-  "unicorn/prefer-array-flat-map",
   "unicorn/prefer-dom-node-text-content",
   "unicorn/prefer-includes",
   "unicorn/prefer-logical-operator-over-ternary",
@@ -588,6 +587,7 @@ const perfRules = [
   "react-perf/jsx-no-new-function-as-prop",
   "react-perf/jsx-no-new-object-as-prop",
   "unicorn/prefer-array-find",
+  "unicorn/prefer-array-flat-map",
   "unicorn/prefer-set-has"
 ];
 export {

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

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

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

@@ -0,0 +1,20 @@
+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

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

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

@@ -0,0 +1,59 @@
+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/comments/replaceRuleDirectiveComment.test.d.ts

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

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

@@ -0,0 +1,10 @@
+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

@@ -0,0 +1,19 @@
+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

@@ -0,0 +1,10 @@
+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[];

package/dist/src/walker/partialSourceTextLoader.mjs

@@ -0,0 +1,167 @@
+function extractLangAttribute(source) {
+  const langIndex = source.indexOf("lang");
+  if (langIndex === -1) return void 0;
+  let cursor = langIndex + 4;
+  while (cursor < source.length && isWhitespace(source[cursor])) {
+    cursor++;
+  }
+  if (source[cursor] !== "=") return void 0;
+  cursor++;
+  while (cursor < source.length && isWhitespace(source[cursor])) {
+    cursor++;
+  }
+  const quote = source[cursor];
+  if (quote !== '"' && quote !== "'") return void 0;
+  cursor++;
+  let value = "";
+  while (cursor < source.length && source[cursor] !== quote) {
+    value += source[cursor++];
+  }
+  if (value === "js" || value === "jsx" || value === "ts" || value === "tsx") {
+    return value;
+  }
+  return void 0;
+}
+function extractScriptBlocks(sourceText, offset, maxBlocks, parseLangAttribute) {
+  const results = [];
+  while (offset < sourceText.length) {
+    const idx = sourceText.indexOf("<script", offset);
+    if (idx === -1) break;
+    const nextChar = sourceText[idx + 7];
+    if (nextChar !== " " && nextChar !== ">" && nextChar !== "\n" && nextChar !== "	") {
+      offset = idx + 7;
+      continue;
+    }
+    let i = idx + 7;
+    let inQuote = null;
+    let genericDepth = 0;
+    let selfClosing = false;
+    while (i < sourceText.length) {
+      const c = sourceText[i];
+      if (inQuote) {
+        if (c === inQuote) inQuote = null;
+      } else if (c === '"' || c === "'") {
+        inQuote = c;
+      } else if (c === "<") {
+        genericDepth++;
+      } else if (c === ">") {
+        if (genericDepth > 0) {
+          genericDepth--;
+        } else {
+          if (i > idx && sourceText[i - 1] === "/") {
+            selfClosing = true;
+          }
+          i++;
+          break;
+        }
+      }
+      i++;
+    }
+    if (selfClosing) {
+      offset = i;
+      continue;
+    }
+    if (i >= sourceText.length) break;
+    let lang = void 0;
+    if (parseLangAttribute) {
+      lang = extractLangAttribute(sourceText.slice(idx, i));
+    }
+    const contentStart = i;
+    const closeTag = "<\/script>";
+    const closeIdx = sourceText.indexOf(closeTag, contentStart);
+    if (closeIdx === -1) break;
+    const content = sourceText.slice(contentStart, closeIdx);
+    results.push({ sourceText: content, offset: contentStart, lang });
+    if (results.length >= maxBlocks) {
+      break;
+    }
+    offset = closeIdx + closeTag.length;
+  }
+  return results;
+}
+function partialSourceTextLoader(absoluteFilePath, fileContent) {
+  if (absoluteFilePath.endsWith(".vue")) {
+    return partialVueSourceTextLoader(fileContent);
+  } else if (absoluteFilePath.endsWith(".astro")) {
+    return partialAstroSourceTextLoader(fileContent);
+  } else if (absoluteFilePath.endsWith(".svelte")) {
+    return partialSvelteSourceTextLoader(fileContent);
+  }
+  return [
+    {
+      sourceText: fileContent,
+      offset: 0
+    }
+  ];
+}
+function isWhitespace(char) {
+  return char === " " || char === "	" || char === "\r";
+}
+function findDelimiter(sourceText, startPos) {
+  let i = startPos;
+  while (i < sourceText.length) {
+    if (i === 0 || sourceText[i - 1] === "\n") {
+      let j = i;
+      while (j < sourceText.length && isWhitespace(sourceText[j])) j++;
+      if (sourceText[j] === "-" && sourceText[j + 1] === "-" && sourceText[j + 2] === "-") {
+        let k = j + 3;
+        while (k < sourceText.length && sourceText[k] !== "\n") {
+          if (!isWhitespace(sourceText[k])) break;
+          k++;
+        }
+        if (k === sourceText.length || sourceText[k] === "\n") {
+          return j;
+        }
+      }
+    }
+    i++;
+  }
+  return -1;
+}
+function partialVueSourceTextLoader(sourceText) {
+  return extractScriptBlocks(sourceText, 0, 2, true);
+}
+function partialSvelteSourceTextLoader(sourceText) {
+  return extractScriptBlocks(sourceText, 0, 2, true);
+}
+function partialAstroSourceTextLoader(sourceText) {
+  const results = [];
+  let pos = 0;
+  const frontmatterStartDelimiter = findDelimiter(sourceText, pos);
+  if (frontmatterStartDelimiter !== -1) {
+    const frontmatterContentStart = frontmatterStartDelimiter + 3;
+    const frontmatterEndDelimiter = findDelimiter(
+      sourceText,
+      frontmatterContentStart
+    );
+    if (frontmatterEndDelimiter !== -1) {
+      const content = sourceText.slice(
+        frontmatterContentStart,
+        frontmatterEndDelimiter
+      );
+      results.push({
+        sourceText: content,
+        offset: frontmatterContentStart,
+        lang: "ts",
+        sourceType: "module"
+      });
+      pos = frontmatterEndDelimiter + 3;
+    }
+  }
+  results.push(
+    ...extractScriptBlocks(sourceText, pos, Number.MAX_SAFE_INTEGER, false).map(
+      (sourceText2) => ({
+        ...sourceText2,
+        lang: "ts",
+        sourceType: "module"
+      })
+    )
+  );
+  return results;
+}
+export {
+  partialSourceTextLoader as default,
+  partialAstroSourceTextLoader,
+  partialSvelteSourceTextLoader,
+  partialVueSourceTextLoader
+};

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

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

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

@@ -0,0 +1,2 @@
+import { Options } from '../types.js';
+export default function replaceCommentsInFile(absoluteFilePath: string, fileContent: string, options: Options): string;

package/dist/src/walker/replaceCommentsInFile.mjs

@@ -0,0 +1,60 @@
+import { parseSync } from "oxc-parser";
+import replaceComments from "./comments/index.mjs";
+import partialSourceTextLoader from "./partialSourceTextLoader.mjs";
+const getComments = (absoluteFilePath, partialSourceText, options) => {
+  const parserResult = parseSync(
+    absoluteFilePath,
+    partialSourceText.sourceText,
+    {
+      lang: partialSourceText.lang,
+      sourceType: partialSourceText.sourceType
+    }
+  );
+  if (parserResult.errors.length > 0 && options.reporter) {
+    options.reporter(`${absoluteFilePath}: failed to parse`);
+  }
+  return parserResult.comments;
+};
+function replaceCommentsInSourceText(absoluteFilePath, partialSourceText, options) {
+  const comments = getComments(absoluteFilePath, partialSourceText, options);
+  let sourceText = partialSourceText.sourceText;
+  for (const comment of comments) {
+    try {
+      const replacedStr = replaceComments(comment.value, comment.type, options);
+      if (replacedStr !== comment.value) {
+        const newComment = comment.type === "Line" ? `//${replacedStr}` : `/*${replacedStr}*/`;
+        sourceText = sourceText.slice(0, comment.start) + newComment + sourceText.slice(comment.end);
+      }
+    } catch (error) {
+      if (error instanceof Error && options.reporter) {
+        options.reporter(
+          `${absoluteFilePath}, char offset ${comment.start + partialSourceText.offset}: ${error.message}`
+        );
+        continue;
+      }
+      throw error;
+    }
+  }
+  return sourceText;
+}
+function replaceCommentsInFile(absoluteFilePath, fileContent, options) {
+  for (const partialSourceText of partialSourceTextLoader(
+    absoluteFilePath,
+    fileContent
+  )) {
+    const newSourceText = replaceCommentsInSourceText(
+      absoluteFilePath,
+      partialSourceText,
+      options
+    );
+    if (newSourceText !== partialSourceText.sourceText) {
+      fileContent = fileContent.slice(0, partialSourceText.offset) + newSourceText + fileContent.slice(
+        partialSourceText.offset + partialSourceText.sourceText.length
+      );
+    }
+  }
+  return fileContent;
+}
+export {
+  replaceCommentsInFile as default
+};

package/dist/src/walker/replaceCommentsInFile.test.d.ts

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@oxlint/migrate",
-  "version": "1.7.0",
+  "version": "1.8.0",
   "description": "Generates a `.oxlintrc.json` from a existing eslint flat config",
   "type": "module",
   "bin": {
@@ -57,12 +57,15 @@
     "eslint-plugin-jsdoc": "^51.2.3",
     "eslint-plugin-local": "^6.0.0",
     "eslint-plugin-oxlint": "^1.3.0",
+    "eslint-plugin-react": "^7.37.5",
+    "eslint-plugin-react-hooks": "^5.2.0",
+    "eslint-plugin-react-perf": "^3.3.3",
     "eslint-plugin-regexp": "^2.9.0",
     "eslint-plugin-unicorn": "^59.0.1",
     "husky": "^9.1.7",
     "jiti": "^2.4.2",
     "lint-staged": "^16.1.2",
-    "oxlint": "^1.7.0",
+    "oxlint": "^1.8.0",
     "prettier": "^3.6.1",
     "typescript": "^5.8.3",
     "typescript-eslint": "^8.35.0",
@@ -74,7 +77,9 @@
     "*": "prettier --ignore-unknown --write"
   },
   "dependencies": {
-    "commander": "^14.0.0"
+    "commander": "^14.0.0",
+    "oxc-parser": "^0.77.0",
+    "tinyglobby": "^0.2.14"
   },
   "peerDependencies": {
     "globals": "^14.0.0 || ^15.0.0 || ^16.0.0",