eslint-rule-benchmark/dist/core/eslint/create-eslint-instance.js

Benchmark ESLint rules with detailed performance metrics for CI and plugin development

import { loadESLint } from 'eslint'
import { createJiti } from 'jiti'
import { loadLanguageParser } from './load-language-parser.js'
import { loadRuleFromFile } from './load-rule-from-file.js'
import { SUPPORTED_EXTENSIONS } from '../../constants/index.js'
import { toSeverity } from './to-severity.js'
let jiti = createJiti(import.meta.url, {
  interopDefault: true,
  requireCache: false,
})
async function createESLintInstance(instanceOptions) {
  let { eslintConfigFile, configDirectory, languages, rule } = instanceOptions
  let { path: rulePath, severity, options, ruleId } = rule
  let ruleModule
  if (rulePath) {
    let loadResult = await loadRuleFromFile(jiti, {
      configDirectory,
      rulePath,
      ruleId,
    })
    if (loadResult.error) {
      throw new Error(`Failed to load rule: ${loadResult.error}`)
    }
    ruleModule = loadResult.rule
  }
  if (rulePath && !ruleModule) {
    throw new Error(`Rule module not found: ${ruleId}`)
  }
  let uniqueNamespace = 'eslint-rule-benchmark'
  let localName = ruleId.includes('/') ? ruleId.split('/')[1] : ruleId
  let severityString = toSeverity(severity)
  let ruleEntry = options ? [severityString, ...options] : severityString
  let uniqueRuleId = `${uniqueNamespace}/${localName}`
  let plugins = ruleModule
    ? {
        [uniqueNamespace]: {
          rules: {
            [localName]: ruleModule,
          },
        },
      }
    : void 0
  let additionalOptions = {}
  let parserResults = await Promise.all(
    languages.map(language => loadLanguageParser(jiti, language)),
  )
  let loadedParsers = parserResults
    .filter(result => !result.error && result.parser)
    .map(result => result.parser)
  if (loadedParsers.length > 0) {
    let [parser] = loadedParsers
    additionalOptions.languageOptions = {
      parser,
    }
  }
  if (
    languages.includes('javascript-react') ||
    languages.includes('typescript-react')
  ) {
    if (additionalOptions.languageOptions) {
      additionalOptions.languageOptions.parserOptions = {
        ...additionalOptions.languageOptions.parserOptions,
        ecmaFeatures: {
          jsx: true,
        },
      }
    } else {
      additionalOptions.languageOptions = {
        parserOptions: {
          ecmaFeatures: {
            jsx: true,
          },
        },
      }
    }
  }
  let flatConfig = {
    files: SUPPORTED_EXTENSIONS.map(extension => `**/*.${extension}`),
    rules: {
      [uniqueRuleId]: ruleEntry,
    },
    plugins,
    ...additionalOptions,
  }
  let FlatESLint = await loadESLint({
    useFlatConfig: true,
  })
  return new FlatESLint({
    ruleFilter: ({ ruleId: currentRuleId }) => currentRuleId === uniqueRuleId,
    overrideConfigFile: eslintConfigFile ?? null,
    overrideConfig: [flatConfig],
    allowInlineConfig: false,
    fix: true,
  })
}
export { createESLintInstance }