feat: add sortBy: "value" related-options

[hugop95]

Should resolve #68

Description

This PR adds 3 sort by value related-options to sort-object-types and sort-interfaces:

• customGroups.elementValuePattern to match property patterns.
• sortBy: 'name' | 'value' (by default name).
• customGroups.sortBy: 'name' | 'value' to override the sortBy option in a given custom group.

Example

Sort properties by:

• ObjectId.
• Date.
• Primitive types.
• All the rest, sorted by name alphabetically.

Users have two ways to write this: use sortBy: 'value' by default, and for the last group, use sortBy: 'name', or the opposite.

Details

{
"perfectionist/sort-object-types": [
    "error",
    {
      "groups": [
        "objectIds",
        "dates",
        "primitives"
      ],
      "customGroups": [
        {
          "groupName": "objectIds",
          "elementValuePattern": "^ObjectId$",
        },
        {
          "groupName": "dates",
          "elementValuePattern": "^Date$",
        },
        {
          "groupName": "primitives",
          "elementValuePattern": "string|number|boolean",
          "sortBy": "value"
        }
      ]
    }
  ]
}	

Or

"perfectionist/sort-object-types": [
    "error",
    {
      "sortBy": "value",
      "groups": [
        "objectIds",
        "dates",
        "primitives",
        "allTheRestSortedNormally"
      ],
      "customGroups": [
        {
          "groupName": "objectIds",
          "elementValuePattern": "^ObjectId$"
        },
        {
          "groupName": "dates",
          "elementValuePattern": "^Date$"
        },
        {
          "groupName": "primitives",
          "elementValuePattern": "string|number|boolean"
        },
        {
          "groupName": "allTheRestSortedNormally",
          "sortBy": "name"
        }
      ]
    }
  ],

Result:

type Type = {
  _id: ObjectId;
  groupId: ObjectId;
  createdAt: Date;
  lastLoginAt: Date;
  b: boolean;
  c: number;
  a: string;
  // We are sorted alphabetically!
  anotherObject: AnotherObject;
  someValue: AnObject;
};

Important notes

❓Can users sort by value alphabetically, then by name alphabetically if the values are the same ?

Currently, no. This means that

{
  "perfectionist/sort-object-types": [
    "error",
    {
      "sortBy": "value",
    }
  ],
}

will tolerate both

type Types = {
  a: string
  b: string
}

and

type Types = {
  b: string
  a: string
}

We would need to allow users to write

"perfectionist/sort-object-types": [
    "error",
    {
      "sortBy": "value",
	  "fallbackSort": { "sortBy": "name"}
    }
  ],

This can come in a later PR.

❓How does sortBy: 'value' work with non-properties ?

It depends if it's the base sortBy option, or the customGroups one.

Base sortBy option

Non-properties nodes will not have a sort order enforced.

type Types = {
  z(): void
  a: string
}

and

type Types = {
  b: string
  z(): void
}

are both allowed.

customGroups.sortBy option

Grouping is still enabled, but within the group, the sort order is not enforced. This essentially means that we are enforcing the non-property member (such as functions) matching the group to be in that group, but the user can choose to move that member inside that group wherever they want.

Commit split

• Commits 1-5 are refactors.
• Commit 6+ are the actual implementation.

What is the purpose of this pull request?

• New Feature

[azat-io]

LGTM.

In the beginning, I thought about using Typescript to solve this problem.

To have TypeScript ESLint detect the type of the value and sort them according to the type. For example, if it is a JSX props object. And the types are specified somewhere else.

interface Props {
  isOpen: boolean
  isCompact: boolean
  otherProp: string
  value: string
  onChange: () => {}
}

// Example:
// If booleans should be last in object

export let Component: FC<Props> = ({
  onChange,
  otherProp
  value,
  isCompact,
  isOpen,
}) => {}

P.S. At least I want to try to do it in another plugin:
azat-io/eslint-plugin-de-morgan#3

[hugop95]

@azat-io I think that we would need to dive deeper into how typescript-eslint infers/detects typings.

I haven't had the time to l look into that, so I don't know if it's going to end up being hard to implement or not. The benefits can be quite big for a lot of rules from perfectionist, and for your new de-morgan plugin as well. It's something I can start looking into as well once the whole sortBy: value milestone is done. 🙂

[azat-io]

The benefits can be quite big, but I'm afraid it could affect the performance.

[hugop95]

@azat-io

The benefits can be quite big, but I'm afraid it could affect the performance.

It's always something we can put behind an option, similarly to sort-imports and tsconfig parsing!

[azat-io]

Yes 👍