eslint-plugin-perfectionist 3.7.0 → 3.9.0
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/dist/index.d.ts +91 -31
- package/dist/index.js +7 -4
- package/dist/index.mjs +7 -4
- package/dist/rules/sort-array-includes.js +17 -3
- package/dist/rules/sort-array-includes.mjs +17 -3
- package/dist/rules/sort-astro-attributes.js +18 -1
- package/dist/rules/sort-astro-attributes.mjs +19 -3
- package/dist/rules/sort-classes-utils.js +62 -8
- package/dist/rules/sort-classes-utils.mjs +56 -8
- package/dist/rules/sort-classes.js +52 -63
- package/dist/rules/sort-classes.mjs +48 -60
- package/dist/rules/sort-classes.types.js +4 -0
- package/dist/rules/sort-classes.types.mjs +4 -0
- package/dist/rules/sort-enums.js +24 -3
- package/dist/rules/sort-enums.mjs +18 -3
- package/dist/rules/sort-exports.js +23 -3
- package/dist/rules/sort-exports.mjs +17 -3
- package/dist/rules/sort-imports.js +234 -238
- package/dist/rules/sort-imports.mjs +219 -227
- package/dist/rules/sort-interfaces.js +37 -10
- package/dist/rules/sort-interfaces.mjs +32 -12
- package/dist/rules/sort-intersection-types.js +24 -4
- package/dist/rules/sort-intersection-types.mjs +18 -4
- package/dist/rules/sort-jsx-props.js +18 -3
- package/dist/rules/sort-jsx-props.mjs +19 -5
- package/dist/rules/sort-maps.js +17 -3
- package/dist/rules/sort-maps.mjs +17 -3
- package/dist/rules/sort-named-exports.js +23 -3
- package/dist/rules/sort-named-exports.mjs +17 -3
- package/dist/rules/sort-named-imports.js +22 -3
- package/dist/rules/sort-named-imports.mjs +16 -3
- package/dist/rules/sort-object-types.js +37 -8
- package/dist/rules/sort-object-types.mjs +31 -10
- package/dist/rules/sort-objects.js +35 -16
- package/dist/rules/sort-objects.mjs +33 -15
- package/dist/rules/sort-sets.js +2 -0
- package/dist/rules/sort-sets.mjs +2 -0
- package/dist/rules/sort-svelte-attributes.js +21 -6
- package/dist/rules/sort-svelte-attributes.mjs +22 -8
- package/dist/rules/sort-switch-case.js +10 -1
- package/dist/rules/sort-switch-case.mjs +10 -1
- package/dist/rules/sort-union-types.js +24 -4
- package/dist/rules/sort-union-types.mjs +18 -4
- package/dist/rules/sort-variable-declarations.js +23 -3
- package/dist/rules/sort-variable-declarations.mjs +17 -3
- package/dist/rules/sort-vue-attributes.js +18 -1
- package/dist/rules/sort-vue-attributes.mjs +19 -3
- package/dist/utils/compare.js +26 -6
- package/dist/utils/compare.mjs +26 -6
- package/dist/utils/get-node-range.js +11 -3
- package/dist/utils/get-node-range.mjs +13 -3
- package/dist/utils/get-options-with-clean-groups.js +13 -0
- package/dist/utils/get-options-with-clean-groups.mjs +11 -0
- package/dist/utils/get-settings.js +9 -10
- package/dist/utils/get-settings.mjs +9 -10
- package/dist/utils/is-partition-comment.js +8 -10
- package/dist/utils/is-partition-comment.mjs +8 -10
- package/dist/utils/matches.js +15 -0
- package/dist/utils/matches.mjs +13 -0
- package/dist/utils/sort-nodes-by-groups.js +33 -7
- package/dist/utils/sort-nodes-by-groups.mjs +33 -7
- package/dist/utils/use-groups.js +4 -8
- package/dist/utils/use-groups.mjs +4 -13
- package/dist/utils/validate-groups-configuration.js +11 -0
- package/dist/utils/validate-groups-configuration.mjs +11 -1
- package/{license → license.md} +1 -1
- package/package.json +3 -3
|
@@ -1,7 +1,8 @@
|
|
|
1
1
|
'use strict'
|
|
2
2
|
const node_module = require('node:module')
|
|
3
|
-
const minimatch = require('minimatch')
|
|
4
3
|
const validateGroupsConfiguration = require('../utils/validate-groups-configuration.js')
|
|
4
|
+
const getOptionsWithCleanGroups = require('../utils/get-options-with-clean-groups.js')
|
|
5
|
+
const sortNodesByGroups = require('../utils/sort-nodes-by-groups.js')
|
|
5
6
|
const getCommentsBefore = require('../utils/get-comments-before.js')
|
|
6
7
|
const createEslintRule = require('../utils/create-eslint-rule.js')
|
|
7
8
|
const getLinesBetween = require('../utils/get-lines-between.js')
|
|
@@ -10,12 +11,11 @@ const getSourceCode = require('../utils/get-source-code.js')
|
|
|
10
11
|
const getNodeRange = require('../utils/get-node-range.js')
|
|
11
12
|
const rangeToDiff = require('../utils/range-to-diff.js')
|
|
12
13
|
const getSettings = require('../utils/get-settings.js')
|
|
13
|
-
const isPositive = require('../utils/is-positive.js')
|
|
14
14
|
const useGroups = require('../utils/use-groups.js')
|
|
15
|
-
const
|
|
15
|
+
const makeFixes = require('../utils/make-fixes.js')
|
|
16
16
|
const complete = require('../utils/complete.js')
|
|
17
17
|
const pairwise = require('../utils/pairwise.js')
|
|
18
|
-
const
|
|
18
|
+
const matches = require('../utils/matches.js')
|
|
19
19
|
const sortImports = createEslintRule.createEslintRule({
|
|
20
20
|
name: 'sort-imports',
|
|
21
21
|
meta: {
|
|
@@ -40,11 +40,22 @@ const sortImports = createEslintRule.createEslintRule({
|
|
|
40
40
|
type: 'string',
|
|
41
41
|
enum: ['asc', 'desc'],
|
|
42
42
|
},
|
|
43
|
+
matcher: {
|
|
44
|
+
description: 'Specifies the string matcher.',
|
|
45
|
+
type: 'string',
|
|
46
|
+
enum: ['minimatch', 'regex'],
|
|
47
|
+
},
|
|
43
48
|
ignoreCase: {
|
|
44
49
|
description:
|
|
45
50
|
'Controls whether sorting should be case-sensitive or not.',
|
|
46
51
|
type: 'boolean',
|
|
47
52
|
},
|
|
53
|
+
specialCharacters: {
|
|
54
|
+
description:
|
|
55
|
+
'Controls how special characters should be handled before sorting.',
|
|
56
|
+
type: 'string',
|
|
57
|
+
enum: ['remove', 'trim', 'keep'],
|
|
58
|
+
},
|
|
48
59
|
internalPattern: {
|
|
49
60
|
description: 'Specifies the pattern for internal modules.',
|
|
50
61
|
items: {
|
|
@@ -154,10 +165,12 @@ const sortImports = createEslintRule.createEslintRule({
|
|
|
154
165
|
type: 'alphabetical',
|
|
155
166
|
order: 'asc',
|
|
156
167
|
ignoreCase: true,
|
|
168
|
+
specialCharacters: 'keep',
|
|
157
169
|
internalPattern: ['~/**'],
|
|
158
170
|
sortSideEffects: false,
|
|
159
171
|
newlinesBetween: 'always',
|
|
160
172
|
maxLineLength: void 0,
|
|
173
|
+
matcher: 'minimatch',
|
|
161
174
|
groups: [
|
|
162
175
|
'type',
|
|
163
176
|
['builtin', 'external'],
|
|
@@ -174,44 +187,34 @@ const sortImports = createEslintRule.createEslintRule({
|
|
|
174
187
|
],
|
|
175
188
|
create: context => {
|
|
176
189
|
let settings = getSettings.getSettings(context.settings)
|
|
177
|
-
let
|
|
178
|
-
|
|
179
|
-
|
|
180
|
-
[
|
|
181
|
-
|
|
182
|
-
|
|
183
|
-
|
|
184
|
-
|
|
185
|
-
|
|
186
|
-
|
|
187
|
-
|
|
188
|
-
|
|
189
|
-
|
|
190
|
-
|
|
191
|
-
|
|
192
|
-
|
|
193
|
-
|
|
194
|
-
|
|
195
|
-
|
|
196
|
-
|
|
197
|
-
|
|
198
|
-
|
|
199
|
-
|
|
200
|
-
|
|
201
|
-
|
|
202
|
-
|
|
203
|
-
|
|
204
|
-
|
|
205
|
-
}
|
|
206
|
-
} else {
|
|
207
|
-
if (group === 'unknown') {
|
|
208
|
-
hasUnknownGroup = true
|
|
209
|
-
}
|
|
210
|
-
}
|
|
211
|
-
}
|
|
212
|
-
if (!hasUnknownGroup) {
|
|
213
|
-
options.groups = [...options.groups, 'unknown']
|
|
214
|
-
}
|
|
190
|
+
let userOptions = context.options.at(0)
|
|
191
|
+
let options = getOptionsWithCleanGroups.getOptionsWithCleanGroups(
|
|
192
|
+
complete.complete(userOptions, settings, {
|
|
193
|
+
groups: [
|
|
194
|
+
'type',
|
|
195
|
+
['builtin', 'external'],
|
|
196
|
+
'internal-type',
|
|
197
|
+
'internal',
|
|
198
|
+
['parent-type', 'sibling-type', 'index-type'],
|
|
199
|
+
['parent', 'sibling', 'index'],
|
|
200
|
+
'object',
|
|
201
|
+
'unknown',
|
|
202
|
+
],
|
|
203
|
+
matcher: 'minimatch',
|
|
204
|
+
customGroups: { type: {}, value: {} },
|
|
205
|
+
internalPattern:
|
|
206
|
+
(userOptions == null ? void 0 : userOptions.matcher) === 'regex'
|
|
207
|
+
? ['^~/.*']
|
|
208
|
+
: ['~/**'],
|
|
209
|
+
newlinesBetween: 'always',
|
|
210
|
+
sortSideEffects: false,
|
|
211
|
+
type: 'alphabetical',
|
|
212
|
+
environment: 'node',
|
|
213
|
+
ignoreCase: true,
|
|
214
|
+
specialCharacters: 'keep',
|
|
215
|
+
order: 'asc',
|
|
216
|
+
}),
|
|
217
|
+
)
|
|
215
218
|
validateGroupsConfiguration.validateGroupsConfiguration(
|
|
216
219
|
options.groups,
|
|
217
220
|
[
|
|
@@ -239,17 +242,63 @@ const sortImports = createEslintRule.createEslintRule({
|
|
|
239
242
|
...Object.keys(options.customGroups.value ?? {}),
|
|
240
243
|
],
|
|
241
244
|
)
|
|
245
|
+
let isSideEffectOnlyGroup = group => {
|
|
246
|
+
if (!group) {
|
|
247
|
+
return false
|
|
248
|
+
}
|
|
249
|
+
if (typeof group === 'string') {
|
|
250
|
+
return group === 'side-effect' || group === 'side-effect-style'
|
|
251
|
+
}
|
|
252
|
+
return group.every(isSideEffectOnlyGroup)
|
|
253
|
+
}
|
|
254
|
+
if (!options.sortSideEffects) {
|
|
255
|
+
let hasInvalidGroup = options.groups
|
|
256
|
+
.filter(group => Array.isArray(group))
|
|
257
|
+
.some(
|
|
258
|
+
nestedGroup =>
|
|
259
|
+
!isSideEffectOnlyGroup(nestedGroup) &&
|
|
260
|
+
nestedGroup.some(
|
|
261
|
+
subGroup =>
|
|
262
|
+
subGroup === 'side-effect' || subGroup === 'side-effect-style',
|
|
263
|
+
),
|
|
264
|
+
)
|
|
265
|
+
if (hasInvalidGroup) {
|
|
266
|
+
throw new Error(
|
|
267
|
+
"Side effect groups cannot be nested with non side effect groups when 'sortSideEffects' is 'false'.",
|
|
268
|
+
)
|
|
269
|
+
}
|
|
270
|
+
}
|
|
271
|
+
let sourceCode = getSourceCode.getSourceCode(context)
|
|
242
272
|
let nodes = []
|
|
243
273
|
let isSideEffectImport = node =>
|
|
244
274
|
node.type === 'ImportDeclaration' &&
|
|
245
275
|
node.specifiers.length ===
|
|
246
276
|
0 /* Avoid matching on named imports without specifiers */ &&
|
|
247
277
|
!/}\s*from\s+/.test(sourceCode.getText(node))
|
|
248
|
-
let
|
|
249
|
-
|
|
250
|
-
|
|
251
|
-
|
|
252
|
-
|
|
278
|
+
let isStyle = value =>
|
|
279
|
+
['.less', '.scss', '.sass', '.styl', '.pcss', '.css', '.sss'].some(
|
|
280
|
+
extension => value.endsWith(extension),
|
|
281
|
+
)
|
|
282
|
+
let hasMultipleImportDeclarations = node => node.specifiers.length > 1
|
|
283
|
+
let flatGroups = options.groups.flat()
|
|
284
|
+
let shouldRegroupSideEffectNodes = flatGroups.includes('side-effect')
|
|
285
|
+
let shouldRegroupSideEffectStyleNodes =
|
|
286
|
+
flatGroups.includes('side-effect-style')
|
|
287
|
+
let registerNode = node => {
|
|
288
|
+
let name
|
|
289
|
+
if (node.type === 'ImportDeclaration') {
|
|
290
|
+
name = node.source.value
|
|
291
|
+
} else if (node.type === 'TSImportEqualsDeclaration') {
|
|
292
|
+
if (node.moduleReference.type === 'TSExternalModuleReference') {
|
|
293
|
+
name = `${node.moduleReference.expression.value}`
|
|
294
|
+
} else {
|
|
295
|
+
name = sourceCode.text.slice(...node.moduleReference.range)
|
|
296
|
+
}
|
|
297
|
+
} else {
|
|
298
|
+
let decl = node.declarations[0].init
|
|
299
|
+
let { value } = decl.arguments[0]
|
|
300
|
+
name = value.toString()
|
|
301
|
+
}
|
|
253
302
|
let isIndex = value =>
|
|
254
303
|
[
|
|
255
304
|
'./index.d.js',
|
|
@@ -260,17 +309,14 @@ const sortImports = createEslintRule.createEslintRule({
|
|
|
260
309
|
'./',
|
|
261
310
|
'.',
|
|
262
311
|
].includes(value)
|
|
263
|
-
let isParent = value => value.
|
|
264
|
-
let isSibling = value => value.
|
|
265
|
-
let { getGroup, defineGroup, setCustomGroups } =
|
|
266
|
-
options
|
|
267
|
-
)
|
|
312
|
+
let isParent = value => value.startsWith('..')
|
|
313
|
+
let isSibling = value => value.startsWith('./')
|
|
314
|
+
let { getGroup, defineGroup, setCustomGroups } =
|
|
315
|
+
useGroups.useGroups(options)
|
|
268
316
|
let isInternal = value =>
|
|
269
317
|
options.internalPattern.length &&
|
|
270
318
|
options.internalPattern.some(pattern =>
|
|
271
|
-
|
|
272
|
-
nocomment: true,
|
|
273
|
-
}),
|
|
319
|
+
matches.matches(value, pattern, options.matcher),
|
|
274
320
|
)
|
|
275
321
|
let isCoreModule = value => {
|
|
276
322
|
let bunModules = [
|
|
@@ -321,6 +367,8 @@ const sortImports = createEslintRule.createEslintRule({
|
|
|
321
367
|
}
|
|
322
368
|
defineGroup('type')
|
|
323
369
|
}
|
|
370
|
+
let isSideEffect = isSideEffectImport(node)
|
|
371
|
+
let isStyleSideEffect = false
|
|
324
372
|
if (
|
|
325
373
|
node.type === 'ImportDeclaration' ||
|
|
326
374
|
node.type === 'VariableDeclaration'
|
|
@@ -333,14 +381,16 @@ const sortImports = createEslintRule.createEslintRule({
|
|
|
333
381
|
let declValue = decl.arguments[0].value
|
|
334
382
|
value = declValue.toString()
|
|
335
383
|
}
|
|
384
|
+
let isStyleValue = isStyle(value)
|
|
385
|
+
isStyleSideEffect = isSideEffect && isStyleValue
|
|
336
386
|
setCustomGroups(options.customGroups.value, value)
|
|
337
|
-
if (
|
|
387
|
+
if (isStyleSideEffect) {
|
|
338
388
|
defineGroup('side-effect-style')
|
|
339
389
|
}
|
|
340
|
-
if (
|
|
390
|
+
if (isSideEffect) {
|
|
341
391
|
defineGroup('side-effect')
|
|
342
392
|
}
|
|
343
|
-
if (
|
|
393
|
+
if (isStyleValue) {
|
|
344
394
|
defineGroup('style')
|
|
345
395
|
}
|
|
346
396
|
if (isIndex(value)) {
|
|
@@ -362,28 +412,15 @@ const sortImports = createEslintRule.createEslintRule({
|
|
|
362
412
|
defineGroup('external')
|
|
363
413
|
}
|
|
364
414
|
}
|
|
365
|
-
return getGroup()
|
|
366
|
-
}
|
|
367
|
-
let hasMultipleImportDeclarations = node => node.specifiers.length > 1
|
|
368
|
-
let registerNode = node => {
|
|
369
|
-
let name
|
|
370
|
-
if (node.type === 'ImportDeclaration') {
|
|
371
|
-
name = node.source.value
|
|
372
|
-
} else if (node.type === 'TSImportEqualsDeclaration') {
|
|
373
|
-
if (node.moduleReference.type === 'TSExternalModuleReference') {
|
|
374
|
-
name = `${node.moduleReference.expression.value}`
|
|
375
|
-
} else {
|
|
376
|
-
name = sourceCode.text.slice(...node.moduleReference.range)
|
|
377
|
-
}
|
|
378
|
-
} else {
|
|
379
|
-
let decl = node.declarations[0].init
|
|
380
|
-
let { value } = decl.arguments[0]
|
|
381
|
-
name = value.toString()
|
|
382
|
-
}
|
|
383
415
|
nodes.push({
|
|
384
416
|
size: rangeToDiff.rangeToDiff(node.range),
|
|
385
|
-
group:
|
|
417
|
+
group: getGroup(),
|
|
386
418
|
node,
|
|
419
|
+
isIgnored:
|
|
420
|
+
!options.sortSideEffects &&
|
|
421
|
+
isSideEffect &&
|
|
422
|
+
!shouldRegroupSideEffectNodes &&
|
|
423
|
+
(!isStyleSideEffect || !shouldRegroupSideEffectStyleNodes),
|
|
387
424
|
name,
|
|
388
425
|
...(options.type === 'line-length' &&
|
|
389
426
|
options.maxLineLength && {
|
|
@@ -416,193 +453,152 @@ const sortImports = createEslintRule.createEslintRule({
|
|
|
416
453
|
!!sourceCode.getTokensBetween(left.node, right.node, {
|
|
417
454
|
includeComments: false,
|
|
418
455
|
}).length
|
|
419
|
-
let
|
|
420
|
-
let fixes = []
|
|
421
|
-
let grouped = {}
|
|
422
|
-
for (let node of nodesToFix) {
|
|
423
|
-
let groupNum = getGroupNumber.getGroupNumber(options.groups, node)
|
|
424
|
-
if (!(groupNum in grouped)) {
|
|
425
|
-
grouped[groupNum] = [node]
|
|
426
|
-
} else {
|
|
427
|
-
if (!options.sortSideEffects && isSideEffectImport(node.node)) {
|
|
428
|
-
grouped[groupNum] = [...grouped[groupNum], node]
|
|
429
|
-
} else {
|
|
430
|
-
grouped[groupNum] = sortNodes.sortNodes(
|
|
431
|
-
[...grouped[groupNum], node],
|
|
432
|
-
options,
|
|
433
|
-
)
|
|
434
|
-
}
|
|
435
|
-
}
|
|
436
|
-
}
|
|
437
|
-
let formatted = Object.keys(grouped)
|
|
438
|
-
.sort((a, b) => Number(a) - Number(b))
|
|
439
|
-
.reduce(
|
|
440
|
-
(accumulator, group) => [...accumulator, ...grouped[group]],
|
|
441
|
-
[],
|
|
442
|
-
)
|
|
443
|
-
for (let max = formatted.length, i = 0; i < max; i++) {
|
|
444
|
-
let node = formatted.at(i)
|
|
445
|
-
fixes.push(
|
|
446
|
-
fixer.replaceTextRange(
|
|
447
|
-
getNodeRange.getNodeRange(nodesToFix.at(i).node, sourceCode),
|
|
448
|
-
sourceCode.text.slice(
|
|
449
|
-
...getNodeRange.getNodeRange(node.node, sourceCode),
|
|
450
|
-
),
|
|
451
|
-
),
|
|
452
|
-
)
|
|
453
|
-
if (options.newlinesBetween !== 'ignore') {
|
|
454
|
-
let nextNode = formatted.at(i + 1)
|
|
455
|
-
if (nextNode) {
|
|
456
|
-
let linesBetweenImports = getLinesBetween.getLinesBetween(
|
|
457
|
-
sourceCode,
|
|
458
|
-
nodesToFix.at(i),
|
|
459
|
-
nodesToFix.at(i + 1),
|
|
460
|
-
)
|
|
461
|
-
if (
|
|
462
|
-
(options.newlinesBetween === 'always' &&
|
|
463
|
-
getGroupNumber.getGroupNumber(options.groups, node) ===
|
|
464
|
-
getGroupNumber.getGroupNumber(options.groups, nextNode) &&
|
|
465
|
-
linesBetweenImports !== 0) ||
|
|
466
|
-
(options.newlinesBetween === 'never' &&
|
|
467
|
-
linesBetweenImports > 0)
|
|
468
|
-
) {
|
|
469
|
-
fixes.push(
|
|
470
|
-
fixer.removeRange([
|
|
471
|
-
getNodeRange
|
|
472
|
-
.getNodeRange(nodesToFix.at(i).node, sourceCode)
|
|
473
|
-
.at(1),
|
|
474
|
-
getNodeRange
|
|
475
|
-
.getNodeRange(nodesToFix.at(i + 1).node, sourceCode)
|
|
476
|
-
.at(0) - 1,
|
|
477
|
-
]),
|
|
478
|
-
)
|
|
479
|
-
}
|
|
480
|
-
if (
|
|
481
|
-
options.newlinesBetween === 'always' &&
|
|
482
|
-
getGroupNumber.getGroupNumber(options.groups, node) !==
|
|
483
|
-
getGroupNumber.getGroupNumber(options.groups, nextNode) &&
|
|
484
|
-
linesBetweenImports > 1
|
|
485
|
-
) {
|
|
486
|
-
fixes.push(
|
|
487
|
-
fixer.replaceTextRange(
|
|
488
|
-
[
|
|
489
|
-
getNodeRange
|
|
490
|
-
.getNodeRange(nodesToFix.at(i).node, sourceCode)
|
|
491
|
-
.at(1),
|
|
492
|
-
getNodeRange
|
|
493
|
-
.getNodeRange(nodesToFix.at(i + 1).node, sourceCode)
|
|
494
|
-
.at(0) - 1,
|
|
495
|
-
],
|
|
496
|
-
'\n',
|
|
497
|
-
),
|
|
498
|
-
)
|
|
499
|
-
}
|
|
500
|
-
if (
|
|
501
|
-
options.newlinesBetween === 'always' &&
|
|
502
|
-
getGroupNumber.getGroupNumber(options.groups, node) !==
|
|
503
|
-
getGroupNumber.getGroupNumber(options.groups, nextNode) &&
|
|
504
|
-
linesBetweenImports === 0
|
|
505
|
-
) {
|
|
506
|
-
fixes.push(
|
|
507
|
-
fixer.insertTextAfterRange(
|
|
508
|
-
getNodeRange.getNodeRange(
|
|
509
|
-
nodesToFix.at(i).node,
|
|
510
|
-
sourceCode,
|
|
511
|
-
),
|
|
512
|
-
'\n',
|
|
513
|
-
),
|
|
514
|
-
)
|
|
515
|
-
}
|
|
516
|
-
}
|
|
517
|
-
}
|
|
518
|
-
}
|
|
519
|
-
return fixes
|
|
520
|
-
}
|
|
521
|
-
let splittedNodes = [[]]
|
|
456
|
+
let splitNodes = [[]]
|
|
522
457
|
for (let node of nodes) {
|
|
523
|
-
let lastNode =
|
|
524
|
-
(_a = splittedNodes.at(-1)) == null ? void 0 : _a.at(-1)
|
|
458
|
+
let lastNode = (_a = splitNodes.at(-1)) == null ? void 0 : _a.at(-1)
|
|
525
459
|
if (lastNode && hasContentBetweenNodes(lastNode, node)) {
|
|
526
|
-
|
|
460
|
+
splitNodes.push([node])
|
|
527
461
|
} else {
|
|
528
|
-
|
|
462
|
+
splitNodes.at(-1).push(node)
|
|
529
463
|
}
|
|
530
464
|
}
|
|
531
|
-
for (let nodeList of
|
|
465
|
+
for (let nodeList of splitNodes) {
|
|
466
|
+
let sortedNodes = sortNodesByGroups.sortNodesByGroups(
|
|
467
|
+
nodeList,
|
|
468
|
+
options,
|
|
469
|
+
{
|
|
470
|
+
isNodeIgnored: node => node.isIgnored,
|
|
471
|
+
getGroupCompareOptions: groupNumber => {
|
|
472
|
+
if (options.sortSideEffects) {
|
|
473
|
+
return options
|
|
474
|
+
}
|
|
475
|
+
let group = options.groups[groupNumber]
|
|
476
|
+
return isSideEffectOnlyGroup(group) ? null : options
|
|
477
|
+
},
|
|
478
|
+
},
|
|
479
|
+
)
|
|
532
480
|
pairwise.pairwise(nodeList, (left, right) => {
|
|
533
481
|
let leftNum = getGroupNumber.getGroupNumber(options.groups, left)
|
|
534
482
|
let rightNum = getGroupNumber.getGroupNumber(options.groups, right)
|
|
483
|
+
let indexOfLeft = sortedNodes.indexOf(left)
|
|
484
|
+
let indexOfRight = sortedNodes.indexOf(right)
|
|
485
|
+
let messageIds = []
|
|
486
|
+
if (indexOfLeft > indexOfRight) {
|
|
487
|
+
messageIds.push(
|
|
488
|
+
leftNum !== rightNum
|
|
489
|
+
? 'unexpectedImportsGroupOrder'
|
|
490
|
+
: 'unexpectedImportsOrder',
|
|
491
|
+
)
|
|
492
|
+
}
|
|
535
493
|
let numberOfEmptyLinesBetween = getLinesBetween.getLinesBetween(
|
|
536
494
|
sourceCode,
|
|
537
495
|
left,
|
|
538
496
|
right,
|
|
539
497
|
)
|
|
540
|
-
if (
|
|
541
|
-
!(
|
|
542
|
-
!options.sortSideEffects &&
|
|
543
|
-
isSideEffectImport(left.node) &&
|
|
544
|
-
isSideEffectImport(right.node)
|
|
545
|
-
) &&
|
|
546
|
-
!hasContentBetweenNodes(left, right) &&
|
|
547
|
-
(leftNum > rightNum ||
|
|
548
|
-
(leftNum === rightNum &&
|
|
549
|
-
isPositive.isPositive(compare.compare(left, right, options))))
|
|
550
|
-
) {
|
|
551
|
-
context.report({
|
|
552
|
-
messageId:
|
|
553
|
-
leftNum !== rightNum
|
|
554
|
-
? 'unexpectedImportsGroupOrder'
|
|
555
|
-
: 'unexpectedImportsOrder',
|
|
556
|
-
data: {
|
|
557
|
-
left: left.name,
|
|
558
|
-
leftGroup: left.group,
|
|
559
|
-
right: right.name,
|
|
560
|
-
rightGroup: right.group,
|
|
561
|
-
},
|
|
562
|
-
node: right.node,
|
|
563
|
-
fix: fixer => fix(fixer, nodeList),
|
|
564
|
-
})
|
|
565
|
-
}
|
|
566
498
|
if (
|
|
567
499
|
options.newlinesBetween === 'never' &&
|
|
568
500
|
numberOfEmptyLinesBetween > 0
|
|
569
501
|
) {
|
|
570
|
-
|
|
571
|
-
messageId: 'extraSpacingBetweenImports',
|
|
572
|
-
data: {
|
|
573
|
-
left: left.name,
|
|
574
|
-
right: right.name,
|
|
575
|
-
},
|
|
576
|
-
node: right.node,
|
|
577
|
-
fix: fixer => fix(fixer, nodeList),
|
|
578
|
-
})
|
|
502
|
+
messageIds.push('extraSpacingBetweenImports')
|
|
579
503
|
}
|
|
580
504
|
if (options.newlinesBetween === 'always') {
|
|
581
505
|
if (leftNum < rightNum && numberOfEmptyLinesBetween === 0) {
|
|
582
|
-
|
|
583
|
-
messageId: 'missedSpacingBetweenImports',
|
|
584
|
-
data: {
|
|
585
|
-
left: left.name,
|
|
586
|
-
right: right.name,
|
|
587
|
-
},
|
|
588
|
-
node: right.node,
|
|
589
|
-
fix: fixer => fix(fixer, nodeList),
|
|
590
|
-
})
|
|
506
|
+
messageIds.push('missedSpacingBetweenImports')
|
|
591
507
|
} else if (
|
|
592
508
|
numberOfEmptyLinesBetween > 1 ||
|
|
593
509
|
(leftNum === rightNum && numberOfEmptyLinesBetween > 0)
|
|
594
510
|
) {
|
|
595
|
-
|
|
596
|
-
messageId: 'extraSpacingBetweenImports',
|
|
597
|
-
data: {
|
|
598
|
-
left: left.name,
|
|
599
|
-
right: right.name,
|
|
600
|
-
},
|
|
601
|
-
node: right.node,
|
|
602
|
-
fix: fixer => fix(fixer, nodeList),
|
|
603
|
-
})
|
|
511
|
+
messageIds.push('extraSpacingBetweenImports')
|
|
604
512
|
}
|
|
605
513
|
}
|
|
514
|
+
for (let messageId of messageIds) {
|
|
515
|
+
context.report({
|
|
516
|
+
messageId,
|
|
517
|
+
data: {
|
|
518
|
+
left: left.name,
|
|
519
|
+
leftGroup: left.group,
|
|
520
|
+
right: right.name,
|
|
521
|
+
rightGroup: right.group,
|
|
522
|
+
},
|
|
523
|
+
node: right.node,
|
|
524
|
+
fix: fixer => {
|
|
525
|
+
let newlinesFixes = []
|
|
526
|
+
for (let max = sortedNodes.length, i = 0; i < max; i++) {
|
|
527
|
+
let node = sortedNodes.at(i)
|
|
528
|
+
let nextNode = sortedNodes.at(i + 1)
|
|
529
|
+
if (options.newlinesBetween === 'ignore' || !nextNode) {
|
|
530
|
+
continue
|
|
531
|
+
}
|
|
532
|
+
let nodeGroupNumber = getGroupNumber.getGroupNumber(
|
|
533
|
+
options.groups,
|
|
534
|
+
node,
|
|
535
|
+
)
|
|
536
|
+
let nextNodeGroupNumber = getGroupNumber.getGroupNumber(
|
|
537
|
+
options.groups,
|
|
538
|
+
nextNode,
|
|
539
|
+
)
|
|
540
|
+
let currentNodeRange = getNodeRange.getNodeRange(
|
|
541
|
+
nodeList.at(i).node,
|
|
542
|
+
sourceCode,
|
|
543
|
+
options,
|
|
544
|
+
)
|
|
545
|
+
let nextNodeRange =
|
|
546
|
+
getNodeRange
|
|
547
|
+
.getNodeRange(
|
|
548
|
+
nodeList.at(i + 1).node,
|
|
549
|
+
sourceCode,
|
|
550
|
+
options,
|
|
551
|
+
)
|
|
552
|
+
.at(0) - 1
|
|
553
|
+
let linesBetweenImports = getLinesBetween.getLinesBetween(
|
|
554
|
+
sourceCode,
|
|
555
|
+
nodeList.at(i),
|
|
556
|
+
nodeList.at(i + 1),
|
|
557
|
+
)
|
|
558
|
+
if (
|
|
559
|
+
(options.newlinesBetween === 'always' &&
|
|
560
|
+
nodeGroupNumber === nextNodeGroupNumber &&
|
|
561
|
+
linesBetweenImports !== 0) ||
|
|
562
|
+
(options.newlinesBetween === 'never' &&
|
|
563
|
+
linesBetweenImports > 0)
|
|
564
|
+
) {
|
|
565
|
+
newlinesFixes.push(
|
|
566
|
+
fixer.removeRange([
|
|
567
|
+
currentNodeRange.at(1),
|
|
568
|
+
nextNodeRange,
|
|
569
|
+
]),
|
|
570
|
+
)
|
|
571
|
+
}
|
|
572
|
+
if (
|
|
573
|
+
options.newlinesBetween === 'always' &&
|
|
574
|
+
nodeGroupNumber !== nextNodeGroupNumber
|
|
575
|
+
) {
|
|
576
|
+
if (linesBetweenImports > 1) {
|
|
577
|
+
newlinesFixes.push(
|
|
578
|
+
fixer.replaceTextRange(
|
|
579
|
+
[currentNodeRange.at(1), nextNodeRange],
|
|
580
|
+
'\n',
|
|
581
|
+
),
|
|
582
|
+
)
|
|
583
|
+
} else if (linesBetweenImports === 0) {
|
|
584
|
+
newlinesFixes.push(
|
|
585
|
+
fixer.insertTextAfterRange(currentNodeRange, '\n'),
|
|
586
|
+
)
|
|
587
|
+
}
|
|
588
|
+
}
|
|
589
|
+
}
|
|
590
|
+
return [
|
|
591
|
+
...makeFixes.makeFixes(
|
|
592
|
+
fixer,
|
|
593
|
+
nodeList,
|
|
594
|
+
sortedNodes,
|
|
595
|
+
sourceCode,
|
|
596
|
+
),
|
|
597
|
+
...newlinesFixes,
|
|
598
|
+
]
|
|
599
|
+
},
|
|
600
|
+
})
|
|
601
|
+
}
|
|
606
602
|
})
|
|
607
603
|
}
|
|
608
604
|
},
|