@pob/codemods 0.17.1 → 0.18.1

package/bin/migrate.mjs

@@ -13,7 +13,7 @@ const globPaths = argv[1];
 if (!transformerName || !globPaths) {
   const transformerList = readdirSync(
     new URL("../lib/transforms/", import.meta.url),
-  );
+  ).filter((fileName) => fileName.endsWith(".cjs"));
   throw new Error(
     `Usage: pob-migrate <transformer-name> <glob-paths>\n${transformerList
       .map((t) => `- "${t.slice(0, -4)}"`)

package/lib/data/eslint-to-oxlint-rule-names.json

@@ -0,0 +1,492 @@
+{
+  "@pob/forbid-non-native-fetch-import": "@pob/forbid-non-native-fetch-import",
+  "@pob/forbid-non-native-node-imports": "@pob/forbid-non-native-node-imports",
+  "@pob/no-useless-template-literal": "@pob/no-useless-template-literal",
+  "@pob/react-function-component-return-react-node": "@pob/react-function-component-return-react-node",
+  "@pob/react-named-import": "@pob/react-named-import",
+  "@typescript-eslint/adjacent-overload-signatures": "typescript/adjacent-overload-signatures",
+  "@typescript-eslint/array-type": "typescript/array-type",
+  "@typescript-eslint/await-thenable": "typescript/await-thenable",
+  "@typescript-eslint/ban-ts-comment": "typescript/ban-ts-comment",
+  "@typescript-eslint/ban-tslint-comment": "typescript/ban-tslint-comment",
+  "@typescript-eslint/class-literal-property-style": "typescript/class-literal-property-style",
+  "@typescript-eslint/consistent-generic-constructors": "typescript/consistent-generic-constructors",
+  "@typescript-eslint/consistent-indexed-object-style": "typescript/consistent-indexed-object-style",
+  "@typescript-eslint/consistent-type-assertions": "typescript/consistent-type-assertions",
+  "@typescript-eslint/consistent-type-definitions": "typescript/consistent-type-definitions",
+  "@typescript-eslint/consistent-type-exports": "typescript/consistent-type-exports",
+  "@typescript-eslint/consistent-type-imports": "typescript/consistent-type-imports",
+  "@typescript-eslint/default-param-last": "default-param-last",
+  "@typescript-eslint/dot-notation": "typescript/dot-notation",
+  "@typescript-eslint/explicit-function-return-type": "typescript/explicit-function-return-type",
+  "@typescript-eslint/explicit-module-boundary-types": "typescript/explicit-module-boundary-types",
+  "@typescript-eslint/max-params": "max-params",
+  "@typescript-eslint/method-signature-style": "typescript/method-signature-style",
+  "@typescript-eslint/no-array-constructor": "no-array-constructor",
+  "@typescript-eslint/no-array-delete": "typescript/no-array-delete",
+  "@typescript-eslint/no-base-to-string": "typescript/no-base-to-string",
+  "@typescript-eslint/no-confusing-non-null-assertion": "typescript/no-confusing-non-null-assertion",
+  "@typescript-eslint/no-confusing-void-expression": "typescript/no-confusing-void-expression",
+  "@typescript-eslint/no-deprecated": "typescript/no-deprecated",
+  "@typescript-eslint/no-dupe-class-members": "no-dupe-class-members",
+  "@typescript-eslint/no-duplicate-enum-values": "typescript/no-duplicate-enum-values",
+  "@typescript-eslint/no-duplicate-type-constituents": "typescript/no-duplicate-type-constituents",
+  "@typescript-eslint/no-dynamic-delete": "typescript/no-dynamic-delete",
+  "@typescript-eslint/no-empty-function": "no-empty-function",
+  "@typescript-eslint/no-empty-object-type": "typescript/no-empty-object-type",
+  "@typescript-eslint/no-explicit-any": "typescript/no-explicit-any",
+  "@typescript-eslint/no-extra-non-null-assertion": "typescript/no-extra-non-null-assertion",
+  "@typescript-eslint/no-floating-promises": "typescript/no-floating-promises",
+  "@typescript-eslint/no-for-in-array": "typescript/no-for-in-array",
+  "@typescript-eslint/no-implied-eval": "typescript/no-implied-eval",
+  "@typescript-eslint/no-import-type-side-effects": "typescript/no-import-type-side-effects",
+  "@typescript-eslint/no-inferrable-types": "typescript/no-inferrable-types",
+  "@typescript-eslint/no-invalid-void-type": "typescript/no-invalid-void-type",
+  "@typescript-eslint/no-loop-func": "no-loop-func",
+  "@typescript-eslint/no-loss-of-precision": "no-loss-of-precision",
+  "@typescript-eslint/no-meaningless-void-operator": "typescript/no-meaningless-void-operator",
+  "@typescript-eslint/no-misused-new": "typescript/no-misused-new",
+  "@typescript-eslint/no-misused-promises": "typescript/no-misused-promises",
+  "@typescript-eslint/no-misused-spread": "typescript/no-misused-spread",
+  "@typescript-eslint/no-mixed-enums": "typescript/no-mixed-enums",
+  "@typescript-eslint/no-namespace": "typescript/no-namespace",
+  "@typescript-eslint/no-non-null-asserted-nullish-coalescing": "typescript/no-non-null-asserted-nullish-coalescing",
+  "@typescript-eslint/no-non-null-asserted-optional-chain": "typescript/no-non-null-asserted-optional-chain",
+  "@typescript-eslint/no-non-null-assertion": "typescript/no-non-null-assertion",
+  "@typescript-eslint/no-redeclare": "no-redeclare",
+  "@typescript-eslint/no-redundant-type-constituents": "typescript/no-redundant-type-constituents",
+  "@typescript-eslint/no-this-alias": "typescript/no-this-alias",
+  "@typescript-eslint/no-unnecessary-boolean-literal-compare": "typescript/no-unnecessary-boolean-literal-compare",
+  "@typescript-eslint/no-unnecessary-condition": "typescript/no-unnecessary-condition",
+  "@typescript-eslint/no-unnecessary-qualifier": "typescript/no-unnecessary-qualifier",
+  "@typescript-eslint/no-unnecessary-template-expression": "typescript/no-unnecessary-template-expression",
+  "@typescript-eslint/no-unnecessary-type-assertion": "typescript/no-unnecessary-type-assertion",
+  "@typescript-eslint/no-unnecessary-type-constraint": "typescript/no-unnecessary-type-constraint",
+  "@typescript-eslint/no-unnecessary-type-conversion": "typescript/no-unnecessary-type-conversion",
+  "@typescript-eslint/no-unnecessary-type-parameters": "typescript/no-unnecessary-type-parameters",
+  "@typescript-eslint/no-unsafe-argument": "typescript/no-unsafe-argument",
+  "@typescript-eslint/no-unsafe-assignment": "typescript/no-unsafe-assignment",
+  "@typescript-eslint/no-unsafe-call": "typescript/no-unsafe-call",
+  "@typescript-eslint/no-unsafe-declaration-merging": "typescript/no-unsafe-declaration-merging",
+  "@typescript-eslint/no-unsafe-enum-comparison": "typescript/no-unsafe-enum-comparison",
+  "@typescript-eslint/no-unsafe-function-type": "typescript/no-unsafe-function-type",
+  "@typescript-eslint/no-unsafe-member-access": "typescript/no-unsafe-member-access",
+  "@typescript-eslint/no-unsafe-return": "typescript/no-unsafe-return",
+  "@typescript-eslint/no-unsafe-unary-minus": "typescript/no-unsafe-unary-minus",
+  "@typescript-eslint/no-unused-expressions": "no-unused-expressions",
+  "@typescript-eslint/no-unused-private-class-members": "no-unused-private-class-members",
+  "@typescript-eslint/no-unused-vars": "no-unused-vars",
+  "@typescript-eslint/no-use-before-define": "no-use-before-define",
+  "@typescript-eslint/no-useless-constructor": "no-useless-constructor",
+  "@typescript-eslint/no-useless-default-assignment": "typescript/no-useless-default-assignment",
+  "@typescript-eslint/no-useless-empty-export": "typescript/no-useless-empty-export",
+  "@typescript-eslint/no-wrapper-object-types": "typescript/no-wrapper-object-types",
+  "@typescript-eslint/non-nullable-type-assertion-style": "typescript/non-nullable-type-assertion-style",
+  "@typescript-eslint/only-throw-error": "typescript/only-throw-error",
+  "@typescript-eslint/parameter-properties": "typescript/parameter-properties",
+  "@typescript-eslint/prefer-as-const": "typescript/prefer-as-const",
+  "@typescript-eslint/prefer-enum-initializers": "typescript/prefer-enum-initializers",
+  "@typescript-eslint/prefer-find": "typescript/prefer-find",
+  "@typescript-eslint/prefer-function-type": "typescript/prefer-function-type",
+  "@typescript-eslint/prefer-literal-enum-member": "typescript/prefer-literal-enum-member",
+  "@typescript-eslint/prefer-namespace-keyword": "typescript/prefer-namespace-keyword",
+  "@typescript-eslint/prefer-optional-chain": "typescript/prefer-optional-chain",
+  "@typescript-eslint/prefer-promise-reject-errors": "typescript/prefer-promise-reject-errors",
+  "@typescript-eslint/prefer-reduce-type-parameter": "typescript/prefer-reduce-type-parameter",
+  "@typescript-eslint/prefer-regexp-exec": "typescript/prefer-regexp-exec",
+  "@typescript-eslint/prefer-return-this-type": "typescript/prefer-return-this-type",
+  "@typescript-eslint/prefer-string-starts-ends-with": "typescript/prefer-string-starts-ends-with",
+  "@typescript-eslint/related-getter-setter-pairs": "typescript/related-getter-setter-pairs",
+  "@typescript-eslint/require-await": "typescript/require-await",
+  "@typescript-eslint/restrict-plus-operands": "typescript/restrict-plus-operands",
+  "@typescript-eslint/restrict-template-expressions": "typescript/restrict-template-expressions",
+  "@typescript-eslint/return-await": "typescript/return-await",
+  "@typescript-eslint/switch-exhaustiveness-check": "typescript/switch-exhaustiveness-check",
+  "@typescript-eslint/triple-slash-reference": "typescript/triple-slash-reference",
+  "@typescript-eslint/unified-signatures": "typescript/unified-signatures",
+  "@typescript-eslint/use-unknown-in-catch-callback-variable": "typescript/use-unknown-in-catch-callback-variable",
+  "array-callback-return": "array-callback-return",
+  "block-scoped-var": "block-scoped-var",
+  "camelcase": "eslint-js/camelcase",
+  "complexity": "complexity",
+  "constructor-super": "constructor-super",
+  "curly": "curly",
+  "default-case": "default-case",
+  "default-case-last": "default-case-last",
+  "default-param-last": "default-param-last",
+  "dot-notation": "eslint-js/dot-notation",
+  "eqeqeq": "eqeqeq",
+  "for-direction": "for-direction",
+  "func-names": "func-names",
+  "getter-return": "getter-return",
+  "grouped-accessor-pairs": "grouped-accessor-pairs",
+  "guard-for-in": "guard-for-in",
+  "import-x/extensions": "import/extensions",
+  "import-x/first": "import/first",
+  "import-x/named": "import/named",
+  "import-x/namespace": "import/namespace",
+  "import-x/newline-after-import": "import/newline-after-import",
+  "import-x/no-absolute-path": "import/no-absolute-path",
+  "import-x/no-amd": "import/no-amd",
+  "import-x/no-anonymous-default-export": "import/no-anonymous-default-export",
+  "import-x/no-commonjs": "import/no-commonjs",
+  "import-x/no-cycle": "import/no-cycle",
+  "import-x/no-duplicates": "import/no-duplicates",
+  "import-x/no-dynamic-require": "import/no-dynamic-require",
+  "import-x/no-empty-named-blocks": "import/no-empty-named-blocks",
+  "import-x/no-mutable-exports": "import/no-mutable-exports",
+  "import-x/no-named-as-default": "import/no-named-as-default",
+  "import-x/no-named-as-default-member": "import/no-named-as-default-member",
+  "import-x/no-named-default": "import/no-named-default",
+  "import-x/no-self-import": "import/no-self-import",
+  "import-x/no-webpack-loader-syntax": "import/no-webpack-loader-syntax",
+  "jsx-a11y/alt-text": "jsx_a11y/alt-text",
+  "jsx-a11y/anchor-has-content": "jsx_a11y/anchor-has-content",
+  "jsx-a11y/anchor-is-valid": "jsx_a11y/anchor-is-valid",
+  "jsx-a11y/aria-activedescendant-has-tabindex": "jsx_a11y/aria-activedescendant-has-tabindex",
+  "jsx-a11y/aria-props": "jsx_a11y/aria-props",
+  "jsx-a11y/aria-proptypes": "jsx_a11y/aria-proptypes",
+  "jsx-a11y/aria-role": "jsx_a11y/aria-role",
+  "jsx-a11y/aria-unsupported-elements": "jsx_a11y/aria-unsupported-elements",
+  "jsx-a11y/autocomplete-valid": "jsx_a11y/autocomplete-valid",
+  "jsx-a11y/click-events-have-key-events": "jsx_a11y/click-events-have-key-events",
+  "jsx-a11y/heading-has-content": "jsx_a11y/heading-has-content",
+  "jsx-a11y/html-has-lang": "jsx_a11y/html-has-lang",
+  "jsx-a11y/iframe-has-title": "jsx_a11y/iframe-has-title",
+  "jsx-a11y/img-redundant-alt": "jsx_a11y/img-redundant-alt",
+  "jsx-a11y/interactive-supports-focus": "jsx_a11y/interactive-supports-focus",
+  "jsx-a11y/label-has-associated-control": "jsx_a11y/label-has-associated-control",
+  "jsx-a11y/media-has-caption": "jsx_a11y/media-has-caption",
+  "jsx-a11y/mouse-events-have-key-events": "jsx_a11y/mouse-events-have-key-events",
+  "jsx-a11y/no-access-key": "jsx_a11y/no-access-key",
+  "jsx-a11y/no-autofocus": "jsx_a11y/no-autofocus",
+  "jsx-a11y/no-distracting-elements": "jsx_a11y/no-distracting-elements",
+  "jsx-a11y/no-interactive-element-to-noninteractive-role": "jsx_a11y/no-interactive-element-to-noninteractive-role",
+  "jsx-a11y/no-noninteractive-element-interactions": "jsx_a11y/no-noninteractive-element-interactions",
+  "jsx-a11y/no-noninteractive-element-to-interactive-role": "jsx_a11y/no-noninteractive-element-to-interactive-role",
+  "jsx-a11y/no-noninteractive-tabindex": "jsx_a11y/no-noninteractive-tabindex",
+  "jsx-a11y/no-redundant-roles": "jsx_a11y/no-redundant-roles",
+  "jsx-a11y/no-static-element-interactions": "jsx_a11y/no-static-element-interactions",
+  "jsx-a11y/role-has-required-aria-props": "jsx_a11y/role-has-required-aria-props",
+  "jsx-a11y/role-supports-aria-props": "jsx_a11y/role-supports-aria-props",
+  "jsx-a11y/scope": "jsx_a11y/scope",
+  "jsx-a11y/tabindex-no-positive": "jsx_a11y/tabindex-no-positive",
+  "max-depth": "max-depth",
+  "max-params": "max-params",
+  "n/no-deprecated-api": "node-js/no-deprecated-api",
+  "n/no-exports-assign": "node/no-exports-assign",
+  "n/no-new-require": "node/no-new-require",
+  "n/no-path-concat": "node/no-path-concat",
+  "n/no-unpublished-bin": "node-js/no-unpublished-bin",
+  "n/no-unsupported-features/es-builtins": "node-js/no-unsupported-features/es-builtins",
+  "n/no-unsupported-features/es-syntax": "node-js/no-unsupported-features/es-syntax",
+  "n/no-unsupported-features/node-builtins": "node-js/no-unsupported-features/node-builtins",
+  "new-cap": "new-cap",
+  "no-alert": "no-alert",
+  "no-array-constructor": "no-array-constructor",
+  "no-async-promise-executor": "no-async-promise-executor",
+  "no-bitwise": "no-bitwise",
+  "no-caller": "no-caller",
+  "no-case-declarations": "no-case-declarations",
+  "no-class-assign": "no-class-assign",
+  "no-compare-neg-zero": "no-compare-neg-zero",
+  "no-cond-assign": "no-cond-assign",
+  "no-console": "no-console",
+  "no-const-assign": "no-const-assign",
+  "no-constant-binary-expression": "no-constant-binary-expression",
+  "no-constant-condition": "no-constant-condition",
+  "no-constructor-return": "no-constructor-return",
+  "no-control-regex": "no-control-regex",
+  "no-debugger": "no-debugger",
+  "no-delete-var": "no-delete-var",
+  "no-dupe-class-members": "no-dupe-class-members",
+  "no-dupe-else-if": "no-dupe-else-if",
+  "no-dupe-keys": "no-dupe-keys",
+  "no-duplicate-case": "no-duplicate-case",
+  "no-empty-character-class": "no-empty-character-class",
+  "no-empty-function": "no-empty-function",
+  "no-empty-pattern": "no-empty-pattern",
+  "no-empty-static-block": "no-empty-static-block",
+  "no-eval": "no-eval",
+  "no-ex-assign": "no-ex-assign",
+  "no-extend-native": "no-extend-native",
+  "no-extra-bind": "no-extra-bind",
+  "no-extra-boolean-cast": "no-extra-boolean-cast",
+  "no-extra-label": "no-extra-label",
+  "no-fallthrough": "no-fallthrough",
+  "no-func-assign": "no-func-assign",
+  "no-global-assign": "no-global-assign",
+  "no-implied-eval": "no-implied-eval",
+  "no-import-assign": "no-import-assign",
+  "no-invalid-regexp": "no-invalid-regexp",
+  "no-irregular-whitespace": "no-irregular-whitespace",
+  "no-label-var": "no-label-var",
+  "no-labels": "no-labels",
+  "no-lone-blocks": "eslint-js/no-lone-blocks",
+  "no-lonely-if": "no-lonely-if",
+  "no-loop-func": "no-loop-func",
+  "no-loss-of-precision": "no-loss-of-precision",
+  "no-misleading-character-class": "no-misleading-character-class",
+  "no-multi-assign": "no-multi-assign",
+  "no-multi-str": "no-multi-str",
+  "no-nested-ternary": "no-nested-ternary",
+  "no-new": "no-new",
+  "no-new-func": "no-new-func",
+  "no-new-native-nonconstructor": "no-new-native-nonconstructor",
+  "no-new-wrappers": "no-new-wrappers",
+  "no-nonoctal-decimal-escape": "no-nonoctal-decimal-escape",
+  "no-obj-calls": "no-obj-calls",
+  "no-object-constructor": "no-object-constructor",
+  "no-promise-executor-return": "no-promise-executor-return",
+  "no-proto": "no-proto",
+  "no-prototype-builtins": "no-prototype-builtins",
+  "no-redeclare": "no-redeclare",
+  "no-regex-spaces": "no-regex-spaces",
+  "no-restricted-exports": "no-restricted-exports",
+  "no-restricted-globals": "no-restricted-globals",
+  "no-restricted-properties": "no-restricted-properties",
+  "no-restricted-syntax": "eslint-js/no-restricted-syntax",
+  "no-return-assign": "no-return-assign",
+  "no-script-url": "no-script-url",
+  "no-self-assign": "no-self-assign",
+  "no-self-compare": "no-self-compare",
+  "no-sequences": "no-sequences",
+  "no-setter-return": "no-setter-return",
+  "no-shadow-restricted-names": "no-shadow-restricted-names",
+  "no-sparse-arrays": "no-sparse-arrays",
+  "no-template-curly-in-string": "no-template-curly-in-string",
+  "no-this-before-super": "no-this-before-super",
+  "no-throw-literal": "no-throw-literal",
+  "no-unassigned-vars": "no-unassigned-vars",
+  "no-undef-init": "eslint-js/no-undef-init",
+  "no-unexpected-multiline": "no-unexpected-multiline",
+  "no-unneeded-ternary": "no-unneeded-ternary",
+  "no-unreachable": "no-unreachable",
+  "no-unreachable-loop": "no-unreachable-loop",
+  "no-unsafe-finally": "no-unsafe-finally",
+  "no-unsafe-negation": "no-unsafe-negation",
+  "no-unsafe-optional-chaining": "no-unsafe-optional-chaining",
+  "no-unused-expressions": "no-unused-expressions",
+  "no-unused-labels": "no-unused-labels",
+  "no-unused-private-class-members": "no-unused-private-class-members",
+  "no-unused-vars": "no-unused-vars",
+  "no-use-before-define": "no-use-before-define",
+  "no-useless-assignment": "no-useless-assignment",
+  "no-useless-backreference": "no-useless-backreference",
+  "no-useless-catch": "no-useless-catch",
+  "no-useless-computed-key": "no-useless-computed-key",
+  "no-useless-concat": "no-useless-concat",
+  "no-useless-constructor": "no-useless-constructor",
+  "no-useless-escape": "no-useless-escape",
+  "no-useless-rename": "no-useless-rename",
+  "no-useless-return": "no-useless-return",
+  "no-var": "no-var",
+  "no-void": "no-void",
+  "no-with": "no-with",
+  "object-shorthand": "object-shorthand",
+  "prefer-arrow-callback": "prefer-arrow-callback",
+  "prefer-const": "prefer-const",
+  "prefer-exponentiation-operator": "prefer-exponentiation-operator",
+  "prefer-numeric-literals": "prefer-numeric-literals",
+  "prefer-object-has-own": "prefer-object-has-own",
+  "prefer-object-spread": "prefer-object-spread",
+  "prefer-promise-reject-errors": "prefer-promise-reject-errors",
+  "prefer-regex-literals": "prefer-regex-literals",
+  "prefer-rest-params": "prefer-rest-params",
+  "prefer-spread": "prefer-spread",
+  "prefer-template": "prefer-template",
+  "preserve-caught-error": "preserve-caught-error",
+  "radix": "radix",
+  "react-hooks/exhaustive-deps": "react/exhaustive-deps",
+  "react-hooks/rules-of-hooks": "react/rules-of-hooks",
+  "react/button-has-type": "react/button-has-type",
+  "react/function-component-definition": "react/function-component-definition",
+  "react/hook-use-state": "react/hook-use-state",
+  "react/jsx-boolean-value": "react/jsx-boolean-value",
+  "react/jsx-curly-brace-presence": "react/jsx-curly-brace-presence",
+  "react/jsx-fragments": "react/jsx-fragments",
+  "react/jsx-key": "react/jsx-key",
+  "react/jsx-no-comment-textnodes": "react/jsx-no-comment-textnodes",
+  "react/jsx-no-constructed-context-values": "react/jsx-no-constructed-context-values",
+  "react/jsx-no-duplicate-props": "react/jsx-no-duplicate-props",
+  "react/jsx-no-leaked-render": "@pob/jsx-no-leaked-render",
+  "react/jsx-no-script-url": "react/jsx-no-script-url",
+  "react/jsx-no-target-blank": "react/jsx-no-target-blank",
+  "react/jsx-no-undef": "react/jsx-no-undef",
+  "react/jsx-no-useless-fragment": "react/jsx-no-useless-fragment",
+  "react/jsx-pascal-case": "react/jsx-pascal-case",
+  "react/jsx-sort-props": "@pob/jsx-sort-props",
+  "react/no-array-index-key": "react/no-array-index-key",
+  "react/no-children-prop": "react/no-children-prop",
+  "react/no-danger-with-children": "react/no-danger-with-children",
+  "react/no-direct-mutation-state": "react/no-direct-mutation-state",
+  "react/no-find-dom-node": "react/no-find-dom-node",
+  "react/no-is-mounted": "react/no-is-mounted",
+  "react/no-namespace": "react/no-namespace",
+  "react/no-render-return-value": "react/no-render-return-value",
+  "react/no-string-refs": "react/no-string-refs",
+  "react/no-unknown-property": "react/no-unknown-property",
+  "react/no-unstable-nested-components": "react/no-unstable-nested-components",
+  "react/prefer-es6-class": "react/prefer-es6-class",
+  "react/require-render-return": "react/require-render-return",
+  "react/self-closing-comp": "react/self-closing-comp",
+  "regexp/confusing-quantifier": "regexp/confusing-quantifier",
+  "regexp/control-character-escape": "regexp/control-character-escape",
+  "regexp/match-any": "regexp/match-any",
+  "regexp/negation": "regexp/negation",
+  "regexp/no-contradiction-with-assertion": "regexp/no-contradiction-with-assertion",
+  "regexp/no-dupe-characters-character-class": "regexp/no-dupe-characters-character-class",
+  "regexp/no-dupe-disjunctions": "regexp/no-dupe-disjunctions",
+  "regexp/no-empty-alternative": "regexp/no-empty-alternative",
+  "regexp/no-empty-capturing-group": "regexp/no-empty-capturing-group",
+  "regexp/no-empty-character-class": "regexp/no-empty-character-class",
+  "regexp/no-empty-group": "regexp/no-empty-group",
+  "regexp/no-empty-lookarounds-assertion": "regexp/no-empty-lookarounds-assertion",
+  "regexp/no-empty-string-literal": "regexp/no-empty-string-literal",
+  "regexp/no-escape-backspace": "regexp/no-escape-backspace",
+  "regexp/no-extra-lookaround-assertions": "regexp/no-extra-lookaround-assertions",
+  "regexp/no-invalid-regexp": "regexp/no-invalid-regexp",
+  "regexp/no-invisible-character": "regexp/no-invisible-character",
+  "regexp/no-lazy-ends": "regexp/no-lazy-ends",
+  "regexp/no-legacy-features": "regexp/no-legacy-features",
+  "regexp/no-misleading-capturing-group": "regexp/no-misleading-capturing-group",
+  "regexp/no-misleading-unicode-character": "regexp/no-misleading-unicode-character",
+  "regexp/no-missing-g-flag": "regexp/no-missing-g-flag",
+  "regexp/no-non-standard-flag": "regexp/no-non-standard-flag",
+  "regexp/no-obscure-range": "regexp/no-obscure-range",
+  "regexp/no-optional-assertion": "regexp/no-optional-assertion",
+  "regexp/no-potentially-useless-backreference": "regexp/no-potentially-useless-backreference",
+  "regexp/no-super-linear-backtracking": "regexp/no-super-linear-backtracking",
+  "regexp/no-trivially-nested-assertion": "regexp/no-trivially-nested-assertion",
+  "regexp/no-trivially-nested-quantifier": "regexp/no-trivially-nested-quantifier",
+  "regexp/no-unused-capturing-group": "regexp/no-unused-capturing-group",
+  "regexp/no-useless-assertions": "regexp/no-useless-assertions",
+  "regexp/no-useless-backreference": "regexp/no-useless-backreference",
+  "regexp/no-useless-character-class": "regexp/no-useless-character-class",
+  "regexp/no-useless-dollar-replacements": "regexp/no-useless-dollar-replacements",
+  "regexp/no-useless-escape": "regexp/no-useless-escape",
+  "regexp/no-useless-flag": "regexp/no-useless-flag",
+  "regexp/no-useless-lazy": "regexp/no-useless-lazy",
+  "regexp/no-useless-non-capturing-group": "regexp/no-useless-non-capturing-group",
+  "regexp/no-useless-quantifier": "regexp/no-useless-quantifier",
+  "regexp/no-useless-range": "regexp/no-useless-range",
+  "regexp/no-useless-set-operand": "regexp/no-useless-set-operand",
+  "regexp/no-useless-string-literal": "regexp/no-useless-string-literal",
+  "regexp/no-useless-two-nums-quantifier": "regexp/no-useless-two-nums-quantifier",
+  "regexp/no-zero-quantifier": "regexp/no-zero-quantifier",
+  "regexp/optimal-lookaround-quantifier": "regexp/optimal-lookaround-quantifier",
+  "regexp/optimal-quantifier-concatenation": "regexp/optimal-quantifier-concatenation",
+  "regexp/prefer-character-class": "regexp/prefer-character-class",
+  "regexp/prefer-d": "regexp/prefer-d",
+  "regexp/prefer-plus-quantifier": "regexp/prefer-plus-quantifier",
+  "regexp/prefer-predefined-assertion": "regexp/prefer-predefined-assertion",
+  "regexp/prefer-question-quantifier": "regexp/prefer-question-quantifier",
+  "regexp/prefer-range": "regexp/prefer-range",
+  "regexp/prefer-set-operation": "regexp/prefer-set-operation",
+  "regexp/prefer-star-quantifier": "regexp/prefer-star-quantifier",
+  "regexp/prefer-unicode-codepoint-escapes": "regexp/prefer-unicode-codepoint-escapes",
+  "regexp/prefer-w": "regexp/prefer-w",
+  "regexp/simplify-set-operations": "regexp/simplify-set-operations",
+  "regexp/sort-flags": "regexp/sort-flags",
+  "regexp/strict": "regexp/strict",
+  "regexp/use-ignore-case": "regexp/use-ignore-case",
+  "require-await": "require-await",
+  "require-yield": "require-yield",
+  "sort-imports": "sort-imports",
+  "symbol-description": "symbol-description",
+  "unicorn/catch-error-name": "unicorn/catch-error-name",
+  "unicorn/consistent-assert": "unicorn/consistent-assert",
+  "unicorn/consistent-date-clone": "unicorn/consistent-date-clone",
+  "unicorn/consistent-existence-index-check": "unicorn/consistent-existence-index-check",
+  "unicorn/consistent-template-literal-escape": "unicorn/consistent-template-literal-escape",
+  "unicorn/custom-error-definition": "unicorn/custom-error-definition",
+  "unicorn/error-message": "unicorn/error-message",
+  "unicorn/escape-case": "unicorn/escape-case",
+  "unicorn/expiring-todo-comments": "unicorn-js/expiring-todo-comments",
+  "unicorn/explicit-length-check": "unicorn/explicit-length-check",
+  "unicorn/new-for-builtins": "unicorn/new-for-builtins",
+  "unicorn/no-accessor-recursion": "unicorn/no-accessor-recursion",
+  "unicorn/no-array-method-this-argument": "unicorn/no-array-method-this-argument",
+  "unicorn/no-array-reduce": "unicorn/no-array-reduce",
+  "unicorn/no-array-reverse": "unicorn/no-array-reverse",
+  "unicorn/no-array-sort": "unicorn/no-array-sort",
+  "unicorn/no-await-expression-member": "unicorn/no-await-expression-member",
+  "unicorn/no-document-cookie": "unicorn/no-document-cookie",
+  "unicorn/no-hex-escape": "unicorn/no-hex-escape",
+  "unicorn/no-immediate-mutation": "unicorn/no-immediate-mutation",
+  "unicorn/no-instanceof-builtins": "unicorn/no-instanceof-builtins",
+  "unicorn/no-invalid-remove-event-listener": "unicorn/no-invalid-remove-event-listener",
+  "unicorn/no-nested-ternary": "unicorn/no-nested-ternary",
+  "unicorn/no-new-array": "unicorn/no-new-array",
+  "unicorn/no-new-buffer": "unicorn/no-new-buffer",
+  "unicorn/no-process-exit": "unicorn/no-process-exit",
+  "unicorn/no-static-only-class": "unicorn/no-static-only-class",
+  "unicorn/no-this-assignment": "unicorn/no-this-assignment",
+  "unicorn/no-typeof-undefined": "unicorn/no-typeof-undefined",
+  "unicorn/no-unnecessary-await": "unicorn/no-unnecessary-await",
+  "unicorn/no-unnecessary-polyfills": "unicorn-js/no-unnecessary-polyfills",
+  "unicorn/no-unnecessary-slice-end": "unicorn/no-unnecessary-slice-end",
+  "unicorn/no-unreadable-iife": "unicorn/no-unreadable-iife",
+  "unicorn/no-useless-collection-argument": "unicorn/no-useless-collection-argument",
+  "unicorn/no-useless-fallback-in-spread": "unicorn/no-useless-fallback-in-spread",
+  "unicorn/no-useless-iterator-to-array": "unicorn/no-useless-iterator-to-array",
+  "unicorn/no-useless-length-check": "unicorn/no-useless-length-check",
+  "unicorn/no-useless-promise-resolve-reject": "unicorn/no-useless-promise-resolve-reject",
+  "unicorn/no-useless-spread": "unicorn/no-useless-spread",
+  "unicorn/number-literal-case": "unicorn/number-literal-case",
+  "unicorn/numeric-separators-style": "unicorn/numeric-separators-style",
+  "unicorn/prefer-add-event-listener": "unicorn-js/prefer-add-event-listener",
+  "unicorn/prefer-array-find": "unicorn/prefer-array-find",
+  "unicorn/prefer-array-flat": "unicorn/prefer-array-flat",
+  "unicorn/prefer-array-flat-map": "unicorn/prefer-array-flat-map",
+  "unicorn/prefer-array-index-of": "unicorn/prefer-array-index-of",
+  "unicorn/prefer-array-some": "unicorn/prefer-array-some",
+  "unicorn/prefer-at": "unicorn/prefer-at",
+  "unicorn/prefer-blob-reading-methods": "unicorn/prefer-blob-reading-methods",
+  "unicorn/prefer-class-fields": "unicorn/prefer-class-fields",
+  "unicorn/prefer-code-point": "unicorn/prefer-code-point",
+  "unicorn/prefer-date-now": "unicorn/prefer-date-now",
+  "unicorn/prefer-default-parameters": "unicorn/prefer-default-parameters",
+  "unicorn/prefer-dom-node-append": "unicorn/prefer-dom-node-append",
+  "unicorn/prefer-dom-node-dataset": "unicorn/prefer-dom-node-dataset",
+  "unicorn/prefer-dom-node-remove": "unicorn/prefer-dom-node-remove",
+  "unicorn/prefer-dom-node-text-content": "unicorn/prefer-dom-node-text-content",
+  "unicorn/prefer-event-target": "unicorn/prefer-event-target",
+  "unicorn/prefer-export-from": "unicorn/prefer-export-from",
+  "unicorn/prefer-global-this": "unicorn/prefer-global-this",
+  "unicorn/prefer-includes": "unicorn/prefer-includes",
+  "unicorn/prefer-json-parse-buffer": "unicorn-js/prefer-json-parse-buffer",
+  "unicorn/prefer-logical-operator-over-ternary": "unicorn/prefer-logical-operator-over-ternary",
+  "unicorn/prefer-math-min-max": "unicorn/prefer-math-min-max",
+  "unicorn/prefer-math-trunc": "unicorn/prefer-math-trunc",
+  "unicorn/prefer-modern-dom-apis": "unicorn/prefer-modern-dom-apis",
+  "unicorn/prefer-modern-math-apis": "unicorn/prefer-modern-math-apis",
+  "unicorn/prefer-module": "unicorn/prefer-module",
+  "unicorn/prefer-native-coercion-functions": "unicorn/prefer-native-coercion-functions",
+  "unicorn/prefer-negative-index": "unicorn/prefer-negative-index",
+  "unicorn/prefer-node-protocol": "unicorn/prefer-node-protocol",
+  "unicorn/prefer-object-from-entries": "unicorn/prefer-object-from-entries",
+  "unicorn/prefer-optional-catch-binding": "unicorn/prefer-optional-catch-binding",
+  "unicorn/prefer-prototype-methods": "unicorn/prefer-prototype-methods",
+  "unicorn/prefer-regexp-test": "unicorn/prefer-regexp-test",
+  "unicorn/prefer-response-static-json": "unicorn/prefer-response-static-json",
+  "unicorn/prefer-set-size": "unicorn/prefer-set-size",
+  "unicorn/prefer-single-call": "unicorn/prefer-single-call",
+  "unicorn/prefer-spread": "unicorn/prefer-spread",
+  "unicorn/prefer-string-slice": "unicorn/prefer-string-slice",
+  "unicorn/prefer-string-starts-ends-with": "unicorn/prefer-string-starts-ends-with",
+  "unicorn/prefer-string-trim-start-end": "unicorn/prefer-string-trim-start-end",
+  "unicorn/prefer-switch": "unicorn-js/prefer-switch",
+  "unicorn/prefer-top-level-await": "unicorn/prefer-top-level-await",
+  "unicorn/prefer-type-error": "unicorn/prefer-type-error",
+  "unicorn/relative-url-style": "unicorn/relative-url-style",
+  "unicorn/require-array-join-separator": "unicorn/require-array-join-separator",
+  "unicorn/require-number-to-fixed-digits-argument": "unicorn/require-number-to-fixed-digits-argument",
+  "unicorn/require-post-message-target-origin": "unicorn/require-post-message-target-origin",
+  "unicorn/switch-case-break-position": "unicorn/switch-case-break-position",
+  "unicorn/text-encoding-identifier-case": "unicorn/text-encoding-identifier-case",
+  "unicorn/throw-new-error": "unicorn/throw-new-error",
+  "use-isnan": "use-isnan",
+  "valid-typeof": "valid-typeof",
+  "yoda": "yoda"
+}

package/lib/index.js

@@ -0,0 +1,18 @@
+import { fileURLToPath } from "node:url";
+import runJscodeshift from "./runJscodeshift.cjs";
+
+/**
+ * Runs a transform of lib/transforms on `paths`, like `pob-migrate`.
+ *
+ * @param {string} transformName
+ * @param {string[]} paths
+ * @param {Record<string, unknown>} [options] jscodeshift runner options
+ */
+export const runTransform = (transformName, paths, options = {}) =>
+  runJscodeshift(
+    fileURLToPath(
+      new URL(`./transforms/${transformName}.cjs`, import.meta.url),
+    ),
+    paths,
+    options,
+  );

package/lib/runJscodeshift.cjs

@@ -0,0 +1,7 @@
+"use strict";
+
+const { run: jscodeshift } = require("jscodeshift/src/Runner");
+
+module.exports = (...args) => {
+  return jscodeshift(...args);
+};

package/lib/transforms/jest-to-node-runner.cjs

@@ -0,0 +1,146 @@
+/* oxlint-disable unicorn/prefer-array-some */
+/* oxlint-disable unicorn/no-array-method-this-argument */
+
+"use strict";
+
+const { prependImport } = require("../utils/prependImport.cjs");
+
+const jestToNodeGlobalMethods = {
+  test: "test",
+  describe: "describe",
+  it: "it",
+  beforeAll: "before",
+  afterAll: "after",
+  beforeEach: "beforeEach",
+  afterEach: "afterEach",
+};
+const propertiesMap = {
+  toBe: { default: "equal", not: "notEqual" },
+  toStrictEqual: { default: "equal", not: "notEqual" },
+  toEqual: { default: "equal", not: "notEqual" },
+};
+
+// const mocks = {
+//   toHaveBeenCalledTimes: {
+//     default: 'mock.calls.length',
+//   },
+// };
+
+module.exports = (file, api, options) => {
+  if (
+    !(
+      file.path.endsWith(".test.js") ||
+      file.path.endsWith(".test.ts") ||
+      file.path.endsWith(".test.tsx")
+    )
+  ) {
+    throw new Error(`Invalid file: "${file.path}"`);
+  }
+
+  const j = api.jscodeshift.withParser("tsx");
+  const root = j(file.source);
+
+  function updateTopLevelMethods() {
+    const topLevelMethodsUsed = new Set();
+
+    root
+      .find(j.CallExpression, {
+        callee: {
+          type: j.Identifier.name,
+          name: (name) => Object.keys(jestToNodeGlobalMethods).includes(name),
+        },
+      })
+      .replaceWith((p) => {
+        const { value } = p;
+        const replaceValue = jestToNodeGlobalMethods[value.callee.name];
+        topLevelMethodsUsed.add(replaceValue);
+
+        return j.callExpression(j.identifier(replaceValue), value.arguments);
+      });
+
+    if (topLevelMethodsUsed.size > 0) {
+      prependImport(
+        j,
+        root,
+        j.importDeclaration(
+          [...topLevelMethodsUsed].map((method) =>
+            j.importSpecifier(j.identifier(method)),
+          ),
+          j.stringLiteral("node:test"),
+        ),
+      );
+    }
+  }
+
+  function updateAssertions() {
+    let hasAssertions = false;
+
+    root
+      .find(j.MemberExpression, {
+        object: {
+          callee: { name: "expect" },
+        },
+      })
+      .forEach((memberExpressionPath) => {
+        const { value: memberExpression, parentPath } = memberExpressionPath;
+        let memberExpressionPathToReplace = memberExpressionPath;
+        let propertyName = memberExpression.property.name;
+        let not = false;
+        if (propertyName === "not") {
+          not = true;
+          memberExpressionPathToReplace = parentPath;
+          propertyName = parentPath.value.property.name;
+        }
+
+        if (!propertiesMap[propertyName]) {
+          console.warn(
+            `Unsupported expect property: ${propertyName} in ${file.path}`,
+          );
+          return;
+        }
+
+        const assertPropertyName =
+          propertiesMap[propertyName][not ? "not" : "default"];
+        const callExpressionPath = memberExpressionPathToReplace.parentPath;
+
+        const value = memberExpression.object.arguments[0];
+        const expected = callExpressionPath.value.arguments[0];
+
+        hasAssertions = true;
+        callExpressionPath.value.callee = j.memberExpression(
+          j.identifier("assert"),
+          j.identifier(assertPropertyName),
+        );
+        callExpressionPath.value.arguments = [value, expected];
+      });
+
+    if (hasAssertions) {
+      root
+        .find(j.ImportDeclaration, { source: { value: "node:assert" } })
+        .remove();
+      if (
+        // oxlint-disable-next-line no-constant-condition
+        (!root.find(j.ImportDeclaration),
+        { source: { value: "node:assert/strict" } })
+      ) {
+        prependImport(
+          j,
+          root,
+          j.importDeclaration(
+            [j.importDefaultSpecifier(j.identifier("assert"))],
+            j.stringLiteral("node:assert/strict"),
+          ),
+        );
+      }
+    }
+  }
+
+  updateTopLevelMethods();
+  updateAssertions();
+
+  root
+    .find(j.ImportDeclaration, { source: { value: "@jest/globals" } })
+    .remove();
+
+  return root.toSource(options);
+};

package/lib/transforms/oxlint-directives.cjs

@@ -0,0 +1,31 @@
+"use strict";
+
+const { parse } = require("@babel/parser");
+const { rewriteDirectiveComments } = require("../utils/oxlintDirectives.cjs");
+
+/**
+ * Rewrites the eslint directive comments of rules moved to oxlint, for the
+ * major of @pob/eslint-config that no longer runs them in eslint.
+ *
+ * @type {import("jscodeshift").Transform}
+ */
+module.exports = (file) => {
+  const isTypescript = /\.[cm]?ts$/.test(file.path);
+  const { comments = [] } = parse(file.source, {
+    // .cjs files may use sloppy mode syntax
+    sourceType: /\.c[jt]s$/.test(file.path) ? "script" : "unambiguous",
+    allowReturnOutsideFunction: true,
+    // only comments are needed: syntax errors do not matter
+    errorRecovery: true,
+    plugins: isTypescript
+      ? ["typescript", "decorators-legacy"]
+      : ["typescript", "jsx", "decorators-legacy"],
+  });
+  const result = rewriteDirectiveComments(
+    file.source,
+    /** @type {{ type: string; value: string; start: number; end: number }[]} */ (
+      comments
+    ),
+  );
+  return result === file.source ? undefined : result;
+};

package/lib/transforms/oxlint-eslint-config.cjs

@@ -0,0 +1,194 @@
+"use strict";
+
+const {
+  eslintToOxlintRuleNames,
+  isRemovedEslintPluginRule,
+} = require("../utils/oxlintDirectives.cjs");
+
+// configs of @pob/eslint-config and @pob/eslint-config-typescript-react left
+// without rules once oxlint runs every rule it supports
+const removedConfigNames = new Set([
+  "allowImplicitReturnType",
+  "allowUnsafe",
+  "allowUnsafeAsWarn",
+  "app",
+  "oxlint",
+]);
+
+const renamedConfigNames = new Map([
+  ["nodeCommonjs", "node"],
+  ["nodeModule", "node"],
+]);
+
+/**
+ * Updates eslint.config.js for the major of @pob/eslint-config running every
+ * rule supported by oxlint in oxlint only: removes the configs left empty,
+ * renames the deprecated ones, and removes the rule entries of rules moved to
+ * oxlint (reported: their options go in .oxlintrc.json).
+ *
+ * @type {import("jscodeshift").Transform}
+ */
+module.exports = (file, api) => {
+  const j = api.jscodeshift.withParser("tsx");
+  const root = j(file.source);
+  let hasModifications = false;
+
+  /** @param {any} node */
+  const getLine = (node) => (node.loc ? `:${node.loc.start.line}` : "");
+
+  /**
+   * @param {any} key
+   * @param {boolean} [computed]
+   */
+  const getKeyName = (key, computed) => {
+    if (key.type === "Identifier" && !computed) return key.name;
+    if (
+      (key.type === "StringLiteral" || key.type === "Literal") &&
+      typeof key.value === "string"
+    ) {
+      return key.value;
+    }
+    return undefined;
+  };
+
+  /** @param {any} node */
+  const getPropertyName = (node) => getKeyName(node.property, node.computed);
+
+  /** `<x>.configs.<name>` or `configs.<name>` */
+  const isConfigsMember = (/** @type {any} */ node) =>
+    node.type === "MemberExpression" &&
+    ((node.object.type === "Identifier" && node.object.name === "configs") ||
+      (node.object.type === "MemberExpression" &&
+        getPropertyName(node.object) === "configs"));
+
+  /**
+   * Removes the closest spread element of an array containing `path`, like
+   * `...apply({ configs: [] })`.
+   *
+   * @param {any} path
+   */
+  const removeEnclosingSpread = (path) => {
+    let current = path.parent;
+    while (current) {
+      if (
+        current.value.type === "SpreadElement" &&
+        current.parent.value.type === "ArrayExpression"
+      ) {
+        current.prune();
+        return true;
+      }
+      current = current.parent;
+    }
+    return false;
+  };
+
+  /** @param {any} node */
+  const isConfigsProperty = (node) =>
+    (node.type === "Property" || node.type === "ObjectProperty") &&
+    getKeyName(node.key, node.computed) === "configs";
+
+  /**
+   * Removes an element of an array, and the apply() call whose `configs` it
+   * leaves empty.
+   *
+   * @param {any} elementPath
+   */
+  const pruneArrayElement = (elementPath) => {
+    const array = elementPath.parent;
+    elementPath.prune();
+    if (
+      array.value.elements.length === 0 &&
+      isConfigsProperty(array.parent.value)
+    ) {
+      removeEnclosingSpread(array);
+    }
+  };
+
+  root
+    .find(j.MemberExpression)
+    .filter((path) => isConfigsMember(path.value))
+    .forEach((path) => {
+      const name = getPropertyName(path.value);
+      if (!name) return;
+
+      const renamed = renamedConfigNames.get(name);
+      if (renamed) {
+        path.value.property = j.identifier(renamed);
+        path.value.computed = false;
+        hasModifications = true;
+        return;
+      }
+
+      if (!removedConfigNames.has(name)) return;
+
+      const parent = path.parent.value;
+      if (
+        parent.type === "SpreadElement" &&
+        path.parent.parent.value.type === "ArrayExpression"
+      ) {
+        pruneArrayElement(path.parent);
+        hasModifications = true;
+        return;
+      }
+
+      if (
+        isConfigsProperty(parent) &&
+        parent.value === path.value &&
+        removeEnclosingSpread(path)
+      ) {
+        hasModifications = true;
+        return;
+      }
+
+      api.report(
+        `${file.path}${getLine(path.value)}: "configs.${name}" was removed, update this usage by hand.`,
+      );
+    });
+
+  // rule entries of rules moved to oxlint
+  root
+    .find(j.Node)
+    .filter(
+      (path) =>
+        (path.value.type === "Property" ||
+          path.value.type === "ObjectProperty") &&
+        getKeyName(path.value.key, path.value.computed) === "rules" &&
+        path.value.value.type === "ObjectExpression",
+    )
+    .forEach((path) => {
+      const rules = path.value.value;
+      rules.properties = rules.properties.filter((/** @type {any} */ rule) => {
+        const ruleName = getKeyName(rule.key, rule.computed);
+        if (typeof ruleName !== "string") return true;
+        const oxlintRuleName = eslintToOxlintRuleNames[ruleName];
+        if (!oxlintRuleName && !isRemovedEslintPluginRule(ruleName)) {
+          return true;
+        }
+        hasModifications = true;
+        api.report(
+          oxlintRuleName
+            ? `${file.path}${getLine(rule)}: "${ruleName}" is checked by oxlint: configure "${oxlintRuleName}" in .oxlintrc.json instead.`
+            : `${file.path}${getLine(rule)}: "${ruleName}" was removed.`,
+        );
+        return false;
+      });
+      if (rules.properties.length > 0) return;
+
+      // remove the config when the rules were all it configured
+      const config = path.parent;
+      config.value.properties = config.value.properties.filter(
+        (/** @type {any} */ property) => property !== path.value,
+      );
+      const isEmptyConfig = config.value.properties.every(
+        (/** @type {any} */ property) =>
+          ["files", "ignores", "name"].includes(
+            getKeyName(property.key, property.computed) ?? "",
+          ),
+      );
+      if (isEmptyConfig && config.parent.value.type === "ArrayExpression") {
+        pruneArrayElement(config);
+      }
+    });
+
+  return hasModifications ? root.toSource({ trailingComma: true }) : undefined;
+};

package/lib/transforms/update-function-component-return-type.cjs

@@ -0,0 +1,88 @@
+"use strict";
+
+module.exports = (file, api, options) => {
+  const j = api.jscodeshift.withParser("tsx");
+  const root = j(file.source);
+  let hasModifications = false;
+
+  function processFunctionComponent(path) {
+    const node = path.value;
+    const { returnType } = node;
+    if (returnType == null) return;
+    if (returnType.type !== "TSTypeAnnotation") return;
+    const { typeAnnotation } = returnType;
+    if (typeAnnotation == null) return;
+
+    if (
+      typeAnnotation.type === "TSTypeReference" &&
+      typeAnnotation.typeName &&
+      typeAnnotation.typeName.type === "Identifier"
+    ) {
+      if (typeAnnotation.typeName.name === "ReactElement") {
+        typeAnnotation.typeName.name = "ReactNode";
+        hasModifications = true;
+      }
+    } else if (
+      typeAnnotation.type === "TSUnionType" &&
+      typeAnnotation.types.every((unionTypeItem) => {
+        if (unionTypeItem.type === "TSTypeReference") {
+          return (
+            unionTypeItem.typeName &&
+            unionTypeItem.typeName.type === "Identifier" &&
+            unionTypeItem.typeName.name === "ReactElement"
+          );
+        }
+
+        if (unionTypeItem.type === "TSNullKeyword") {
+          return true;
+        }
+
+        return false;
+      })
+    ) {
+      returnType.typeAnnotation = j.tsTypeReference(j.identifier("ReactNode"));
+      hasModifications = true;
+    }
+  }
+
+  root.find(j.FunctionDeclaration).forEach(processFunctionComponent);
+
+  if (hasModifications) {
+    root.find(j.ImportDeclaration).forEach((importDeclaration) => {
+      const { node } = importDeclaration;
+      if (node.source.value !== "react") return;
+      if (node.importKind !== "type") return;
+
+      node.specifiers = node.specifiers.filter((importSpecifier) => {
+        if (importSpecifier.local.name !== "ReactElement") return true;
+        if (importSpecifier.importKind !== "value") return true;
+        return (
+          j(importDeclaration)
+            .closestScope()
+            // oxlint-disable-next-line unicorn/no-array-method-this-argument -- not an array
+            .find(j.Identifier, { name: "ReactElement" })
+            .filter((p) => {
+              if (p.value.start === importSpecifier.local.start) return false;
+              if (p.parentPath.value.type === "Property" && p.name === "key") {
+                return false;
+              }
+              if (p.name === "property") return false;
+              return true;
+            })
+            .size() > 0
+        );
+      });
+      if (
+        !node.specifiers.some(
+          (specifier) =>
+            specifier.type === "ImportSpecifier" &&
+            specifier.imported.name === "ReactNode",
+        )
+      ) {
+        node.specifiers.push(j.importSpecifier(j.identifier("ReactNode")));
+      }
+    });
+  }
+
+  return hasModifications ? root.toSource(options) : null;
+};

package/lib/utils/oxlintDirectives.cjs

@@ -0,0 +1,220 @@
+"use strict";
+
+// eslint rule name → oxlint rule name, for every rule of the oxlint configs of
+// @pob/eslint-config and @pob/eslint-config-typescript-react, frozen at the
+// last version running them in eslint too.
+const eslintToOxlintRuleNames = require("../data/eslint-to-oxlint-rule-names.json");
+
+// plugins no longer loaded by @pob/eslint-config: eslint reports a directive
+// naming one of their rules as "Definition for rule ... was not found"
+const removedEslintPluginPrefixes = [
+  "@pob/",
+  "@typescript-eslint/",
+  "jsx-a11y/",
+  "react-hooks/",
+  "react/",
+  "regexp/",
+  "unicorn/",
+];
+
+// rules of the eslint-plugin-react JS plugin of oxlint (react-js), removed
+// with eslint-plugin-react: renamed when moved to @pob/eslint-plugin
+const renamedOxlintRuleNames = new Map([
+  ["react-js/jsx-no-leaked-render", "@pob/jsx-no-leaked-render"],
+  ["react-js/jsx-sort-props", "@pob/jsx-sort-props"],
+]);
+const removedOxlintPluginPrefixes = ["react-js/"];
+
+/** @param {string} ruleName */
+const isRemovedEslintPluginRule = (ruleName) =>
+  removedEslintPluginPrefixes.some((prefix) => ruleName.startsWith(prefix));
+
+const directiveRegExp =
+  /^\s*(eslint|oxlint)-(disable-next-line|disable-line|disable|enable)(?=\s|$)/;
+
+// same as eslint: the description starts at the first " -- "
+const descriptionRegExp = /\s-{2,}\s/;
+
+/**
+ * @param {string} commentValue the comment without its delimiters
+ */
+const parseDirective = (commentValue) => {
+  const [content, ...descriptionParts] = commentValue.split(descriptionRegExp);
+  const match = directiveRegExp.exec(content);
+  if (!match) return undefined;
+  const [prefix, tool, kind] = match;
+  const ruleList = content.slice(prefix.length);
+  return {
+    tool,
+    kind,
+    ruleNames: ruleList
+      .split(",")
+      .map((ruleName) => ruleName.trim())
+      .filter(Boolean),
+    description:
+      descriptionParts.length > 0
+        ? commentValue.slice(content.length).trim()
+        : undefined,
+  };
+};
+
+/**
+ * @param {string[]} ruleNames
+ */
+const splitRuleNames = (ruleNames) => {
+  /** @type {Set<string>} */
+  const eslintRuleNames = new Set();
+  /** @type {Set<string>} */
+  const oxlintRuleNames = new Set();
+  for (const ruleName of ruleNames) {
+    const oxlintRuleName = eslintToOxlintRuleNames[ruleName];
+    if (oxlintRuleName) {
+      oxlintRuleNames.add(oxlintRuleName);
+    } else if (!isRemovedEslintPluginRule(ruleName)) {
+      eslintRuleNames.add(ruleName);
+    }
+  }
+  return {
+    eslintRuleNames: [...eslintRuleNames],
+    oxlintRuleNames: [...oxlintRuleNames],
+  };
+};
+
+/**
+ * @param {"eslint" | "oxlint"} tool
+ * @param {string} kind
+ * @param {string[]} ruleNames
+ * @param {string | undefined} description
+ */
+const formatDirective = (tool, kind, ruleNames, description) =>
+  [`${tool}-${kind}`, ruleNames.join(", "), description]
+    .filter(Boolean)
+    .join(" ");
+
+/**
+ * Renames or removes the rules of the react-js JS plugin in an oxlint
+ * directive comment.
+ *
+ * @param {{ type: "CommentLine" | "CommentBlock" }} comment
+ * @param {{ kind: string; ruleNames: string[]; description: string | undefined }} directive
+ * @returns {string | null | undefined}
+ */
+const rewriteOxlintDirective = (comment, { kind, ruleNames, description }) => {
+  const newRuleNames = [
+    ...new Set(
+      ruleNames
+        .map((ruleName) => renamedOxlintRuleNames.get(ruleName) ?? ruleName)
+        .filter(
+          (ruleName) =>
+            !removedOxlintPluginPrefixes.some((prefix) =>
+              ruleName.startsWith(prefix),
+            ),
+        ),
+    ),
+  ];
+  if (
+    newRuleNames.length === ruleNames.length &&
+    newRuleNames.every((ruleName, index) => ruleName === ruleNames[index])
+  ) {
+    return undefined;
+  }
+  if (newRuleNames.length === 0) return null;
+  const text = formatDirective("oxlint", kind, newRuleNames, description);
+  return comment.type === "CommentBlock" ? `/* ${text} */` : `// ${text}`;
+};
+
+/**
+ * Rewrites an eslint directive comment for @pob/eslint-config running the
+ * moved rules in oxlint only: their names move to an `oxlint-` directive of
+ * the same kind, rules of removed eslint plugins are dropped.
+ *
+ * @param {{ type: "CommentLine" | "CommentBlock"; value: string }} comment
+ * @returns {string | null | undefined} the new comment text, `null` to remove
+ *   the comment, `undefined` when unchanged
+ */
+const rewriteDirectiveComment = (comment) => {
+  const directive = parseDirective(comment.value);
+  if (!directive) return undefined;
+  const { tool, kind, ruleNames, description } = directive;
+  if (tool === "oxlint") return rewriteOxlintDirective(comment, directive);
+
+  // a blanket directive disables every rule, now in both tools
+  if (ruleNames.length === 0) {
+    const eslintDirective = `/* ${comment.value.trim()} */`;
+    const oxlintDirective = formatDirective("oxlint", kind, [], description);
+    return comment.type === "CommentLine"
+      ? `${eslintDirective} // ${oxlintDirective}`
+      : `${eslintDirective} /* ${oxlintDirective} */`;
+  }
+
+  const { eslintRuleNames, oxlintRuleNames } = splitRuleNames(ruleNames);
+  if (oxlintRuleNames.length === 0) {
+    if (eslintRuleNames.length === ruleNames.length) return undefined;
+    if (eslintRuleNames.length === 0) return null;
+  }
+
+  const directives = [
+    eslintRuleNames.length > 0 &&
+      formatDirective("eslint", kind, eslintRuleNames, description),
+    oxlintRuleNames.length > 0 &&
+      formatDirective("oxlint", kind, oxlintRuleNames, description),
+  ].filter(Boolean);
+
+  if (comment.type === "CommentBlock") {
+    return directives.map((text) => `/* ${text} */`).join(" ");
+  }
+  // a line comment ends the line: only the last directive can be one
+  return directives
+    .map((text, index) =>
+      index === directives.length - 1 ? `// ${text}` : `/* ${text} */`,
+    )
+    .join(" ");
+};
+
+/**
+ * @param {string} source
+ * @param {{ type: string; value: string; start: number; end: number }[]} comments
+ * @returns {string}
+ */
+const rewriteDirectiveComments = (source, comments) => {
+  let result = source;
+  // from the end, so that the offsets of the previous comments stay valid
+  for (const comment of comments.toSorted((a, b) => b.start - a.start)) {
+    if (comment.type !== "CommentLine" && comment.type !== "CommentBlock") {
+      continue;
+    }
+    const replacement = rewriteDirectiveComment(
+      /** @type {{ type: "CommentLine" | "CommentBlock"; value: string }} */ (
+        comment
+      ),
+    );
+    if (replacement === undefined) continue;
+
+    let start = comment.start;
+    let end = comment.end;
+    if (replacement === null) {
+      // remove the whole line when the comment is alone on it
+      const lineStart = result.lastIndexOf("\n", start - 1) + 1;
+      const lineEndIndex = result.indexOf("\n", end);
+      const lineEnd = lineEndIndex === -1 ? result.length : lineEndIndex;
+      const before = result.slice(lineStart, start);
+      const after = result.slice(end, lineEnd);
+      if (before.trim() === "" && after.trim() === "") {
+        start = lineStart;
+        end = lineEndIndex === -1 ? lineEnd : lineEnd + 1;
+      } else if (before.trim() !== "") {
+        // trailing comment: also remove the spaces before it
+        start = lineStart + before.trimEnd().length;
+      }
+    }
+    result = result.slice(0, start) + (replacement ?? "") + result.slice(end);
+  }
+  return result;
+};
+
+module.exports = {
+  eslintToOxlintRuleNames,
+  isRemovedEslintPluginRule,
+  rewriteDirectiveComment,
+  rewriteDirectiveComments,
+};

package/lib/utils/prependImport.cjs

@@ -0,0 +1,35 @@
+"use strict";
+
+exports.prependImport = (j, source, importDeclaration) => {
+  const existingImports = source.find(j.ImportDeclaration);
+  if (existingImports.length > 0) {
+    const firstImport = existingImports.at(0);
+    const firstImportNode = firstImport.nodes()[0];
+    if (firstImportNode?.comments) {
+      importDeclaration.comments = firstImportNode.comments;
+      firstImportNode.comments = null;
+    }
+
+    firstImport.insertBefore(importDeclaration);
+    return;
+  }
+
+  const firstNode = source.find(j.Program).get("body", 0).node;
+  const { comments } = firstNode;
+  if (comments?.length) {
+    const comment = comments[0];
+
+    // Only move comments that look like file-level comments. Ignore
+    // line-level and JSDoc-style comments because these probably belong
+    // to the first node, rather than the file.
+    if (
+      (comment.type === "Block" || comment.type === "CommentBlock") &&
+      !comment.value.startsWith("*")
+    ) {
+      importDeclaration.comments = comments;
+      firstNode.comments = null;
+    }
+  }
+
+  source.get("program", "body").unshift(importDeclaration);
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pob/codemods",
-  "version": "0.17.1",
+  "version": "0.18.1",
   "description": "codemods for pob",
   "keywords": [],
   "homepage": "https://github.com/christophehurpeau/pob",
@@ -18,10 +18,9 @@
     "pob-migrate": "./bin/migrate.mjs"
   },
   "files": [
-    "src",
-    "build",
     "bin",
-    "lib/index.js"
+    "lib",
+    "!lib/**/*.test.js"
   ],
   "type": "module",
   "main": "./lib/index.js",
@@ -33,6 +32,7 @@
     "access": "public"
   },
   "dependencies": {
+    "@babel/parser": "7.29.9",
     "jscodeshift": "17.4.0"
   },
   "devDependencies": {