eslint-plugin-perfectionist/dist/rules/sort-modules/compute-overload-signature-groups.js

ESLint plugin for sorting various data such as objects, imports, types, enums, JSX props, etc.

import { isSortable } from '../../utils/is-sortable.js'
import { OverloadSignatureGroup } from '../../utils/overload-signature/overload-signature-group.js'
import { AST_NODE_TYPES } from '@typescript-eslint/utils'
/**
 * Returns a list of groups of overload signatures.
 *
 * @param nodes - The nodes to process.
 * @returns A list of overload signature groups.
 */
function computeOverloadSignatureGroups(nodes) {
  let functionDetailsByName = /* @__PURE__ */ new Map()
  for (let node of nodes) {
    let functionDetails = computeNodeFunctionDetails(node)
    if (!functionDetails) {
      continue
    }
    let functionDetailsArray = functionDetailsByName.get(functionDetails.name)
    if (!functionDetailsArray) {
      functionDetailsArray = []
      functionDetailsByName.set(functionDetails.name, functionDetailsArray)
    }
    functionDetailsArray.push({
      ...functionDetails,
      node,
    })
  }
  return [...functionDetailsByName.values()]
    .filter(isSortable)
    .map(buildOverloadSignatureGroup)
}
function computeNodeFunctionDetails(node) {
  switch (node.type) {
    case AST_NODE_TYPES.ExportDefaultDeclaration:
      return computeNodeFunctionDetails(node.declaration)
    case AST_NODE_TYPES.ExportNamedDeclaration:
      /* v8 ignore start -- @preserve Unsure how we can reach that case */
      if (!node.declaration) {
        return null
      }
      /* v8 ignore stop -- @preserve Unsure how we can reach that case */
      return computeNodeFunctionDetails(node.declaration)
    case AST_NODE_TYPES.FunctionDeclaration:
    case AST_NODE_TYPES.TSDeclareFunction:
      return computeFunctionDetails(node)
    default:
      return null
  }
  function computeFunctionDetails(functionNode) {
    /* v8 ignore if -- @preserve Unsure how we can reach that case */
    if (!functionNode.id) {
      return null
    }
    return {
      isImplementation:
        functionNode.type === AST_NODE_TYPES.FunctionDeclaration,
      name: functionNode.id.name,
    }
  }
}
function buildOverloadSignatureGroup(functionDetailsArray) {
  let implementation = (
    functionDetailsArray.find(isFunctionImplementation) ??
    functionDetailsArray.at(-1)
  ).node
  return new OverloadSignatureGroup({
    overloadSignatures: functionDetailsArray
      .filter(functionDetails => !isFunctionImplementation(functionDetails))
      .map(functionDetails => functionDetails.node),
    implementation,
  })
  function isFunctionImplementation(functionDetails) {
    return functionDetails.isImplementation
  }
}
export { computeOverloadSignatureGroups }