Perfectionist
Rules sort-classes

sort-classes

Enforce sorted class members.

Organizing class members in a consistent order improves both readability and maintainability.

This rule helps developers quickly locate class members and understand the overall structure of the class.

By sorting class members systematically, confusion is minimized, and the code becomes more intuitive to navigate. This practice not only aids in individual productivity but also enhances team collaboration by establishing clear and predictable coding standards.

Try it out

Options

This rule accepts an options object with the following properties:

type

default: 'alphabetical'

Specifies the sorting method.

  • 'alphabetical' — Sort items alphabetically (e.g., “a” < “b” < “c”).
  • 'natural' — Sort items in a natural order (e.g., “item2” < “item10”).
  • 'line-length' — Sort items by the length of the code line (shorter lines first).

order

default: 'asc'

Determines whether the sorted items should be in ascending or descending order.

  • 'asc' — Sort items in ascending order (A to Z, 1 to 9).
  • 'desc' — Sort items in descending order (Z to A, 9 to 1).

ignoreCase

default: true

Controls whether sorting should be case-sensitive or not.

  • true — Ignore case when sorting alphabetically or naturally (e.g., “A” and “a” are the same).
  • false — Consider case when sorting (e.g., “A” comes before “a”).

partitionByComment

default: false

Allows you to use comments to separate the class members into logical groups. This can help in organizing and maintaining large enums by creating partitions within the enum based on comments.

  • true — All comments will be treated as delimiters, creating partitions.
  • false — Comments will not be used as delimiters.
  • string — A glob pattern to specify which comments should act as delimiters.

groups

default:

[
  'index-signature',
  'static-property',
  'static-block',
  ['protected-property', 'protected-accessor-property'],
  ['private-property', 'private-accessor-property'],
  ['property', 'accessor-property'],
  'constructor',
  'static-method',
  'protected-method',
  'private-method',
  'method',
  ['get-method', 'set-method'],
  'unknown',
]

Allows you to specify a list of class member groups for sorting. Groups help organize class members into categories, prioritizing them during sorting. Multiple groups can be combined to achieve the desired sorting order.

Predefined groups are characterized by a single selector and potentially multiple modifiers. You may enter modifiers in any order, but the selector must always come at the end.

Constructors

  • Selector: constructor.
  • Modifiers: protected, private, public.
  • Example: protected-constructor, private-constructor, public-constructor or constructor.

Methods

  • Selectors: get-method, set-method, method.
  • Modifiers: static, abstract, decorated, override, protected, private, public, optional.
  • Example: private-static-accessor-property, protected-abstract-override-method or static-get-method.

The optional modifier is incompatible with the get-method and set-method selectors.

The abstract modifier is incompatible with the static, private and decorated modifiers.

constructor, get-method and set-method elements will also be matched as method.

Accessors

  • Selector: accessor-property.
  • Modifiers: static, abstract, decorated, override, protected, private, public.
  • Example: private-static-accessor-property, protected-abstract-override-method or static-get-method.

The abstract modifier is incompatible with the static, private and decorated modifiers.

Properties

  • Selectors: function-property, property.
  • Modifiers: static, declare, abstract, decorated, override, readonly, protected, private, public, optional.
  • Example: readonly-decorated-property.

The abstract modifier is incompatible with the static, private and decorated modifiers.

The declare modifier is incompatible with the override and decorated modifiers.

The function-property selector will match properties whose values are defined functions or arrow-functions. As such, the declare and abstract modifiers are incompatible with this selector.

Index-signatures

  • Selector: index-signature.
  • Modifiers: static, readonly.
  • Example: static-readonly-index-signature.

Static-blocks

  • Selector: static-block.
  • Modifiers: No modifier available.
  • Example: static-block.

Important notes

Scope of the private modifier

The private modifier will currently match any of the following:

  • Elements with the private keyword.
  • Elements with their name starting with #.
Scope of the public modifier

Elements that are not protected nor private will be matched with the public modifier, even if the keyword is not present.

The unknown group

Members that don’t fit into any group entered by the user will be placed in the unknown group. If the unknown group is not specified in groups, the members will remain in their original order.

Behavior when multiple groups match an element

The lists of selectors and modifiers above are both sorted by importance, from most to least important. In case of multiple groups matching an element, the following rules will be applied:

  1. Selector priority: constructor, get-method and set-method groups will always take precedence over method groups.
  2. If the selector is the same, the group with the most modifiers matching will be selected.
  3. If modifiers quantity is the same, order will be chosen based on modifier importance as listed above.

Example 1:

abstract class Class {

    protected abstract get field();

}

field can be matched by the following groups, from most to least important:

  • abstract-protected-get-method or protected-abstract-get-method.
  • abstract-get-method.
  • protected-get-method.
  • get-method.
  • abstract-protected-method or protected-abstract-method.
  • abstract-method.
  • protected-method.
  • method.
  • unknown.

Example 2: (The most important group is written in the comments)

abstract class Example extends BaseExample {

  // 'index-signature'
  [key: string]: any;

  // 'public-static-property'
  static instance: Example;

  // 'declare-protected-static-readonly-property'
  declare protected static readonly value: string;

  // 'static-block'
  static {
    console.log("I am a static block");
  }

  // 'protected-abstract-override-readonly-decorated-property'
  @SomeDecorator
  protected abstract override readonly _value: number;

  // 'protected-decorated-accessor-property'
  @SomeDecorator
  protected accessor _value: number;

  // 'protected-property'
  protected name: string;

  // 'private-decorated-property'
  @SomeDecorator
  private _value: number;

  // 'private-decorated-accessor-property'
  @SomeDecorator
  private accessor _value: number;

  // private-function-property
  private arrowProperty = () => {};

  // private-function-property
  private functionProperty = function() {};

  // 'private-property'
  private name: string;

  // 'public-property'
  public description: string;

  // 'public-decorated-property'
  @SomeDecorator
  public value: number;

  // 'public-decorated-accessor-property'
  @SomeDecorator
  public accessor value: number;

  // 'public-constructor'
  constructor(value: number) {
    this._value = value;
  }

  // 'public-static-method'
  static getInstance() {
    return this.instance;
  }

  // 'protected-static-method'
  protected static initialize() {
    this.instance = new Example(0);
  }

  // 'private-static-method'
  private static initialize() {
    this.instance = new Example(0);
  }

  // 'protected-method'
  protected calculate() {
    return this._value * 2;
  }

  // 'private-method'
  private calculate() {
    return this._value * 2;
  }

  // 'public-decorated-method'
  @SomeDecorator
  public decoratedMethod() {
    return this._value;
  }

  // 'public-method'
  public display() {
    console.log(this._value);
  }

  // 'public-decorated-get-method'
  @SomeDecorator
  get decoratedValue() {
    return this._value;
  }

  // 'public-decorated-set-method'
  @SomeDecorator
  set decoratedValue(value: number) {
    this._value = value;
  }

  // 'protected-decorated-get-method'
  @SomeDecorator
  protected get value() {
    return this._value;
  }

  // 'private-decorated-get-method'
  @SomeDecorator
  private get value() {
    return this._value;
  }

  // 'public-decorated-get-method'
  @SomeDecorator
  get value() {
    return this._value;
  }

  // 'public-get-method'
  get value() {
    return this._value;
  }

  // 'public-set-method'
  set value(value: number) {
    this._value = value;
  }
}

customGroups

default: []

You can define your own groups to match very specific members.

A custom group definition may follow one of the two following interfaces:

interface CustomGroupDefinition {
  groupName: string
  type?: 'alphabetical' | 'natural' | 'line-length' | 'unsorted'
  order?: 'asc' | 'desc'
  selector?: string
  modifiers?: string[]
  elementNamePattern?: string
  decoratorNamePattern?: string
}

A class member will match a CustomGroupDefinition group if it matches all the filters of the custom group’s definition.

or:

interface CustomGroupBlockDefinition {
  groupName: string
  type?: 'alphabetical' | 'natural' | 'line-length' | 'unsorted'
  order?: 'asc' | 'desc'
  anyOf: Array<{
      selector?: string
      modifiers?: string[]
      elementNamePattern?: string
      decoratorNamePattern?: string
  }>
}

A class member will match a CustomGroupBlockDefinition group if it matches all the filters of at least one of the anyOf items.

Attributes

  • groupName: The group’s name, which needs to be put in the groups option.
  • selector: Filter on the selector of the element.
  • modifiers: Filter on the modifiers of the element. (All the modifiers of the element must be present in that list)
  • elementNamePattern: If entered, will check that the name of the element matches the pattern entered.
  • decoratorNamePattern: If entered, will check that at least one decorator matches the pattern entered.
  • type: Overrides the sort type for that custom group. unsorted will not sort the group.
  • order: Overrides the sort order for that custom group

Match importance

The customGroups list is ordered: The first custom group definition that matches an element will be used.

Custom groups have a higher priority than any predefined group. If you want a predefined group to take precedence over a custom group, you must write a custom group definition that does the same as what the predefined group does (using selector and modifiers filters), and put it first in the list.

Example:

 {
   groups: [
    'static-block',
    'index-signature',
+   'input-properties',
+   'output-properties',
    'constructor',
+   'unsorted-methods-and-other-properties',
    ['get-method', 'set-method'],
    'unknown',
   ],
+  customGroups: [                               
+    [                                           
+      {                                         
+        // `constructor()` members must not match
+        // `unsorted-methods-and-other-properties`
+        // so make them match this first
+         groupName: 'constructor',
+         selector: 'constructor',
+      },
+      {                                         
+         groupName: 'input-properties',
+         selector: 'property',
+         modifiers: ['decorated'],
+         decoratorNamePattern: 'Input',
+      },
+      {                                         
+         groupName: 'output-properties',
+         selector: 'property',
+         modifiers: ['decorated'],
+         decoratorNamePattern: 'Output',
+      },
+      {                                         
+         groupName: 'unsorted-methods-and-other-properties',
+         type: 'unsorted',
+         anyOf: [                               
+           {                                    
+              selector: 'method',
+           },
+           {                                    
+              selector: 'property',
+           },
+         ]                                      
+      },
+    ]                                           
+  ]                                             
 }

Usage

Version

This rule was introduced in v0.11.0.

Resources

Table of Contents