feat: migrate package to TypeScript and publish types

.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.config.ts

@@ -5,7 +5,6 @@ import { FlatCompat } from '@eslint/eslintrc';
 import { defineConfig } from 'eslint/config';
 import markdown from 'eslint-plugin-markdown';
 import pluginN from 'eslint-plugin-n';
-// @ts-expect-error - eslint-plugin is not typed yet
 import eslintPlugin from './lib/index.js';
 
 const dirname = path.dirname(fileURLToPath(import.meta.url));
@@ -17,7 +16,7 @@ const compat = new FlatCompat({
 export default defineConfig([
   // Global ignores
   {
-    ignores: ['node_modules', 'coverage'],
+    ignores: ['node_modules', 'coverage', 'dist'],
   },
   // Global settings
   {

lib/index.js → 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 → 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 { 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) {
         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(getKeyName).includes('output'),
+              !testCase.properties.map(keyNameMapper).includes('output'),
           );
 
           if (

lib/rules/fixer-return.js → lib/rules/fixer-return.ts

@@ -2,21 +2,37 @@
  * @fileoverview require fixer functions to return a fix
  * @author 薛定谔的猫<[email protected]>
  */
-
 import { getStaticValue } from '@eslint-community/eslint-utils';
+import type { Rule } from 'eslint';
+import type {
+  ArrowFunctionExpression,
+  FunctionExpression,
+  Identifier,
+  Node,
+  Position,
+  SourceLocation,
+} from 'estree';
 
 import {
   getContextIdentifiers,
   isAutoFixerFunction,
   isSuggestionFixerFunction,
 } from '../utils.js';
+import type { FunctionInfo } from '../types.js';
+
+const DEFAULT_FUNC_INFO: FunctionInfo = {
+  upper: null,
+  codePath: null,
+  hasReturnWithFixer: false,
+  hasYieldWithFixer: false,
+  shouldCheck: false,
+  node: null,
+};
 
 // ------------------------------------------------------------------------------
 // Rule Definition
 // ------------------------------------------------------------------------------
-
-/** @type {import('eslint').Rule.RuleModule} */
-const rule = {
+const rule: Rule.RuleModule = {
   meta: {
     type: 'problem',
     docs: {
@@ -25,36 +41,32 @@ const rule = {
       recommended: true,
       url: 'https://github.com/eslint-community/eslint-plugin-eslint-plugin/tree/HEAD/docs/rules/fixer-return.md',
     },
-    fixable: null,
+    fixable: undefined,
     schema: [],
     messages: {
       missingFix: 'Fixer function never returned a fix.',
     },
   },
 
   create(context) {
-    let funcInfo = {
-      upper: null,
-      codePath: null,
-      hasReturnWithFixer: false,
-      hasYieldWithFixer: false,
-      shouldCheck: false,
-      node: null,
-    };
-    let contextIdentifiers;
+    let funcInfo: FunctionInfo = DEFAULT_FUNC_INFO;
+    let contextIdentifiers = new Set<Identifier>();
 
     /**
      * As we exit the fix() function, ensure we have returned or yielded a real fix by this point.
      * If not, report the function as a violation.
      *
-     * @param {ASTNode} node - A node to check.
-     * @param {Location} loc - Optional location to report violation on.
-     * @returns {void}
+     * @param node - A node to check.
+     * @param loc - Optional location to report violation on.
      */
     function ensureFunctionReturnedFix(
-      node,
-      loc = (node.id || node).loc.start,
-    ) {
+      node: ArrowFunctionExpression | FunctionExpression,
+      loc: Position | SourceLocation | undefined = (node.type ===
+        'FunctionExpression' && node.id
+        ? node.id
+        : node
+      ).loc?.start,
+    ): void {
       if (
         (node.generator && !funcInfo.hasYieldWithFixer) || // Generator function never yielded a fix
         (!node.generator && !funcInfo.hasReturnWithFixer) // Non-generator function never returned a fix
@@ -70,10 +82,9 @@ const rule = {
     /**
      * Check if a returned/yielded node is likely to be a fix or not.
      * A fix is an object created by fixer.replaceText() for example and returned by the fix function.
-     * @param {ASTNode} node - node to check
-     * @returns {boolean}
+     * @param node - node to check
      */
-    function isFix(node) {
+    function isFix(node: Node): boolean {
       if (node.type === 'ArrayExpression' && node.elements.length === 0) {
         // An empty array is not a fix.
         return false;
@@ -104,22 +115,22 @@ const rule = {
       },
 
       // Stacks this function's information.
-      onCodePathStart(codePath, node) {
+      onCodePathStart(codePath: Rule.CodePath, node: Node) {
         funcInfo = {
           upper: funcInfo,
           codePath,
           hasYieldWithFixer: false,
           hasReturnWithFixer: false,
           shouldCheck:
-            isAutoFixerFunction(node, contextIdentifiers) ||
-            isSuggestionFixerFunction(node, contextIdentifiers),
+            isAutoFixerFunction(node, contextIdentifiers, context) ||
+            isSuggestionFixerFunction(node, contextIdentifiers, context),
           node,
         };
       },
 
       // Pops this function's information.
       onCodePathEnd() {
-        funcInfo = funcInfo.upper;
+        funcInfo = funcInfo.upper ?? DEFAULT_FUNC_INFO;
       },
 
       // Yield in generators
@@ -147,7 +158,7 @@ const rule = {
       'ArrowFunctionExpression:exit'(node) {
         if (funcInfo.shouldCheck) {
           const sourceCode = context.sourceCode;
-          const loc = sourceCode.getTokenBefore(node.body).loc; // Show violation on arrow (=>).
+          const loc = sourceCode.getTokenBefore(node.body)?.loc; // Show violation on arrow (=>).
           if (node.expression) {
             // When the return is implied (no curly braces around the body), we have to check the single body node directly.
             if (!isFix(node.body)) {