eslint-plugin-perfectionist 5.2.0 → 5.3.0

package/dist/package.json.js

@@ -1,3 +1,3 @@
 const name = 'eslint-plugin-perfectionist'
-const version = '5.2.0'
+const version = '5.3.0'
 export { name, version }

package/dist/rules/sort-array-includes/types.d.ts

@@ -1,11 +1,6 @@
 import { JSONSchema4 } from '@typescript-eslint/utils/json-schema'
-import {
-  CommonOptions,
-  RegexOption,
-  TypeOption,
-} from '../../types/common-options.js'
-import { CommonPartitionOptions } from '../../types/common-partition-options.js'
-import { CommonGroupsOptions } from '../../types/common-groups-options.js'
+import { RegexOption, TypeOption } from '../../types/common-options.js'
+import { AllCommonOptions } from '../../types/all-common-options.js'
 /**
  * Configuration options for the sort-array-includes rule.
  *
@@ -26,13 +21,11 @@ export type Options = Partial<
        */
       allNamesMatchPattern?: RegexOption
     }
-  } & CommonGroupsOptions<
-    SingleCustomGroup,
-    Record<string, never>,
-    TypeOption
-  > &
-    CommonOptions<TypeOption> &
-    CommonPartitionOptions
+  } & AllCommonOptions<
+    TypeOption,
+    AdditionalSortOptions,
+    CustomGroupMatchOptions
+  >
 >[]
 /**
  * Represents the type of array element selector. Used to distinguish between
@@ -50,21 +43,25 @@ export type Selector = (typeof allSelectors)[number]
  *     "selector": "literal"
  *   }
  */
-interface SingleCustomGroup {
+interface CustomGroupMatchOptions {
   /**
    * Specifies the type of array elements to include in this group. Can be
    * 'literal' for literal values or 'spread' for spread elements.
    */
   selector?: Selector
 }
+type AdditionalSortOptions = object
 /**
  * Complete list of available selectors for array elements. Used for validation
  * and JSON schema generation.
  */
 export declare let allSelectors: readonly ['literal', 'spread']
 /**
- * JSON schema definition for validating single custom group configurations.
- * Used by ESLint to validate rule options at configuration time.
+ * Additional custom group match options JSON schema. Used by ESLint to validate
+ * rule options at configuration time.
  */
-export declare let singleCustomGroupJsonSchema: Record<string, JSONSchema4>
+export declare let additionalCustomGroupMatchOptionsJsonSchema: Record<
+  string,
+  JSONSchema4
+>
 export {}

package/dist/rules/sort-array-includes/types.js

@@ -1,6 +1,6 @@
 import { buildCustomGroupSelectorJsonSchema } from '../../utils/json-schemas/common-groups-json-schemas.js'
 let allSelectors = ['literal', 'spread']
-let singleCustomGroupJsonSchema = {
+let additionalCustomGroupMatchOptionsJsonSchema = {
   selector: buildCustomGroupSelectorJsonSchema(allSelectors),
 }
-export { allSelectors, singleCustomGroupJsonSchema }
+export { additionalCustomGroupMatchOptionsJsonSchema, allSelectors }

package/dist/rules/sort-array-includes.js

@@ -1,3 +1,4 @@
+import { AST_NODE_TYPES } from '@typescript-eslint/utils'
 import {
   partitionByNewLineJsonSchema,
   partitionByCommentJsonSchema,
@@ -15,12 +16,12 @@ import {
 import { validateNewlinesAndPartitionConfiguration } from '../utils/validate-newlines-and-partition-configuration.js'
 import { buildDefaultOptionsByGroupIndexComputer } from '../utils/build-default-options-by-group-index-computer.js'
 import { defaultComparatorByOptionsComputer } from '../utils/compare/default-comparator-by-options-computer.js'
-import { buildCommonGroupsJsonSchemas } from '../utils/json-schemas/common-groups-json-schemas.js'
-import { validateCustomSortConfiguration } from '../utils/validate-custom-sort-configuration.js'
 import {
-  singleCustomGroupJsonSchema,
+  additionalCustomGroupMatchOptionsJsonSchema,
   allSelectors,
 } from './sort-array-includes/types.js'
+import { buildCommonGroupsJsonSchemas } from '../utils/json-schemas/common-groups-json-schemas.js'
+import { validateCustomSortConfiguration } from '../utils/validate-custom-sort-configuration.js'
 import { filterOptionsByAllNamesMatch } from '../utils/filter-options-by-all-names-match.js'
 import { validateGroupsConfiguration } from '../utils/validate-groups-configuration.js'
 import { generatePredefinedGroups } from '../utils/generate-predefined-groups.js'
@@ -62,7 +63,8 @@ let jsonSchema = {
     properties: {
       ...buildCommonJsonSchemas(),
       ...buildCommonGroupsJsonSchemas({
-        singleCustomGroupJsonSchema,
+        additionalCustomGroupMatchProperties:
+          additionalCustomGroupMatchOptionsJsonSchema,
       }),
       useConfigurationIf: buildUseConfigurationIfJsonSchema(),
       partitionByComment: partitionByCommentJsonSchema,
@@ -78,13 +80,13 @@ const sortArrayIncludes = createEslintRule({
   create: context => ({
     MemberExpression: node => {
       if (
-        (node.object.type === 'ArrayExpression' ||
-          node.object.type === 'NewExpression') &&
-        node.property.type === 'Identifier' &&
+        (node.object.type === AST_NODE_TYPES.ArrayExpression ||
+          node.object.type === AST_NODE_TYPES.NewExpression) &&
+        node.property.type === AST_NODE_TYPES.Identifier &&
         node.property.name === 'includes'
       ) {
         let elements =
-          node.object.type === 'ArrayExpression'
+          node.object.type === AST_NODE_TYPES.ArrayExpression
             ? node.object.elements
             : node.object.arguments
         sortArray({
@@ -149,7 +151,8 @@ function sortArray({ availableMessageIds, elements, context }) {
         return accumulator
       }
       let name = getNodeName({ sourceCode, element })
-      let selector = element.type === 'SpreadElement' ? 'spread' : 'literal'
+      let selector =
+        element.type === AST_NODE_TYPES.SpreadElement ? 'spread' : 'literal'
       let predefinedGroups = generatePredefinedGroups({
         cache: cachedGroupsByModifiersAndSelectors,
         selectors: [selector],
@@ -214,7 +217,7 @@ function sortArray({ availableMessageIds, elements, context }) {
   })
 }
 function getNodeName({ sourceCode, element }) {
-  return element.type === 'Literal'
+  return element.type === AST_NODE_TYPES.Literal
     ? `${element.value}`
     : sourceCode.getText(element)
 }

package/dist/rules/sort-classes/compute-dependencies.d.ts

@@ -0,0 +1,24 @@
+import { TSESTree } from '@typescript-eslint/types'
+import { RegexOption } from '../../types/common-options.js'
+/**
+ * Computes the dependencies of a class member AST node.
+ *
+ * @param params - Parameters object.
+ * @param params.ignoreCallbackDependenciesPatterns - Patterns to ignore
+ *   callback dependencies.
+ * @param params.isMemberStatic - Indicates if the member is static.
+ * @param params.expression - The AST node expression to analyze.
+ * @param params.className - The name of the class, if available.
+ * @returns The names of the dependencies.
+ */
+export declare function computeDependencies({
+  ignoreCallbackDependenciesPatterns,
+  isMemberStatic,
+  expression,
+  className,
+}: {
+  expression: TSESTree.StaticBlock | TSESTree.Expression
+  ignoreCallbackDependenciesPatterns: RegexOption
+  className: undefined | string
+  isMemberStatic: boolean
+}): string[]

package/dist/rules/sort-classes/compute-dependencies.js

@@ -0,0 +1,147 @@
+import { AST_NODE_TYPES } from '@typescript-eslint/utils'
+import { computeIdentifierNameDetails } from './compute-identifier-name-details.js'
+import { computeDependencyName } from './compute-dependency-name.js'
+import { matches } from '../../utils/matches.js'
+function computeDependencies({
+  ignoreCallbackDependenciesPatterns,
+  isMemberStatic,
+  expression,
+  className,
+}) {
+  let dependencies = []
+  function checkNode(nodeValue) {
+    switch (nodeValue.type) {
+      case AST_NODE_TYPES.ConditionalExpression:
+        traverseNode(nodeValue.test)
+        traverseNode(nodeValue.consequent)
+        traverseNode(nodeValue.alternate)
+        break
+      case AST_NODE_TYPES.MemberExpression:
+        dependencies = [
+          ...dependencies,
+          ...computeMemberExpressionDependencies({
+            memberExpression: nodeValue,
+            isMemberStatic,
+            className,
+          }),
+        ]
+        break
+      case AST_NODE_TYPES.CallExpression:
+        if (!('name' in nodeValue.callee)) {
+          traverseNode(nodeValue.arguments)
+          break
+        }
+        if (
+          matches(nodeValue.callee.name, ignoreCallbackDependenciesPatterns)
+        ) {
+          break
+        }
+        traverseNode(nodeValue.arguments)
+        break
+      case AST_NODE_TYPES.NewExpression:
+        traverseNode(nodeValue.arguments)
+        break
+      case AST_NODE_TYPES.Property:
+        traverseNode(nodeValue.key)
+        traverseNode(nodeValue.value)
+        break
+    }
+    if ('argument' in nodeValue && nodeValue.argument) {
+      traverseNode(nodeValue.argument)
+    }
+    if ('body' in nodeValue && nodeValue.body) {
+      traverseNode(nodeValue.body)
+    }
+    if ('callee' in nodeValue) {
+      traverseNode(nodeValue.callee)
+    }
+    if ('declarations' in nodeValue) {
+      traverseNode(nodeValue.declarations)
+    }
+    if ('elements' in nodeValue) {
+      let elements = nodeValue.elements.filter(
+        currentNode => currentNode !== null,
+      )
+      traverseNode(elements)
+    }
+    if (
+      'expression' in nodeValue &&
+      typeof nodeValue.expression !== 'boolean'
+    ) {
+      traverseNode(nodeValue.expression)
+    }
+    if ('expressions' in nodeValue) {
+      traverseNode(nodeValue.expressions)
+    }
+    if ('init' in nodeValue && nodeValue.init) {
+      traverseNode(nodeValue.init)
+    }
+    if ('left' in nodeValue) {
+      traverseNode(nodeValue.left)
+    }
+    if ('object' in nodeValue) {
+      traverseNode(nodeValue.object)
+    }
+    if ('properties' in nodeValue) {
+      traverseNode(nodeValue.properties)
+    }
+    if ('right' in nodeValue) {
+      traverseNode(nodeValue.right)
+    }
+  }
+  function traverseNode(nodeValue) {
+    if (Array.isArray(nodeValue)) {
+      for (let nodeItem of nodeValue) {
+        traverseNode(nodeItem)
+      }
+    } else {
+      checkNode(nodeValue)
+    }
+  }
+  traverseNode(expression)
+  return dependencies
+}
+function computeMemberExpressionDependencies({
+  memberExpression,
+  isMemberStatic,
+  className,
+}) {
+  switch (memberExpression.object.type) {
+    case AST_NODE_TYPES.ThisExpression:
+      return computeIdentifierOrThisExpressionDependencies()
+    case AST_NODE_TYPES.Identifier:
+      return memberExpression.object.name === className
+        ? computeIdentifierOrThisExpressionDependencies()
+        : []
+    default:
+      return []
+  }
+  function computeIdentifierOrThisExpressionDependencies() {
+    let dependency = computeDependencyFromProperty()
+    if (!dependency) {
+      return []
+    }
+    return [dependency]
+  }
+  function computeDependencyFromProperty() {
+    switch (memberExpression.property.type) {
+      case AST_NODE_TYPES.PrivateIdentifier:
+      case AST_NODE_TYPES.Identifier:
+      case AST_NODE_TYPES.Literal: {
+        let { nameWithoutStartingHash, hasPrivateHash } =
+          computeIdentifierNameDetails(memberExpression.property)
+        return computeDependencyName({
+          isStatic:
+            isMemberStatic ||
+            memberExpression.object.type === AST_NODE_TYPES.Identifier,
+          nodeNameWithoutStartingHash: nameWithoutStartingHash,
+          hasPrivateHash,
+        })
+      }
+      /* v8 ignore next 2 -- @preserve Unhandled cases */
+      default:
+        return null
+    }
+  }
+}
+export { computeDependencies }

package/dist/rules/sort-classes/compute-dependency-name.d.ts

@@ -0,0 +1,9 @@
+export declare function computeDependencyName({
+  nodeNameWithoutStartingHash,
+  hasPrivateHash,
+  isStatic,
+}: {
+  nodeNameWithoutStartingHash: string
+  hasPrivateHash: boolean
+  isStatic: boolean
+}): string

package/dist/rules/sort-classes/compute-dependency-name.js

@@ -0,0 +1,8 @@
+function computeDependencyName({
+  nodeNameWithoutStartingHash,
+  hasPrivateHash,
+  isStatic,
+}) {
+  return `${isStatic ? 'static ' : ''}${hasPrivateHash ? '#' : ''}${nodeNameWithoutStartingHash}`
+}
+export { computeDependencyName }

package/dist/rules/sort-classes/compute-identifier-name-details.d.ts

@@ -0,0 +1,16 @@
+import { TSESTree } from '@typescript-eslint/types'
+export interface NodeNameDetails {
+  nameWithoutStartingHash: string
+  hasPrivateHash: boolean
+  name: string
+}
+/**
+ * Computes the name details of an identifier.
+ *
+ * @param node - The node to compute the name details for.
+ * @returns An object containing the name, whether it has a private hash, and
+ *   the name without the starting hash.
+ */
+export declare function computeIdentifierNameDetails(
+  node: TSESTree.PrivateIdentifier | TSESTree.Identifier | TSESTree.Literal,
+): NodeNameDetails

package/dist/rules/sort-classes/compute-identifier-name-details.js

@@ -0,0 +1,27 @@
+import { AST_NODE_TYPES } from '@typescript-eslint/utils'
+import { UnreachableCaseError } from '../../utils/unreachable-case-error.js'
+function computeIdentifierNameDetails(node) {
+  switch (node.type) {
+    case AST_NODE_TYPES.PrivateIdentifier:
+      return {
+        nameWithoutStartingHash: node.name,
+        name: `#${node.name}`,
+        hasPrivateHash: true,
+      }
+    case AST_NODE_TYPES.Identifier:
+      return buildNonPrivateHashDetails(node.name)
+    case AST_NODE_TYPES.Literal:
+      return buildNonPrivateHashDetails(`${node.value}`)
+    /* v8 ignore next 2 -- @preserve Exhaustive guard. */
+    default:
+      throw new UnreachableCaseError(node)
+  }
+}
+function buildNonPrivateHashDetails(name) {
+  return {
+    nameWithoutStartingHash: name,
+    hasPrivateHash: false,
+    name,
+  }
+}
+export { computeIdentifierNameDetails }

package/dist/rules/sort-classes/get-overload-signature-groups.js

@@ -1,16 +1,17 @@
+import { AST_NODE_TYPES } from '@typescript-eslint/utils'
 import { isSortable } from '../../utils/is-sortable.js'
 function getOverloadSignatureGroups(members) {
   let methods = members
     .filter(
       member =>
-        member.type === 'MethodDefinition' ||
-        member.type === 'TSAbstractMethodDefinition',
+        member.type === AST_NODE_TYPES.MethodDefinition ||
+        member.type === AST_NODE_TYPES.TSAbstractMethodDefinition,
     )
     .filter(member => member.kind === 'method')
   let staticOverloadSignaturesByName = /* @__PURE__ */ new Map()
   let overloadSignaturesByName = /* @__PURE__ */ new Map()
   for (let method of methods) {
-    if (method.key.type !== 'Identifier') {
+    if (method.key.type !== AST_NODE_TYPES.Identifier) {
       continue
     }
     let { name } = method.key

package/dist/rules/sort-classes/node-info/common-modifiers.d.ts

@@ -0,0 +1,39 @@
+import { TSESTree } from '@typescript-eslint/types'
+import { Modifier } from '../types.js'
+type Property =
+  | TSESTree.TSAbstractPropertyDefinition
+  | TSESTree.PropertyDefinition
+type Accessor = TSESTree.TSAbstractAccessorProperty | TSESTree.AccessorProperty
+type Method = TSESTree.TSAbstractMethodDefinition | TSESTree.MethodDefinition
+export declare function computeAbstractModifier(
+  node: Accessor | Property | Method,
+): Modifier[]
+export declare function computeAccessibilityModifier({
+  hasPrivateHash,
+  node,
+}: {
+  node: Accessor | Property | Method
+  hasPrivateHash: boolean
+}): Modifier[]
+export declare function computeAsyncModifier(
+  node:
+    | TSESTree.TSEmptyBodyFunctionExpression
+    | TSESTree.ArrowFunctionExpression
+    | TSESTree.FunctionExpression,
+): Modifier[]
+export declare function computeStaticModifier(
+  node: TSESTree.TSIndexSignature | Accessor | Property | Method,
+): Modifier[]
+export declare function computeReadonlyModifier(
+  node: TSESTree.TSIndexSignature | Property,
+): Modifier[]
+export declare function computeOverrideModifier(
+  node: Accessor | Property | Method,
+): Modifier[]
+export declare function computeOptionalModifier(
+  node: Property | Method,
+): Modifier[]
+export declare function computeDecoratedModifier(
+  isDecorated: boolean,
+): Modifier[]
+export {}

package/dist/rules/sort-classes/node-info/common-modifiers.js

@@ -0,0 +1,62 @@
+import { AST_NODE_TYPES } from '@typescript-eslint/utils'
+import { UnreachableCaseError } from '../../../utils/unreachable-case-error.js'
+function computeAbstractModifier(node) {
+  switch (node.type) {
+    case AST_NODE_TYPES.TSAbstractPropertyDefinition:
+    case AST_NODE_TYPES.TSAbstractMethodDefinition:
+    case AST_NODE_TYPES.TSAbstractAccessorProperty:
+      return ['abstract']
+    case AST_NODE_TYPES.PropertyDefinition:
+    case AST_NODE_TYPES.MethodDefinition:
+    case AST_NODE_TYPES.AccessorProperty:
+      return []
+    /* v8 ignore next 2 -- @preserve Exhaustive guard. */
+    default:
+      throw new UnreachableCaseError(node)
+  }
+}
+function computeAccessibilityModifier({ hasPrivateHash, node }) {
+  if (hasPrivateHash) {
+    return ['private']
+  }
+  switch (node.accessibility) {
+    case 'protected':
+      return ['protected']
+    case 'private':
+      return ['private']
+    case void 0:
+    case 'public':
+      return ['public']
+    /* v8 ignore next 2 -- @preserve Exhaustive guard. */
+    default:
+      throw new UnreachableCaseError(node.accessibility)
+  }
+}
+function computeAsyncModifier(node) {
+  return node.async ? ['async'] : []
+}
+function computeStaticModifier(node) {
+  return node.static ? ['static'] : []
+}
+function computeReadonlyModifier(node) {
+  return node.readonly ? ['readonly'] : []
+}
+function computeOverrideModifier(node) {
+  return node.override ? ['override'] : []
+}
+function computeOptionalModifier(node) {
+  return node.optional ? ['optional'] : []
+}
+function computeDecoratedModifier(isDecorated) {
+  return isDecorated ? ['decorated'] : []
+}
+export {
+  computeAbstractModifier,
+  computeAccessibilityModifier,
+  computeAsyncModifier,
+  computeDecoratedModifier,
+  computeOptionalModifier,
+  computeOverrideModifier,
+  computeReadonlyModifier,
+  computeStaticModifier,
+}

package/dist/rules/sort-classes/node-info/compute-accessor-details.d.ts

@@ -0,0 +1,26 @@
+import { TSESTree } from '@typescript-eslint/types'
+import { TSESLint } from '@typescript-eslint/utils'
+import { Modifier, Selector } from '../types.js'
+/**
+ * Computes details related to an accessor property.
+ *
+ * @param params - Parameters object.
+ * @param params.isDecorated - Whether the accessor is decorated.
+ * @param params.sourceCode - The source code object.
+ * @param params.accessor - The accessor node to compute information for.
+ * @returns An object containing various details about the accessor.
+ */
+export declare function computeAccessorDetails({
+  isDecorated,
+  sourceCode,
+  accessor,
+}: {
+  accessor: TSESTree.TSAbstractAccessorProperty | TSESTree.AccessorProperty
+  sourceCode: TSESLint.SourceCode
+  isDecorated: boolean
+}): {
+  dependencyNames: string[]
+  modifiers: Modifier[]
+  selectors: Selector[]
+  name: string
+}

package/dist/rules/sort-classes/node-info/compute-accessor-details.js

@@ -0,0 +1,43 @@
+import {
+  computeStaticModifier,
+  computeAbstractModifier,
+  computeDecoratedModifier,
+  computeOverrideModifier,
+  computeAccessibilityModifier,
+} from './common-modifiers.js'
+import { computeMethodOrPropertyNameDetails } from './compute-method-or-property-name-details.js'
+import { computeDependencyName } from '../compute-dependency-name.js'
+function computeAccessorDetails({ isDecorated, sourceCode, accessor }) {
+  let { nameWithoutStartingHash, hasPrivateHash, name } =
+    computeMethodOrPropertyNameDetails(accessor, sourceCode)
+  let modifiers = computeModifiers({
+    hasPrivateHash,
+    isDecorated,
+    accessor,
+  })
+  return {
+    dependencyNames: [
+      computeDependencyName({
+        nodeNameWithoutStartingHash: nameWithoutStartingHash,
+        isStatic: modifiers.includes('static'),
+        hasPrivateHash,
+      }),
+    ],
+    selectors: ['accessor-property'],
+    modifiers,
+    name,
+  }
+}
+function computeModifiers({ hasPrivateHash, isDecorated, accessor }) {
+  return [
+    ...computeStaticModifier(accessor),
+    ...computeAbstractModifier(accessor),
+    ...computeDecoratedModifier(isDecorated),
+    ...computeOverrideModifier(accessor),
+    ...computeAccessibilityModifier({
+      hasPrivateHash,
+      node: accessor,
+    }),
+  ]
+}
+export { computeAccessorDetails }

package/dist/rules/sort-classes/node-info/compute-index-signature-details.d.ts

@@ -0,0 +1,23 @@
+import { TSESTree } from '@typescript-eslint/types'
+import { TSESLint } from '@typescript-eslint/utils'
+import { Modifier, Selector } from '../types.js'
+/**
+ * Computes details related to an index-signature.
+ *
+ * @param params - Parameters object.
+ * @param params.indexSignature - The index signature node to compute
+ *   information for.
+ * @param params.sourceCode - The source code object.
+ * @returns An object containing various details about the index-signature.
+ */
+export declare function computeIndexSignatureDetails({
+  indexSignature,
+  sourceCode,
+}: {
+  indexSignature: TSESTree.TSIndexSignature
+  sourceCode: TSESLint.SourceCode
+}): {
+  modifiers: Modifier[]
+  selectors: Selector[]
+  name: string
+}

package/dist/rules/sort-classes/node-info/compute-index-signature-details.js

@@ -0,0 +1,21 @@
+import {
+  computeStaticModifier,
+  computeReadonlyModifier,
+} from './common-modifiers.js'
+function computeIndexSignatureDetails({ indexSignature, sourceCode }) {
+  return {
+    name: sourceCode.text.slice(
+      indexSignature.range.at(0),
+      indexSignature.typeAnnotation?.range.at(0) ?? indexSignature.range.at(1),
+    ),
+    modifiers: computeModifiers(indexSignature),
+    selectors: ['index-signature'],
+  }
+}
+function computeModifiers(indexSignature) {
+  return [
+    ...computeStaticModifier(indexSignature),
+    ...computeReadonlyModifier(indexSignature),
+  ]
+}
+export { computeIndexSignatureDetails }

package/dist/rules/sort-classes/node-info/compute-method-details.d.ts

@@ -0,0 +1,29 @@
+import { TSESTree } from '@typescript-eslint/types'
+import { TSESLint } from '@typescript-eslint/utils'
+import { Modifier, Selector } from '../types.js'
+/**
+ * Computes details related to a method.
+ *
+ * @param params - Parameters object.
+ * @param params.isDecorated - Whether the accessor is decorated.
+ * @param params.method - The method node to compute information for.
+ * @param params.sourceCode - The source code object.
+ * @param params.hasParentDeclare - Whether the parent class is a declare class.
+ * @returns An object containing various details about the method.
+ */
+export declare function computeMethodDetails({
+  hasParentDeclare,
+  isDecorated,
+  sourceCode,
+  method,
+}: {
+  method: TSESTree.TSAbstractMethodDefinition | TSESTree.MethodDefinition
+  sourceCode: TSESLint.SourceCode
+  hasParentDeclare: boolean
+  isDecorated: boolean
+}): {
+  addSafetySemicolonWhenInline: boolean
+  modifiers: Modifier[]
+  selectors: Selector[]
+  name: string
+}