refactor(sort-imports): extract and test internal functions

Author: hugop95

rules/sort-imports.ts

@@ -0,0 +1,137 @@
+import { builtinModules } from 'node:module'
+
+import type { ReadClosestTsConfigByPathValue } from './read-closest-ts-config-by-path'
+import type { RegexOption } from '../../types/common-options'
+
+import { getTypescriptImport } from './get-typescript-import'
+import { matches } from '../../utils/matches'
+
+export let computeCommonPredefinedGroups = ({
+  tsConfigOutput,
+  filename,
+  options,
+  name,
+}: {
+  options: {
+    internalPattern: RegexOption[]
+    environment: 'node' | 'bun'
+  }
+  tsConfigOutput: ReadClosestTsConfigByPathValue | null
+  filename: string
+  name: string
+}): string[] => {
+  let matchesInternalPattern = (value: string): boolean | number =>
+    options.internalPattern.some(pattern => matches(value, pattern))
+
+  let internalExternalGroup = matchesInternalPattern(name)
+    ? 'internal'
+    : getInternalOrExternalGroup({
+        tsConfigOutput,
+        filename,
+        name,
+      })
+
+  let predefinedGroups: string[] = []
+
+  if (isIndex(name)) {
+    predefinedGroups.push('index')
+  }
+
+  if (isSibling(name)) {
+    predefinedGroups.push('sibling')
+  }
+
+  if (isParent(name)) {
+    predefinedGroups.push('parent')
+  }
+
+  if (internalExternalGroup === 'internal') {
+    predefinedGroups.push('internal')
+  }
+
+  if (isCoreModule(name, options.environment)) {
+    predefinedGroups.push('builtin')
+  }
+
+  if (internalExternalGroup === 'external') {
+    predefinedGroups.push('external')
+  }
+
+  return predefinedGroups
+}
+
+let bunModules = new Set([
+  'detect-libc',
+  'bun:sqlite',
+  'bun:test',
+  'bun:wrap',
+  'bun:ffi',
+  'bun:jsc',
+  'undici',
+  'bun',
+  'ws',
+])
+let nodeBuiltinModules = new Set(builtinModules)
+let builtinPrefixOnlyModules = new Set(['node:sqlite', 'node:test', 'node:sea'])
+let isCoreModule = (value: string, environment: 'node' | 'bun'): boolean => {
+  let valueToCheck = value.startsWith('node:') ? value.split('node:')[1] : value
+  return (
+    (!!valueToCheck && nodeBuiltinModules.has(valueToCheck)) ||
+    builtinPrefixOnlyModules.has(value) ||
+    (environment === 'bun' ? bunModules.has(value) : false)
+  )
+}
+
+let isParent = (value: string): boolean => value.startsWith('..')
+
+let isSibling = (value: string): boolean => value.startsWith('./')
+
+let isIndex = (value: string): boolean =>
+  [
+    './index.d.js',
+    './index.d.ts',
+    './index.js',
+    './index.ts',
+    './index',
+    './',
+    '.',
+  ].includes(value)
+
+let getInternalOrExternalGroup = ({
+  tsConfigOutput,
+  filename,
+  name,
+}: {
+  tsConfigOutput: ReadClosestTsConfigByPathValue | null
+  filename: string
+  name: string
+}): 'internal' | 'external' | null => {
+  let typescriptImport = getTypescriptImport()
+  if (!typescriptImport) {
+    return !name.startsWith('.') && !name.startsWith('/') ? 'external' : null
+  }
+
+  let isRelativeImport = typescriptImport.isExternalModuleNameRelative(name)
+  if (isRelativeImport) {
+    return null
+  }
+  if (!tsConfigOutput) {
+    return 'external'
+  }
+
+  let resolution = typescriptImport.resolveModuleName(
+    name,
+    filename,
+    tsConfigOutput.compilerOptions,
+    typescriptImport.sys,
+    tsConfigOutput.cache,
+  )
+  // If the module can't be resolved, assume it is external.
+  if (typeof resolution.resolvedModule?.isExternalLibraryImport !== 'boolean') {
+    return 'external'
+  }
+
+  return resolution.resolvedModule.isExternalLibraryImport
+    ? 'external'
+    : 'internal'
+}

rules/sort-imports/compute-common-predefined-groups.ts

@@ -0,0 +1,16 @@
+import type { GroupsOptions } from '../../types/common-options'
+
+import { isNewlinesBetweenOption } from '../../utils/is-newlines-between-option'
+
+export let isSideEffectOnlyGroup = (
+  group: GroupsOptions<string>[0],
+): boolean => {
+  if (isNewlinesBetweenOption(group)) {
+    return false
+  }
+  if (typeof group === 'string') {
+    return group === 'side-effect' || group === 'side-effect-style'
+  }
+
+  return group.every(isSideEffectOnlyGroup)
+}

rules/sort-imports/is-side-effect-only-group.ts

@@ -10,7 +10,7 @@ import { getTypescriptImport } from './get-typescript-import'
  * https://github.com/typescript-eslint/typescript-eslint/blob/main/packages/typescript-estree/src/parseSettings/getProjectConfigFiles.ts
  */
 
-interface ReadClosestTsConfigByPathValue {
+export interface ReadClosestTsConfigByPathValue {
   compilerOptions: ts.CompilerOptions
   cache: ts.ModuleResolutionCache
 }

rules/sort-imports/read-closest-ts-config-by-path.ts

@@ -0,0 +1,62 @@
+import type {
+  DeprecatedCustomGroupsOption,
+  PartitionByCommentOption,
+  SpecialCharactersOption,
+  NewlinesBetweenOption,
+  FallbackSortOption,
+  GroupsOptions,
+  OrderOption,
+  RegexOption,
+  TypeOption,
+} from '../../types/common-options'
+import type { SortingNode } from '../../types/sorting-node'
+
+export type Options = [
+  Partial<{
+    customGroups: {
+      value?: DeprecatedCustomGroupsOption
+      type?: DeprecatedCustomGroupsOption
+    }
+    partitionByComment: PartitionByCommentOption
+    specialCharacters: SpecialCharactersOption
+    locales: NonNullable<Intl.LocalesArgument>
+    newlinesBetween: NewlinesBetweenOption
+    fallbackSort: FallbackSortOption
+    internalPattern: RegexOption[]
+    groups: GroupsOptions<Group>
+    environment: 'node' | 'bun'
+    partitionByNewLine: boolean
+    sortSideEffects: boolean
+    tsconfigRootDir?: string
+    maxLineLength?: number
+    ignoreCase: boolean
+    order: OrderOption
+    type: TypeOption
+    alphabet: string
+  }>,
+]
+
+export type Group =
+  | 'side-effect-style'
+  | 'external-type'
+  | 'internal-type'
+  | 'builtin-type'
+  | 'sibling-type'
+  | 'parent-type'
+  | 'side-effect'
+  | 'index-type'
+  | 'internal'
+  | 'external'
+  | 'sibling'
+  | 'unknown'
+  | 'builtin'
+  | 'parent'
+  | 'object'
+  | 'index'
+  | 'style'
+  | 'type'
+  | string
+
+export interface SortImportsSortingNode extends SortingNode {
+  isIgnored: boolean
+}

rules/sort-imports/types.ts

@@ -0,0 +1,35 @@
+import type { GroupsOptions } from '../../types/common-options'
+import type { Group } from './types'
+
+import { isSideEffectOnlyGroup } from './is-side-effect-only-group'
+
+export let validateSideEffectsConfiguration = ({
+  sortSideEffects,
+  groups,
+}: {
+  groups: GroupsOptions<Group>
+  sortSideEffects: boolean
+}): void => {
+  if (sortSideEffects) {
+    return
+  }
+  /**
+   * Ensure that if `sortSideEffects: false`, no side effect group is in a
+   * nested group with non-side-effect groups.
+   */
+  let hasInvalidGroup = groups
+    .filter(group => Array.isArray(group))
+    .some(
+      nestedGroup =>
+        !isSideEffectOnlyGroup(nestedGroup) &&
+        nestedGroup.some(
+          subGroup =>
+            subGroup === 'side-effect' || subGroup === 'side-effect-style',
+        ),
+    )
+  if (hasInvalidGroup) {
+    throw new Error(
+      "Side effect groups cannot be nested with non side effect groups when 'sortSideEffects' is 'false'.",
+    )
+  }
+}

rules/sort-imports/validate-side-effects-configuration.ts

@@ -11,7 +11,8 @@ import { createModuleResolutionCache } from 'typescript'
 import { RuleTester as EslintRuleTester } from 'eslint'
 import dedent from 'dedent'
 
-import type { MESSAGE_ID, Options } from '../../rules/sort-imports'
+import type { Options } from '../../rules/sort-imports/types'
+import type { MESSAGE_ID } from '../../rules/sort-imports'
 
 import * as readClosestTsConfigUtilities from '../../rules/sort-imports/read-closest-ts-config-by-path'
 import * as getTypescriptImportUtilities from '../../rules/sort-imports/get-typescript-import'