refactor: drop the enum/string hack for configs, use a class instead

Author: haoqunjiang

src/configs.ts

@@ -1,57 +1,56 @@
 import tseslint from 'typescript-eslint'
-
 import type { FlatConfig } from '@typescript-eslint/utils/ts-eslint'
 
-const PlaceholderPrefix =
-  'PLACEHOLDER_THAT_MUST_BE_WRAPPED_INSIDE_defineConfigWithVueTs_'
-
-// Manually declare all the available configs as enums to make the auto-completion more user-friendly.
-// It's also a good way to avoid the placeholder strings to appear in the auto-completion.
-export enum VueTsPreset {
-  all = `${PlaceholderPrefix}all`,
-  base = `${PlaceholderPrefix}base`,
-  disableTypeChecked = `${PlaceholderPrefix}disableTypeChecked`,
-  eslintRecommended = `${PlaceholderPrefix}eslintRecommended`,
-  recommended = `${PlaceholderPrefix}recommended`,
-  recommendedTypeChecked = `${PlaceholderPrefix}recommendedTypeChecked`,
-  recommendedTypeCheckedOnly = `${PlaceholderPrefix}recommendedTypeCheckedOnly`,
-  strict = `${PlaceholderPrefix}strict`,
-  strictTypeChecked = `${PlaceholderPrefix}strictTypeChecked`,
-  strictTypeCheckedOnly = `${PlaceholderPrefix}strictTypeCheckedOnly`,
-  stylistic = `${PlaceholderPrefix}stylistic`,
-  stylisticTypeChecked = `${PlaceholderPrefix}stylisticTypeChecked`,
-  stylisticTypeCheckedOnly = `${PlaceholderPrefix}stylisticTypeCheckedOnly`,
-}
-
-// `enum`s are just objects with reverse mapping during runtime.
-// We redefine the type here only to make the auto-completion more user-friendly.
-export type ExtendableConfigName = keyof typeof VueTsPreset
-export const vueTsConfigs = VueTsPreset as {
-  [key in ExtendableConfigName]: VueTsPreset
-}
+const CONFIG_NAMES = [
+  'all',
+  'base',
+  'disableTypeChecked',
+  'eslintRecommended',
+  'recommended',
+  'recommendedTypeChecked',
+  'recommendedTypeCheckedOnly',
+  'strict',
+  'strictTypeChecked',
+  'strictTypeCheckedOnly',
+  'stylistic',
+  'stylisticTypeChecked',
+  'stylisticTypeCheckedOnly',
+] as const
+export type ExtendableConfigName = (typeof CONFIG_NAMES)[number]
 
 function toArray<T>(value: T | T[]): T[] {
   return Array.isArray(value) ? value : [value]
 }
 
-export function getConfigForPlaceholder(
-  placeholder: VueTsPreset,
-): FlatConfig.ConfigArray {
-  return toArray(
-    tseslint.configs[
-      placeholder.replace(
-        new RegExp(`^${PlaceholderPrefix}`),
-        '',
-      ) as ExtendableConfigName
-    ],
-  )
-    .flat()
-    .map(config =>
-      config.files && config.files.includes('**/*.ts')
-        ? {
-            ...config,
-            files: [...config.files, '**/*.vue'],
-          }
-        : config,
-    )
+export class TsEslintConfigForVue {
+  constructor(readonly configName: ExtendableConfigName) {
+    this.configName = configName
+  }
+
+  needsTypeChecking(): boolean {
+    if (this.configName === 'disableTypeChecked') {
+      return false
+    }
+    if (this.configName === 'all') {
+      return true
+    }
+    return this.configName.includes('TypeChecked')
+  }
+
+  toConfigArray(): FlatConfig.ConfigArray {
+    return toArray(tseslint.configs[this.configName])
+      .flat()
+      .map(config =>
+        config.files && config.files.includes('**/*.ts')
+          ? {
+              ...config,
+              files: [...config.files, '**/*.vue'],
+            }
+          : config,
+      )
+  }
 }
+
+export const vueTsConfigs = Object.fromEntries(
+  CONFIG_NAMES.map(name => [name, new TsEslintConfigForVue(name)]),
+) as Record<ExtendableConfigName, TsEslintConfigForVue>

src/utilities.ts

@@ -1,7 +1,6 @@
+import process from 'node:process'
 import * as tseslint from 'typescript-eslint'
-
-import type { VueTsPreset } from './configs'
-import { getConfigForPlaceholder } from './configs'
+import { TsEslintConfigForVue } from './configs'
 import groupVueFiles from './groupVueFiles'
 import {
   additionalRulesRequiringParserServices,
@@ -10,17 +9,16 @@ import {
   createTypeCheckingConfigs,
 } from './internals'
 
+import type { ScriptLang } from './internals'
+
 type ConfigArray = ReturnType<typeof tseslint.config>
 type Rules = NonNullable<ConfigArray[number]['rules']>
 
-type ConfigOrVueTsPreset = ConfigArray[number] | VueTsPreset
+type ConfigObjectOrPlaceholder = ConfigArray[number] | TsEslintConfigForVue
 type InfiniteDepthConfigWithVueSupport =
-  | ConfigOrVueTsPreset
+  | ConfigObjectOrPlaceholder
   | InfiniteDepthConfigWithVueSupport[]
 
-import process from 'node:process'
-import type { ScriptLang } from './internals'
-
 export type ProjectOptions = {
   scriptLangs?: ScriptLang[]
   rootDir?: string
@@ -48,11 +46,14 @@ export function configureVueProject(userOptions: ProjectOptions) {
 export function defineConfigWithVueTs(
   ...configs: InfiniteDepthConfigWithVueSupport[]
 ): ConfigArray {
-  // @ts-ignore
-  const flattenedConfigs: Array<ConfigOrVueTsPreset> = configs.flat(Infinity)
-  const normalizedConfigs = insertAndReorderConfigs(flattenedConfigs).map(
-    config =>
-      typeof config === 'string' ? getConfigForPlaceholder(config) : config,
+  const flattenedConfigs: Array<ConfigObjectOrPlaceholder> =
+    // @ts-ignore
+    configs.flat(Infinity)
+
+  const reorderedConfigs = insertAndReorderConfigs(flattenedConfigs)
+
+  const normalizedConfigs = reorderedConfigs.map(config =>
+    config instanceof TsEslintConfigForVue ? config.toConfigArray() : config,
   )
 
   return tseslint.config(...normalizedConfigs)
@@ -86,10 +87,10 @@ type ExtractedConfig = {
 const userTypeAwareConfigs: ExtractedConfig[] = []
 
 function insertAndReorderConfigs(
-  configs: Array<ConfigOrVueTsPreset>,
-): Array<ConfigOrVueTsPreset> {
+  configs: Array<ConfigObjectOrPlaceholder>,
+): Array<ConfigObjectOrPlaceholder> {
   const lastExtendedConfigIndex = configs.findLastIndex(
-    config => typeof config === 'string',
+    config => config instanceof TsEslintConfigForVue,
   )
 
   if (lastExtendedConfigIndex === -1) {
@@ -99,13 +100,12 @@ function insertAndReorderConfigs(
   const vueFiles = groupVueFiles(projectOptions.rootDir!)
   const configsWithoutTypeAwareRules = configs.map(extractTypeAwareRules)
 
-  const hasTypeAwarePresets = configs.some(
+  const hasTypeAwareConfigs = configs.some(
     config =>
-      typeof config === 'string' &&
-      !config.endsWith('disableTypeChecked') &&
-      (config.includes('TypeChecked') || config.endsWith('all')),
+      config instanceof TsEslintConfigForVue && config.needsTypeChecking(),
   )
-  const needsTypeAwareLinting = hasTypeAwarePresets || userTypeAwareConfigs.length > 0
+  const needsTypeAwareLinting =
+    hasTypeAwareConfigs || userTypeAwareConfigs.length > 0
 
   return [
     ...configsWithoutTypeAwareRules.slice(0, lastExtendedConfigIndex + 1),
@@ -130,9 +130,9 @@ function insertAndReorderConfigs(
 }
 
 function extractTypeAwareRules(
-  config: ConfigOrVueTsPreset,
-): ConfigOrVueTsPreset {
-  if (typeof config === 'string') {
+  config: ConfigObjectOrPlaceholder,
+): ConfigObjectOrPlaceholder {
+  if (config instanceof TsEslintConfigForVue) {
     return config
   }
 
@@ -148,7 +148,7 @@ function extractTypeAwareRules(
   if (typeAwareRuleEntries.length > 0) {
     userTypeAwareConfigs.push({
       rules: Object.fromEntries(typeAwareRuleEntries),
-        ...(config.files && { files: config.files }),
+      ...(config.files && { files: config.files }),
     })
   }