Merge branch 'main' into recommended-rules-v7

* main:
  feat: migrate package to TypeScript and publish types (eslint-community#534)
  build: convert eslint-remote-tester config to typescript (eslint-community#533)
  refactor: remove context compat functions (eslint-community#532)
  build: migrate eslint.config.js to typescript  (eslint-community#531)

Author: bmish

.github/workflows/main.yml

@@ -45,3 +45,13 @@ jobs:
           node-version: 'lts/*'
       - run: npm install
       - run: npm run test:remote
+
+  typecheck:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-node@v4
+        with:
+          node-version: 'lts/*'
+      - run: npm install
+      - run: npm run typecheck

.github/workflows/release-please.yml

@@ -38,6 +38,7 @@ jobs:
         if: ${{ steps.release.outputs.release_created }}
       - run: |
           npm install --force
+          npm run build
           npm publish --provenance
         env:
           NODE_AUTH_TOKEN: ${{ secrets.NPM_TOKEN }}

.gitignore

@@ -1,10 +1,11 @@
-.idea
-coverage
+.idea/
+coverage/
 .vscode
 node_modules/
 npm-debug.log
 yarn.lock
 .eslintcache
+dist/
 
 # eslint-remote-tester
 eslint-remote-tester-results

eslint-remote-tester.config.mjs renamed to eslint-remote-tester.config.ts

@@ -1,7 +1,9 @@
-import eslintPlugin from 'eslint-plugin-eslint-plugin';
 import tsparser from '@typescript-eslint/parser';
+import type { Config } from 'eslint-remote-tester';
+
+// @ts-expect-error - eslint-plugin is not typed yet
+import eslintPlugin from './lib/index.js';
 
-/** @type {import('eslint-remote-tester').Config} */
 export default {
   /** Repositories to scan */
   repositories: [
@@ -43,6 +45,7 @@ export default {
   cache: false,
 
   /** ESLint configuration */
+  // @ts-expect-error - eslint-plugin is not typed yet
   eslintConfig: [
     {
       files: ['**/*.{js,mjs,cjs,ts,mts,cts}'],
@@ -56,4 +59,4 @@ export default {
       },
     },
   ],
-};
+} satisfies Config;

eslint.config.js renamed to eslint.config.ts

@@ -2,6 +2,7 @@ import path from 'node:path';
 import { fileURLToPath } from 'node:url';
 import js from '@eslint/js';
 import { FlatCompat } from '@eslint/eslintrc';
+import { defineConfig } from 'eslint/config';
 import markdown from 'eslint-plugin-markdown';
 import pluginN from 'eslint-plugin-n';
 import eslintPlugin from './lib/index.js';
@@ -12,10 +13,10 @@ const compat = new FlatCompat({
   recommendedConfig: js.configs.recommended,
 });
 
-export default [
+export default defineConfig([
   // Global ignores
   {
-    ignores: ['node_modules', 'coverage'],
+    ignores: ['node_modules', 'coverage', 'dist'],
   },
   // Global settings
   {
@@ -39,7 +40,6 @@ export default [
       'unicorn/no-array-reduce': 'off',
       'unicorn/no-null': 'off',
       'unicorn/prefer-module': 'off',
-      'unicorn/prefer-node-protocol': 'off', // TODO: enable once we drop support for Node 14.17.
       'unicorn/prevent-abbreviations': 'off',
     },
   },
@@ -82,4 +82,4 @@ export default [
       'unicorn/filename-case': 'off',
     },
   },
-];
+]);

lib/index.js renamed to lib/index.ts

@@ -2,12 +2,10 @@
  * @fileoverview An ESLint plugin for linting ESLint plugins
  * @author Teddy Katz
  */
+import { createRequire } from 'node:module';
 
-// ------------------------------------------------------------------------------
-// Requirements
-// ------------------------------------------------------------------------------
+import type { ESLint, Linter, Rule } from 'eslint';
 
-import packageMetadata from '../package.json' with { type: 'json' };
 import consistentOutput from './rules/consistent-output.js';
 import fixerReturn from './rules/fixer-return.js';
 import metaPropertyOrdering from './rules/meta-property-ordering.js';
@@ -41,20 +39,56 @@ import requireMetaType from './rules/require-meta-type.js';
 import testCasePropertyOrdering from './rules/test-case-property-ordering.js';
 import testCaseShorthandStrings from './rules/test-case-shorthand-strings.js';
 
+const require = createRequire(import.meta.url);
+
+const packageMetadata = require("../package.json") as {
+	name: string;
+	version: string;
+};
+
 const PLUGIN_NAME = packageMetadata.name.replace(/^eslint-plugin-/, '');
+const CONFIG_NAMES = [
+  'all',
+  'all-type-checked',
+  'recommended',
+  'rules',
+  'tests',
+  'rules-recommended',
+  'tests-recommended',
+] as const;
+type ConfigName = (typeof CONFIG_NAMES)[number];
 
-const configFilters = {
-  all: (rule) => !rule.meta.docs.requiresTypeChecking,
+const configFilters: Record<ConfigName, (rule: Rule.RuleModule) => boolean> = {
+  all: (rule: Rule.RuleModule) =>
+    !(
+      rule.meta?.docs &&
+      'requiresTypeChecking' in rule.meta.docs &&
+      rule.meta.docs.requiresTypeChecking
+    ),
   'all-type-checked': () => true,
-  recommended: (rule) => rule.meta.docs.recommended,
-  rules: (rule) => rule.meta.docs.category === 'Rules',
-  tests: (rule) => rule.meta.docs.category === 'Tests',
-  'rules-recommended': (rule) =>
+  recommended: (rule: Rule.RuleModule) => !!rule.meta?.docs?.recommended,
+  rules: (rule: Rule.RuleModule) => rule.meta?.docs?.category === 'Rules',
+  tests: (rule: Rule.RuleModule) => rule.meta?.docs?.category === 'Tests',
+  'rules-recommended': (rule: Rule.RuleModule) =>
     configFilters.recommended(rule) && configFilters.rules(rule),
-  'tests-recommended': (rule) =>
+  'tests-recommended': (rule: Rule.RuleModule) =>
     configFilters.recommended(rule) && configFilters.tests(rule),
 };
 
+const createConfig = (configName: ConfigName): Linter.Config => ({
+  name: `${PLUGIN_NAME}/${configName}`,
+  plugins: {
+    get [PLUGIN_NAME](): ESLint.Plugin {
+      return plugin;
+    },
+  },
+  rules: Object.fromEntries(
+    (Object.keys(allRules) as (keyof typeof allRules)[])
+      .filter((ruleName) => configFilters[configName](allRules[ruleName]))
+      .map((ruleName) => [`${PLUGIN_NAME}/${ruleName}`, 'error']),
+  ),
+});
+
 // ------------------------------------------------------------------------------
 // Plugin Definition
 // ------------------------------------------------------------------------------
@@ -93,34 +127,23 @@ const allRules = {
   'require-meta-type': requireMetaType,
   'test-case-property-ordering': testCasePropertyOrdering,
   'test-case-shorthand-strings': testCaseShorthandStrings,
-};
+} satisfies Record<string, Rule.RuleModule>;
 
-/** @type {import("eslint").ESLint.Plugin} */
 const plugin = {
   meta: {
     name: packageMetadata.name,
     version: packageMetadata.version,
   },
   rules: allRules,
-  configs: {}, // assigned later
-};
-
-// configs
-Object.assign(
-  plugin.configs,
-  Object.keys(configFilters).reduce((configs, configName) => {
-    return Object.assign(configs, {
-      [configName]: {
-        name: `${PLUGIN_NAME}/${configName}`,
-        plugins: { [PLUGIN_NAME]: plugin },
-        rules: Object.fromEntries(
-          Object.keys(allRules)
-            .filter((ruleName) => configFilters[configName](allRules[ruleName]))
-            .map((ruleName) => [`${PLUGIN_NAME}/${ruleName}`, 'error']),
-        ),
-      },
-    });
-  }, {}),
-);
+  configs: {
+    all: createConfig('all'),
+    'all-type-checked': createConfig('all-type-checked'),
+    recommended: createConfig('recommended'),
+    rules: createConfig('rules'),
+    tests: createConfig('tests'),
+    'rules-recommended': createConfig('rules-recommended'),
+    'tests-recommended': createConfig('tests-recommended'),
+  },
+} satisfies ESLint.Plugin;
 
 export default plugin;

lib/rules/consistent-output.js renamed to lib/rules/consistent-output.ts

@@ -2,15 +2,17 @@
  * @fileoverview Enforce consistent use of `output` assertions in rule tests
  * @author Teddy Katz
  */
+import type { Rule } from 'eslint';
 
-import * as utils from '../utils.js';
+import { getKeyName, getTestInfo } from '../utils.js';
+
+const keyNameMapper = (property: Parameters<typeof getKeyName>[0]) =>
+  getKeyName(property);
 
 // ------------------------------------------------------------------------------
 // Rule Definition
 // ------------------------------------------------------------------------------
-
-/** @type {import('eslint').Rule.RuleModule} */
-const rule = {
+const rule: Rule.RuleModule = {
   meta: {
     type: 'suggestion',
     docs: {
@@ -20,7 +22,7 @@ const rule = {
       recommended: false,
       url: 'https://github.com/eslint-community/eslint-plugin-eslint-plugin/tree/HEAD/docs/rules/consistent-output.md',
     },
-    fixable: null, // or "code" or "whitespace"
+    fixable: undefined, // or "code" or "whitespace"
     schema: [
       {
         type: 'string',
@@ -37,20 +39,18 @@ const rule = {
   },
 
   create(context) {
-    // ----------------------------------------------------------------------
-    // Public
-    // ----------------------------------------------------------------------
-    const always = context.options[0] && context.options[0] === 'always';
+    const always: boolean =
+      context.options[0] && context.options[0] === 'always';
 
     return {
       Program(ast) {
-        utils.getTestInfo(context, ast).forEach((testRun) => {
+        getTestInfo(context, ast).forEach((testRun) => {
           const readableCases = testRun.invalid.filter(
-            (testCase) => testCase.type === 'ObjectExpression',
+            (testCase) => testCase?.type === 'ObjectExpression',
           );
           const casesWithoutOutput = readableCases.filter(
             (testCase) =>
-              !testCase.properties.map(utils.getKeyName).includes('output'),
+              !testCase.properties.map(keyNameMapper).includes('output'),
           );
 
           if (