Skip to content

Commit 8fd2c4e

Browse files
hugop95azat-io
hugop95
authored and
azat-io
committedNov 19, 2024
feat: add sort-decorators rule
·
v4.11.0v4.0.0
1 parent 97adf51 commit 8fd2c4e

7 files changed

+3957
-0
lines changed
 

‎docs/content/rules/sort-decorators.mdx

+362
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,362 @@
1+
---
2+
title: sort-decorators
3+
description: Enforce sorting of decorators for improved readability and maintainability. Use this ESLint rule to keep your decorators well-organized
4+
shortDescription: Enforce sorted decorators
5+
keywords:
6+
- eslint
7+
- sort decorators
8+
- eslint rule
9+
- coding standards
10+
- code quality
11+
- javascript linting
12+
- typescript decorators sorting
13+
---
14+
15+
import CodeExample from '../../components/CodeExample.svelte'
16+
import Important from '../../components/Important.astro'
17+
import CodeTabs from '../../components/CodeTabs.svelte'
18+
import { dedent } from 'ts-dedent'
19+
20+
Enforce sorted decorators.
21+
22+
Sorting decorators provides a clear and predictable structure to the codebase. This rule detects instances where decorators are not sorted and raises linting errors, encouraging developers to arrange elements in the desired order.
23+
24+
Consistently sorted decorators enhance the overall clarity and organization of your code.
25+
26+
## Try it out
27+
28+
<CodeExample
29+
alphabetical={dedent`
30+
@ApiDescription('Create a new user')
31+
@Authenticated()
32+
@Controller()
33+
@Post('/users')
34+
class CreateUserController {
35+
36+
@AutoInjected()
37+
@NotNull()
38+
userService: UserService;
39+
40+
@IsBoolean()
41+
@NotNull()
42+
accessor disableController: boolean;
43+
44+
@ApiError({ status: 400, description: 'Bad request' })
45+
@ApiResponse({ status: 200, description: 'User created successfully' })
46+
createUser(
47+
@Body()
48+
@IsNotEmpty()
49+
@ValidateNested()
50+
createUserDto: CreateUserDto
51+
): UserDto {
52+
// ...
53+
}
54+
55+
}
56+
`}
57+
lineLength={dedent`
58+
@ApiDescription('Create a new user')
59+
@Authenticated()
60+
@Post('/users')
61+
@Controller()
62+
class CreateUserController {
63+
64+
@AutoInjected()
65+
@NotNull()
66+
userService: UserService;
67+
68+
@IsBoolean()
69+
@NotNull()
70+
accessor disableController: boolean;
71+
72+
@ApiResponse({ status: 200, description: 'User created successfully' })
73+
@ApiError({ status: 400, description: 'Bad request' })
74+
createUser(
75+
@ValidateNested()
76+
@IsNotEmpty()
77+
@Body()
78+
createUserDto: CreateUserDto
79+
): UserDto {
80+
// ...
81+
}
82+
83+
}
84+
`}
85+
initial={dedent`
86+
@Post('/users')
87+
@ApiDescription('Create a new user')
88+
@Authenticated()
89+
@Controller()
90+
class CreateUserController {
91+
92+
@NotNull()
93+
@AutoInjected()
94+
userService: UserService;
95+
96+
@NotNull()
97+
@IsBoolean()
98+
accessor disableController: boolean;
99+
100+
@ApiError({ status: 400, description: 'Bad request' })
101+
@ApiResponse({ status: 200, description: 'User created successfully' })
102+
createUser(
103+
@IsNotEmpty()
104+
@ValidateNested()
105+
@Body()
106+
createUserDto: CreateUserDto
107+
): UserDto {
108+
// ...
109+
}
110+
111+
}
112+
`}
113+
client:load
114+
lang="tsx"
115+
/>
116+
117+
## Options
118+
119+
This rule accepts an options object with the following properties:
120+
121+
### type
122+
123+
<sub>default: `'alphabetical'`</sub>
124+
125+
Specifies the sorting method.
126+
127+
- `'alphabetical'` — Sort items alphabetically (e.g., “a” < “b” < “c”).
128+
- `'natural'` — Sort items in a natural order (e.g., “item2” < “item10”).
129+
- `'line-length'` — Sort items by the length of the code line (shorter lines first).
130+
131+
### order
132+
133+
<sub>default: `'asc'`</sub>
134+
135+
Determines whether the sorted items should be in ascending or descending order.
136+
137+
- `'asc'` — Sort items in ascending order (A to Z, 1 to 9).
138+
- `'desc'` — Sort items in descending order (Z to A, 9 to 1).
139+
140+
### ignoreCase
141+
142+
<sub>default: `true`</sub>
143+
144+
Controls whether sorting should be case-sensitive or not.
145+
146+
- `true` — Ignore case when sorting alphabetically or naturally (e.g., “A” and “a” are the same).
147+
- `false` — Consider case when sorting (e.g., “A” comes before “a”).
148+
149+
### sortOnClasses
150+
151+
<sub>default: `true`</sub>
152+
153+
Controls whether sorting should be enabled for class decorators.
154+
155+
### sortOnMethods
156+
157+
<sub>default: `true`</sub>
158+
159+
Controls whether sorting should be enabled for class method decorators.
160+
161+
### sortOnProperties
162+
163+
<sub>default: `true`</sub>
164+
165+
Controls whether sorting should be enabled for class property decorators.
166+
167+
### sortOnAccessors
168+
169+
<sub>default: `true`</sub>
170+
171+
Controls whether sorting should be enabled for class auto-accessor decorators.
172+
173+
### sortOnParameters
174+
175+
<sub>default: `true`</sub>
176+
177+
Controls whether sorting should be enabled for method parameter decorators.
178+
179+
### specialCharacters
180+
181+
<sub>default: `keep`</sub>
182+
183+
Controls whether special characters should be trimmed, removed or kept before sorting.
184+
185+
- `'keep'` — Keep special characters when sorting (e.g., “_a” comes before “a”).
186+
- `'trim'` — Trim special characters when sorting alphabetically or naturally (e.g., “_a” and “a” are the same).
187+
- `'remove'` — Remove special characters when sorting (e.g., “/a/b” and “ab” are the same).
188+
189+
### partitionByComment
190+
191+
<sub>default: `false`</sub>
192+
193+
Allows you to use comments to separate class decorators into logical groups.
194+
195+
- `true` — All comments will be treated as delimiters, creating partitions.
196+
- `false` — Comments will not be used as delimiters.
197+
- `string` — A glob pattern to specify which comments should act as delimiters.
198+
- `string[]` — An array of glob patterns to specify which comments should act as delimiters.
199+
200+
### groups
201+
202+
<sub>
203+
type: `Array<string | string[]>`
204+
</sub>
205+
<sub>default: `[]`</sub>
206+
207+
Allows you to specify a list of decorator groups for sorting.
208+
209+
Predefined groups:
210+
211+
- `'unknown'` — Decorators that don’t fit into any group specified in the `groups` option.
212+
213+
If the `unknown` group is not specified in the `groups` option, it will automatically be added to the end of the list.
214+
215+
Each decorator will be assigned a single group specified in the `groups` option (or the `unknown` group if no match is found).
216+
The order of items in the `groups` option determines how groups are ordered.
217+
218+
Within a given group, members will be sorted according to the `type`, `order`, `ignoreCase`, etc. options.
219+
220+
Individual groups can be combined together by placing them in an array. The order of groups in that array does not matter.
221+
All members of the groups in the array will be sorted together as if they were part of a single group.
222+
223+
### customGroups
224+
225+
<sub>
226+
type: `{ [groupName: string]: string | string[] }`
227+
</sub>
228+
<sub>default: `{}`</sub>
229+
230+
You can define your own groups and use custom glob patterns or regex to match specific decorators.
231+
232+
Use the `matcher` option to specify the pattern matching method.
233+
234+
Each key of `customGroups` represents a group name which you can then use in the `groups` option. The value for each key can either be of type:
235+
- `string` — A decorator's name matching the value will be marked as part of the group referenced by the key.
236+
- `string[]` — A decorator's name matching any of the values of the array will be marked as part of the group referenced by the key.
237+
The order of values in the array does not matter.
238+
239+
Custom group matching takes precedence over predefined group matching.
240+
241+
#### Example for class decorators (same for the rest of the elements):
242+
243+
```ts
244+
245+
Put all error-related decorators at the bottom:
246+
247+
```ts
248+
@Component()
249+
@Validated()
250+
@AtLeastOneAttributeError()
251+
@NoPublicAttributeError()
252+
class MyClass {
253+
}
254+
```
255+
256+
`groups` and `customGroups` configuration:
257+
258+
```js
259+
{
260+
groups: [
261+
'unknown',
262+
'error' // [!code ++]
263+
],
264+
+ customGroups: { // [!code ++]
265+
+ error: '*Error' // [!code ++]
266+
+ } // [!code ++]
267+
}
268+
```
269+
270+
### matcher
271+
272+
<sub>default: `'minimatch'`</sub>
273+
274+
Determines the matcher used for patterns in the `partitionByComment` and `customGroups` options.
275+
276+
- `'minimatch'` — Use the [minimatch](https://github.com/isaacs/minimatch) library for pattern matching.
277+
- `'regex'` — Use regular expressions for pattern matching.
278+
279+
## Usage
280+
281+
<CodeTabs
282+
code={[
283+
{
284+
source: dedent`
285+
// eslint.config.js
286+
import perfectionist from 'eslint-plugin-perfectionist'
287+
288+
export default [
289+
{
290+
plugins: {
291+
perfectionist,
292+
},
293+
rules: {
294+
'perfectionist/sort-decorators': [
295+
'error',
296+
{
297+
type: 'alphabetical',
298+
order: 'asc',
299+
ignoreCase: true,
300+
specialCharacters: 'keep',
301+
matcher: 'minimatch',
302+
groups: [],
303+
customGroups: {},
304+
sortOnClasses: true,
305+
sortOnMethods: true,
306+
sortOnAccessors: true,
307+
sortOnProperties: true,
308+
sortOnParameters: true,
309+
},
310+
],
311+
},
312+
},
313+
]
314+
`,
315+
name: 'Flat Config',
316+
value: 'flat',
317+
},
318+
{
319+
source: dedent`
320+
// .eslintrc.js
321+
module.exports = {
322+
plugins: [
323+
'perfectionist',
324+
],
325+
rules: {
326+
'perfectionist/sort-decorators': [
327+
'error',
328+
{
329+
type: 'alphabetical',
330+
order: 'asc',
331+
ignoreCase: true,
332+
specialCharacters: 'keep',
333+
matcher: 'minimatch',
334+
groups: [],
335+
customGroups: {},
336+
sortOnClasses: true,
337+
sortOnMethods: true,
338+
sortOnAccessors: true,
339+
sortOnProperties: true,
340+
sortOnParameters: true,
341+
},
342+
],
343+
},
344+
}
345+
`,
346+
name: 'Legacy Config',
347+
value: 'legacy',
348+
},
349+
]}
350+
type="config-type"
351+
client:load
352+
lang="ts"
353+
/>
354+
355+
## Version
356+
357+
This rule was introduced in [v4.0.0](https://github.com/azat-io/eslint-plugin-perfectionist/releases/tag/v4.0.0).
358+
359+
## Resources
360+
361+
- [Rule source](https://github.com/azat-io/eslint-plugin-perfectionist/blob/main/rules/sort-decorators.ts)
362+
- [Test source](https://github.com/azat-io/eslint-plugin-perfectionist/blob/main/test/sort-decorators.test.ts)

‎index.ts

+2
Original file line numberDiff line numberDiff line change
@@ -12,6 +12,7 @@ import sortObjectTypes from './rules/sort-object-types'
1212
import sortSwitchCase from './rules/sort-switch-case'
1313
import sortUnionTypes from './rules/sort-union-types'
1414
import sortInterfaces from './rules/sort-interfaces'
15+
import sortDecorators from './rules/sort-decorators'
1516
import sortJsxProps from './rules/sort-jsx-props'
1617
import sortClasses from './rules/sort-classes'
1718
import sortImports from './rules/sort-imports'
@@ -42,6 +43,7 @@ let plugin = {
4243
'sort-object-types': sortObjectTypes,
4344
'sort-union-types': sortUnionTypes,
4445
'sort-switch-case': sortSwitchCase,
46+
'sort-decorators': sortDecorators,
4547
'sort-interfaces': sortInterfaces,
4648
'sort-jsx-props': sortJsxProps,
4749
'sort-classes': sortClasses,

‎readme.md

+1
Original file line numberDiff line numberDiff line change
@@ -176,6 +176,7 @@ module.exports = {
176176
| :--------------------------------------------------------------------------------------- | :------------------------------------------ | :-- |
177177
| [sort-array-includes](https://perfectionist.dev/rules/sort-array-includes) | Enforce sorted arrays before include method | 🔧 |
178178
| [sort-classes](https://perfectionist.dev/rules/sort-classes) | Enforce sorted classes | 🔧 |
179+
| [sort-decorators](https://perfectionist.dev/rules/sort-decorators) | Enforce sorted decorators | 🔧 |
179180
| [sort-enums](https://perfectionist.dev/rules/sort-enums) | Enforce sorted TypeScript enums | 🔧 |
180181
| [sort-exports](https://perfectionist.dev/rules/sort-exports) | Enforce sorted exports | 🔧 |
181182
| [sort-imports](https://perfectionist.dev/rules/sort-imports) | Enforce sorted imports | 🔧 |

‎rules/sort-decorators.ts

+323
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,323 @@
1+
import type { RuleContext } from '@typescript-eslint/utils/ts-eslint'
2+
import type { TSESTree } from '@typescript-eslint/types'
3+
4+
import type { SortingNode } from '../typings'
5+
6+
import { validateGroupsConfiguration } from '../utils/validate-groups-configuration'
7+
import { hasPartitionComment } from '../utils/is-partition-comment'
8+
import { sortNodesByGroups } from '../utils/sort-nodes-by-groups'
9+
import { getCommentsBefore } from '../utils/get-comments-before'
10+
import { createEslintRule } from '../utils/create-eslint-rule'
11+
import { getDecoratorName } from '../utils/get-decorator-name'
12+
import { getGroupNumber } from '../utils/get-group-number'
13+
import { getSourceCode } from '../utils/get-source-code'
14+
import { toSingleLine } from '../utils/to-single-line'
15+
import { rangeToDiff } from '../utils/range-to-diff'
16+
import { getSettings } from '../utils/get-settings'
17+
import { useGroups } from '../utils/use-groups'
18+
import { makeFixes } from '../utils/make-fixes'
19+
import { complete } from '../utils/complete'
20+
import { pairwise } from '../utils/pairwise'
21+
22+
type MESSAGE_ID = 'unexpectedDecoratorsGroupOrder' | 'unexpectedDecoratorsOrder'
23+
24+
type Group<T extends string[]> = 'unknown' | T[number]
25+
26+
export type Options<T extends string[]> = [
27+
Partial<{
28+
customGroups: { [key in T[number]]: string[] | string }
29+
type: 'alphabetical' | 'line-length' | 'natural'
30+
partitionByComment: string[] | boolean | string
31+
specialCharacters: 'remove' | 'trim' | 'keep'
32+
groups: (Group<T>[] | Group<T>)[]
33+
matcher: 'minimatch' | 'regex'
34+
sortOnParameters: boolean
35+
sortOnProperties: boolean
36+
sortOnAccessors: boolean
37+
sortOnMethods: boolean
38+
sortOnClasses: boolean
39+
order: 'desc' | 'asc'
40+
ignoreCase: boolean
41+
}>,
42+
]
43+
44+
type SortDecoratorsSortingNode = SortingNode<TSESTree.Decorator>
45+
46+
export default createEslintRule<Options<string[]>, MESSAGE_ID>({
47+
name: 'sort-decorators',
48+
meta: {
49+
type: 'suggestion',
50+
docs: {
51+
description: 'Enforce sorted decorators.',
52+
},
53+
fixable: 'code',
54+
schema: [
55+
{
56+
type: 'object',
57+
properties: {
58+
type: {
59+
description: 'Specifies the sorting method.',
60+
type: 'string',
61+
enum: ['alphabetical', 'natural', 'line-length'],
62+
},
63+
order: {
64+
description:
65+
'Determines whether the sorted items should be in ascending or descending order.',
66+
type: 'string',
67+
enum: ['asc', 'desc'],
68+
},
69+
matcher: {
70+
description: 'Specifies the string matcher.',
71+
type: 'string',
72+
enum: ['minimatch', 'regex'],
73+
},
74+
ignoreCase: {
75+
description:
76+
'Controls whether sorting should be case-sensitive or not.',
77+
type: 'boolean',
78+
},
79+
specialCharacters: {
80+
description:
81+
'Controls how special characters should be handled before sorting.',
82+
type: 'string',
83+
enum: ['remove', 'trim', 'keep'],
84+
},
85+
sortOnClasses: {
86+
description:
87+
'Controls whether sorting should be enabled for class decorators.',
88+
type: 'boolean',
89+
},
90+
sortOnMethods: {
91+
description:
92+
'Controls whether sorting should be enabled for class method decorators.',
93+
type: 'boolean',
94+
},
95+
sortOnParameters: {
96+
description:
97+
'Controls whether sorting should be enabled for method parameter decorators.',
98+
type: 'boolean',
99+
},
100+
sortOnProperties: {
101+
description:
102+
'Controls whether sorting should be enabled for class property decorators.',
103+
type: 'boolean',
104+
},
105+
sortOnAccessors: {
106+
description:
107+
'Controls whether sorting should be enabled for class accessor decorators.',
108+
type: 'boolean',
109+
},
110+
partitionByComment: {
111+
description:
112+
'Allows you to use comments to separate the decorators into logical groups.',
113+
anyOf: [
114+
{
115+
type: 'boolean',
116+
},
117+
{
118+
type: 'string',
119+
},
120+
{
121+
type: 'array',
122+
items: {
123+
type: 'string',
124+
},
125+
},
126+
],
127+
},
128+
groups: {
129+
description: 'Specifies the order of the groups.',
130+
type: 'array',
131+
items: {
132+
oneOf: [
133+
{
134+
type: 'string',
135+
},
136+
{
137+
type: 'array',
138+
items: {
139+
type: 'string',
140+
},
141+
},
142+
],
143+
},
144+
},
145+
customGroups: {
146+
description: 'Specifies custom groups.',
147+
type: 'object',
148+
additionalProperties: {
149+
oneOf: [
150+
{
151+
type: 'string',
152+
},
153+
{
154+
type: 'array',
155+
items: {
156+
type: 'string',
157+
},
158+
},
159+
],
160+
},
161+
},
162+
},
163+
additionalProperties: false,
164+
},
165+
],
166+
messages: {
167+
unexpectedDecoratorsGroupOrder:
168+
'Expected "{{right}}" ({{rightGroup}}) to come before "{{left}}" ({{leftGroup}}).',
169+
unexpectedDecoratorsOrder:
170+
'Expected "{{right}}" to come before "{{left}}".',
171+
},
172+
},
173+
defaultOptions: [
174+
{
175+
type: 'alphabetical',
176+
order: 'asc',
177+
ignoreCase: true,
178+
specialCharacters: 'keep',
179+
partitionByComment: false,
180+
matcher: 'minimatch',
181+
groups: [],
182+
customGroups: {},
183+
sortOnClasses: true,
184+
sortOnMethods: true,
185+
sortOnAccessors: true,
186+
sortOnProperties: true,
187+
sortOnParameters: true,
188+
},
189+
],
190+
create: context => {
191+
let settings = getSettings(context.settings)
192+
193+
let options = complete(context.options.at(0), settings, {
194+
type: 'alphabetical',
195+
matcher: 'minimatch',
196+
ignoreCase: true,
197+
specialCharacters: 'keep',
198+
partitionByComment: false,
199+
customGroups: {},
200+
order: 'asc',
201+
groups: [],
202+
sortOnClasses: true,
203+
sortOnMethods: true,
204+
sortOnAccessors: true,
205+
sortOnProperties: true,
206+
sortOnParameters: true,
207+
} as const)
208+
209+
validateGroupsConfiguration(
210+
options.groups,
211+
['unknown'],
212+
Object.keys(options.customGroups),
213+
)
214+
215+
return {
216+
ClassDeclaration: Declaration =>
217+
options.sortOnClasses
218+
? sortDecorators(context, options, Declaration.decorators)
219+
: undefined,
220+
AccessorProperty: accessorDefinition =>
221+
options.sortOnAccessors
222+
? sortDecorators(context, options, accessorDefinition.decorators)
223+
: undefined,
224+
MethodDefinition: methodDefinition =>
225+
options.sortOnMethods
226+
? sortDecorators(context, options, methodDefinition.decorators)
227+
: undefined,
228+
PropertyDefinition: propertyDefinition =>
229+
options.sortOnProperties
230+
? sortDecorators(context, options, propertyDefinition.decorators)
231+
: undefined,
232+
Decorator: decorator => {
233+
if (!options.sortOnParameters) {
234+
return
235+
}
236+
if (
237+
'decorators' in decorator.parent &&
238+
decorator.parent.type === 'Identifier' &&
239+
decorator.parent.parent.type === 'FunctionExpression'
240+
) {
241+
let { decorators } = decorator.parent
242+
if (decorator !== decorators[0]) {
243+
return
244+
}
245+
sortDecorators(context, options, decorators)
246+
}
247+
},
248+
}
249+
},
250+
})
251+
252+
let sortDecorators = (
253+
context: Readonly<RuleContext<MESSAGE_ID, Options<string[]>>>,
254+
options: Required<Options<string[]>[0]>,
255+
decorators: TSESTree.Decorator[],
256+
) => {
257+
if (decorators.length < 2) {
258+
return
259+
}
260+
let sourceCode = getSourceCode(context)
261+
let partitionComment = options.partitionByComment
262+
263+
let formattedMembers: SortDecoratorsSortingNode[][] = decorators.reduce(
264+
(accumulator: SortDecoratorsSortingNode[][], decorator) => {
265+
if (
266+
partitionComment &&
267+
hasPartitionComment(
268+
partitionComment,
269+
getCommentsBefore(decorator, sourceCode),
270+
options.matcher,
271+
)
272+
) {
273+
accumulator.push([])
274+
}
275+
276+
let { getGroup, setCustomGroups } = useGroups(options)
277+
let name = getDecoratorName(decorator)
278+
279+
setCustomGroups(options.customGroups, name)
280+
281+
let sortingNode: SortDecoratorsSortingNode = {
282+
size: rangeToDiff(decorator.range),
283+
node: decorator,
284+
group: getGroup(),
285+
name,
286+
}
287+
288+
accumulator.at(-1)!.push(sortingNode)
289+
290+
return accumulator
291+
},
292+
[[]],
293+
)
294+
295+
let sortedNodes = formattedMembers.flatMap(nodes =>
296+
sortNodesByGroups(nodes, options),
297+
)
298+
299+
let nodes = formattedMembers.flat()
300+
pairwise(nodes, (left, right) => {
301+
let indexOfLeft = sortedNodes.indexOf(left)
302+
let indexOfRight = sortedNodes.indexOf(right)
303+
if (indexOfLeft <= indexOfRight) {
304+
return
305+
}
306+
let leftNum = getGroupNumber(options.groups, left)
307+
let rightNum = getGroupNumber(options.groups, right)
308+
context.report({
309+
messageId:
310+
leftNum !== rightNum
311+
? 'unexpectedDecoratorsGroupOrder'
312+
: 'unexpectedDecoratorsOrder',
313+
data: {
314+
left: toSingleLine(left.name),
315+
leftGroup: left.group,
316+
right: toSingleLine(right.name),
317+
rightGroup: right.group,
318+
},
319+
node: right.node,
320+
fix: fixer => makeFixes(fixer, nodes, sortedNodes, sourceCode, options),
321+
})
322+
})
323+
}

‎test/get-decorator-name.test.ts

+69
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,69 @@
1+
import type { TSESTree } from '@typescript-eslint/types'
2+
3+
import { AST_NODE_TYPES } from '@typescript-eslint/types'
4+
import { describe, expect, it } from 'vitest'
5+
6+
import { getDecoratorName } from '../utils/get-decorator-name'
7+
8+
describe('get-decorator-name', () => {
9+
describe('call expressions', () => {
10+
it('returns the decorator name', () => {
11+
expect(
12+
getDecoratorName({
13+
expression: {
14+
type: AST_NODE_TYPES.CallExpression,
15+
callee: {
16+
name: 'decoratorName',
17+
type: AST_NODE_TYPES.Identifier,
18+
},
19+
},
20+
type: AST_NODE_TYPES.Decorator,
21+
} as TSESTree.Decorator),
22+
).toBe('decoratorName')
23+
})
24+
25+
it('throws an error if callee type is not Identifier', () => {
26+
expect(() =>
27+
getDecoratorName({
28+
expression: {
29+
type: AST_NODE_TYPES.CallExpression,
30+
callee: {
31+
name: 'decoratorName',
32+
},
33+
},
34+
type: AST_NODE_TYPES.Decorator,
35+
} as TSESTree.Decorator),
36+
).toThrow(
37+
"Unexpected decorator expression's callee type. Please 'report this " +
38+
'issue here: ' +
39+
'https://github.com/azat-io/eslint-plugin-perfectionist/issues',
40+
)
41+
})
42+
})
43+
44+
it('throws an error if expression type is invalid', () => {
45+
expect(() =>
46+
getDecoratorName({
47+
expression: {
48+
type: AST_NODE_TYPES.ArrayExpression,
49+
},
50+
type: AST_NODE_TYPES.Decorator,
51+
} as TSESTree.Decorator),
52+
).toThrow(
53+
'Unexpected decorator expression type. Please report this issue here: ' +
54+
'https://github.com/azat-io/eslint-plugin-perfectionist/issues',
55+
)
56+
})
57+
58+
it('returns the decorator name', () => {
59+
expect(
60+
getDecoratorName({
61+
expression: {
62+
type: AST_NODE_TYPES.Identifier,
63+
name: 'decoratorName',
64+
},
65+
type: AST_NODE_TYPES.Decorator,
66+
} as TSESTree.Decorator),
67+
).toBe('decoratorName')
68+
})
69+
})

‎test/sort-decorators.test.ts

+3,176
Large diffs are not rendered by default.

‎utils/get-decorator-name.ts

+24
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,24 @@
1+
import type { TSESTree } from '@typescript-eslint/types'
2+
3+
import { AST_NODE_TYPES } from '@typescript-eslint/types'
4+
5+
export const getDecoratorName = (decorator: TSESTree.Decorator) => {
6+
switch (decorator.expression.type) {
7+
case AST_NODE_TYPES.CallExpression:
8+
if (decorator.expression.callee.type !== AST_NODE_TYPES.Identifier) {
9+
throw new Error(
10+
"Unexpected decorator expression's callee type. Please 'report this " +
11+
'issue here: ' +
12+
'https://github.com/azat-io/eslint-plugin-perfectionist/issues',
13+
)
14+
}
15+
return decorator.expression.callee.name
16+
case AST_NODE_TYPES.Identifier:
17+
return decorator.expression.name
18+
default:
19+
throw new Error(
20+
'Unexpected decorator expression type. Please report this issue here: ' +
21+
'https://github.com/azat-io/eslint-plugin-perfectionist/issues',
22+
)
23+
}
24+
}

0 commit comments

Comments
 (0)
Please sign in to comment.