@vinicunca/eslint-config 2.15.7 → 3.0.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 CHANGED
@@ -1466,31 +1466,31 @@ interface RuleOptions {
1466
1466
  */
1467
1467
  'logical-assignment-operators'?: Linter.RuleEntry<LogicalAssignmentOperators>
1468
1468
  /**
1469
- * Require languages for fenced code blocks.
1469
+ * Require languages for fenced code blocks
1470
1470
  */
1471
1471
  'markdown/fenced-code-language'?: Linter.RuleEntry<MarkdownFencedCodeLanguage>
1472
1472
  /**
1473
- * Enforce heading levels increment by one.
1473
+ * Enforce heading levels increment by one
1474
1474
  */
1475
1475
  'markdown/heading-increment'?: Linter.RuleEntry<[]>
1476
1476
  /**
1477
- * Disallow duplicate headings in the same document.
1477
+ * Disallow duplicate headings in the same document
1478
1478
  */
1479
1479
  'markdown/no-duplicate-headings'?: Linter.RuleEntry<[]>
1480
1480
  /**
1481
- * Disallow empty links.
1481
+ * Disallow empty links
1482
1482
  */
1483
1483
  'markdown/no-empty-links'?: Linter.RuleEntry<[]>
1484
1484
  /**
1485
- * Disallow HTML tags.
1485
+ * Disallow HTML tags
1486
1486
  */
1487
1487
  'markdown/no-html'?: Linter.RuleEntry<MarkdownNoHtml>
1488
1488
  /**
1489
- * Disallow invalid label references.
1489
+ * Disallow invalid label references
1490
1490
  */
1491
1491
  'markdown/no-invalid-label-refs'?: Linter.RuleEntry<[]>
1492
1492
  /**
1493
- * Disallow missing label references.
1493
+ * Disallow missing label references
1494
1494
  */
1495
1495
  'markdown/no-missing-label-refs'?: Linter.RuleEntry<[]>
1496
1496
  /**
@@ -11833,11 +11833,15 @@ type PaddingLineBetweenStatements = {
11833
11833
  // ----- perfectionist/sort-array-includes -----
11834
11834
  type PerfectionistSortArrayIncludes = {
11835
11835
 
11836
- partitionByComment?: (string[] | boolean | string | {
11837
- block?: (string[] | boolean | string)
11838
- line?: (string[] | boolean | string)
11839
- [k: string]: unknown | undefined
11840
- })
11836
+ specialCharacters?: ("remove" | "trim" | "keep")
11837
+
11838
+ ignoreCase?: boolean
11839
+
11840
+ alphabet?: string
11841
+
11842
+ locales?: (string | string[])
11843
+
11844
+ order?: ("asc" | "desc")
11841
11845
 
11842
11846
  groupKind?: ("mixed" | "literals-first" | "spreads-first")
11843
11847
 
@@ -11876,34 +11880,36 @@ type PerfectionistSortArrayIncludes = {
11876
11880
 
11877
11881
  type?: ("alphabetical" | "natural" | "line-length" | "custom" | "unsorted")
11878
11882
 
11879
- partitionByNewLine?: boolean
11880
-
11881
- specialCharacters?: ("remove" | "trim" | "keep")
11882
-
11883
- ignoreCase?: boolean
11883
+ partitionByComment?: (string[] | boolean | string | {
11884
+ block?: (string[] | boolean | string)
11885
+ line?: (string[] | boolean | string)
11886
+ [k: string]: unknown | undefined
11887
+ })
11884
11888
 
11885
- alphabet?: string
11889
+ partitionByNewLine?: boolean
11886
11890
 
11887
- locales?: (string | string[])
11891
+ newlinesBetween?: ("ignore" | "always" | "never")
11888
11892
 
11889
11893
  groups?: (string | string[] | {
11890
11894
 
11891
11895
  newlinesBetween?: ("ignore" | "always" | "never")
11892
11896
  [k: string]: unknown | undefined
11893
11897
  })[]
11894
-
11895
- order?: ("asc" | "desc")
11896
11898
  }[]
11897
11899
  // ----- perfectionist/sort-classes -----
11898
11900
  type PerfectionistSortClasses = []|[{
11899
11901
 
11900
- ignoreCallbackDependenciesPatterns?: string[]
11902
+ specialCharacters?: ("remove" | "trim" | "keep")
11901
11903
 
11902
- partitionByComment?: (string[] | boolean | string | {
11903
- block?: (string[] | boolean | string)
11904
- line?: (string[] | boolean | string)
11905
- [k: string]: unknown | undefined
11906
- })
11904
+ ignoreCase?: boolean
11905
+
11906
+ alphabet?: string
11907
+
11908
+ locales?: (string | string[])
11909
+
11910
+ order?: ("asc" | "desc")
11911
+
11912
+ ignoreCallbackDependenciesPatterns?: string[]
11907
11913
 
11908
11914
  customGroups?: ({
11909
11915
 
@@ -11916,14 +11922,14 @@ type PerfectionistSortClasses = []|[{
11916
11922
  newlinesInside?: ("always" | "never")
11917
11923
  anyOf?: {
11918
11924
 
11919
- elementValuePattern?: string
11920
-
11921
11925
  decoratorNamePattern?: string
11922
11926
 
11923
11927
  modifiers?: ("async" | "protected" | "private" | "public" | "static" | "abstract" | "override" | "readonly" | "decorated" | "declare" | "optional")[]
11924
11928
 
11925
11929
  selector?: ("accessor-property" | "index-signature" | "constructor" | "static-block" | "get-method" | "set-method" | "function-property" | "property" | "method")
11926
11930
 
11931
+ elementValuePattern?: string
11932
+
11927
11933
  elementNamePattern?: string
11928
11934
  }[]
11929
11935
  } | {
@@ -11936,47 +11942,47 @@ type PerfectionistSortClasses = []|[{
11936
11942
 
11937
11943
  newlinesInside?: ("always" | "never")
11938
11944
 
11939
- elementValuePattern?: string
11940
-
11941
11945
  decoratorNamePattern?: string
11942
11946
 
11943
11947
  modifiers?: ("async" | "protected" | "private" | "public" | "static" | "abstract" | "override" | "readonly" | "decorated" | "declare" | "optional")[]
11944
11948
 
11945
11949
  selector?: ("accessor-property" | "index-signature" | "constructor" | "static-block" | "get-method" | "set-method" | "function-property" | "property" | "method")
11946
11950
 
11951
+ elementValuePattern?: string
11952
+
11947
11953
  elementNamePattern?: string
11948
11954
  })[]
11949
11955
 
11950
- partitionByNewLine?: boolean
11956
+ partitionByComment?: (string[] | boolean | string | {
11957
+ block?: (string[] | boolean | string)
11958
+ line?: (string[] | boolean | string)
11959
+ [k: string]: unknown | undefined
11960
+ })
11951
11961
 
11952
- specialCharacters?: ("remove" | "trim" | "keep")
11962
+ partitionByNewLine?: boolean
11953
11963
 
11954
11964
  newlinesBetween?: ("ignore" | "always" | "never")
11955
11965
 
11956
- ignoreCase?: boolean
11957
-
11958
- alphabet?: string
11959
-
11960
11966
  type?: ("alphabetical" | "natural" | "line-length" | "custom")
11961
11967
 
11962
- locales?: (string | string[])
11963
-
11964
11968
  groups?: (string | string[] | {
11965
11969
 
11966
11970
  newlinesBetween?: ("ignore" | "always" | "never")
11967
11971
  [k: string]: unknown | undefined
11968
11972
  })[]
11969
-
11970
- order?: ("asc" | "desc")
11971
11973
  }]
11972
11974
  // ----- perfectionist/sort-decorators -----
11973
11975
  type PerfectionistSortDecorators = []|[{
11974
11976
 
11975
- partitionByComment?: (string[] | boolean | string | {
11976
- block?: (string[] | boolean | string)
11977
- line?: (string[] | boolean | string)
11978
- [k: string]: unknown | undefined
11979
- })
11977
+ specialCharacters?: ("remove" | "trim" | "keep")
11978
+
11979
+ ignoreCase?: boolean
11980
+
11981
+ alphabet?: string
11982
+
11983
+ locales?: (string | string[])
11984
+
11985
+ order?: ("asc" | "desc")
11980
11986
 
11981
11987
  sortOnParameters?: boolean
11982
11988
 
@@ -11988,57 +11994,65 @@ type PerfectionistSortDecorators = []|[{
11988
11994
 
11989
11995
  sortOnClasses?: boolean
11990
11996
 
11991
- specialCharacters?: ("remove" | "trim" | "keep")
11997
+ partitionByComment?: (string[] | boolean | string | {
11998
+ block?: (string[] | boolean | string)
11999
+ line?: (string[] | boolean | string)
12000
+ [k: string]: unknown | undefined
12001
+ })
11992
12002
 
11993
12003
  customGroups?: {
11994
12004
  [k: string]: (string | string[]) | undefined
11995
12005
  }
11996
12006
 
11997
- ignoreCase?: boolean
11998
-
11999
- alphabet?: string
12000
-
12001
12007
  type?: ("alphabetical" | "natural" | "line-length" | "custom")
12002
12008
 
12003
- locales?: (string | string[])
12004
-
12005
12009
  groups?: (string | string[] | {
12006
12010
 
12007
12011
  newlinesBetween?: ("ignore" | "always" | "never")
12008
12012
  [k: string]: unknown | undefined
12009
12013
  })[]
12010
-
12011
- order?: ("asc" | "desc")
12012
12014
  }]
12013
12015
  // ----- perfectionist/sort-enums -----
12014
12016
  type PerfectionistSortEnums = []|[{
12015
12017
 
12018
+ specialCharacters?: ("remove" | "trim" | "keep")
12019
+
12020
+ ignoreCase?: boolean
12021
+
12022
+ alphabet?: string
12023
+
12024
+ locales?: (string | string[])
12025
+
12026
+ order?: ("asc" | "desc")
12027
+
12028
+ forceNumericSort?: boolean
12029
+
12030
+ sortByValue?: boolean
12031
+
12016
12032
  partitionByComment?: (string[] | boolean | string | {
12017
12033
  block?: (string[] | boolean | string)
12018
12034
  line?: (string[] | boolean | string)
12019
12035
  [k: string]: unknown | undefined
12020
12036
  })
12021
12037
 
12022
- forceNumericSort?: boolean
12023
-
12024
- sortByValue?: boolean
12025
-
12026
12038
  partitionByNewLine?: boolean
12027
12039
 
12040
+ type?: ("alphabetical" | "natural" | "line-length" | "custom")
12041
+ }]
12042
+ // ----- perfectionist/sort-exports -----
12043
+ type PerfectionistSortExports = []|[{
12044
+
12028
12045
  specialCharacters?: ("remove" | "trim" | "keep")
12029
12046
 
12030
12047
  ignoreCase?: boolean
12031
12048
 
12032
12049
  alphabet?: string
12033
12050
 
12034
- type?: ("alphabetical" | "natural" | "line-length" | "custom")
12035
-
12036
12051
  locales?: (string | string[])
12037
12052
 
12038
12053
  order?: ("asc" | "desc")
12039
- }]
12040
- // ----- perfectionist/sort-exports -----
12041
- type PerfectionistSortExports = []|[{
12054
+
12055
+ groupKind?: ("mixed" | "values-first" | "types-first")
12042
12056
 
12043
12057
  partitionByComment?: (string[] | boolean | string | {
12044
12058
  block?: (string[] | boolean | string)
@@ -12046,51 +12060,49 @@ type PerfectionistSortExports = []|[{
12046
12060
  [k: string]: unknown | undefined
12047
12061
  })
12048
12062
 
12049
- groupKind?: ("mixed" | "values-first" | "types-first")
12050
-
12051
12063
  partitionByNewLine?: boolean
12052
12064
 
12065
+ type?: ("alphabetical" | "natural" | "line-length" | "custom")
12066
+ }]
12067
+ // ----- perfectionist/sort-heritage-clauses -----
12068
+ type PerfectionistSortHeritageClauses = []|[{
12069
+
12053
12070
  specialCharacters?: ("remove" | "trim" | "keep")
12054
12071
 
12055
12072
  ignoreCase?: boolean
12056
12073
 
12057
12074
  alphabet?: string
12058
12075
 
12059
- type?: ("alphabetical" | "natural" | "line-length" | "custom")
12060
-
12061
12076
  locales?: (string | string[])
12062
12077
 
12063
12078
  order?: ("asc" | "desc")
12064
- }]
12065
- // ----- perfectionist/sort-heritage-clauses -----
12066
- type PerfectionistSortHeritageClauses = []|[{
12067
-
12068
- specialCharacters?: ("remove" | "trim" | "keep")
12069
12079
 
12070
12080
  customGroups?: {
12071
12081
  [k: string]: (string | string[]) | undefined
12072
12082
  }
12073
12083
 
12074
- ignoreCase?: boolean
12075
-
12076
- alphabet?: string
12077
-
12078
12084
  type?: ("alphabetical" | "natural" | "line-length" | "custom")
12079
12085
 
12080
- locales?: (string | string[])
12081
-
12082
12086
  groups?: (string | string[] | {
12083
12087
 
12084
12088
  newlinesBetween?: ("ignore" | "always" | "never")
12085
12089
  [k: string]: unknown | undefined
12086
12090
  })[]
12087
-
12088
- order?: ("asc" | "desc")
12089
12091
  }]
12090
12092
  // ----- perfectionist/sort-imports -----
12091
12093
  type PerfectionistSortImports = []|[_PerfectionistSortImportsSortImports]
12092
12094
  type _PerfectionistSortImportsSortImports = (_PerfectionistSortImportsMaxLineLengthRequiresLineLengthType & {
12093
12095
 
12096
+ specialCharacters?: ("remove" | "trim" | "keep")
12097
+
12098
+ ignoreCase?: boolean
12099
+
12100
+ alphabet?: string
12101
+
12102
+ locales?: (string | string[])
12103
+
12104
+ order?: ("asc" | "desc")
12105
+
12094
12106
  customGroups?: {
12095
12107
 
12096
12108
  value?: {
@@ -12102,12 +12114,6 @@ type _PerfectionistSortImportsSortImports = (_PerfectionistSortImportsMaxLineLen
12102
12114
  }
12103
12115
  }
12104
12116
 
12105
- partitionByComment?: (string[] | boolean | string | {
12106
- block?: (string[] | boolean | string)
12107
- line?: (string[] | boolean | string)
12108
- [k: string]: unknown | undefined
12109
- })
12110
-
12111
12117
  internalPattern?: string[]
12112
12118
 
12113
12119
  maxLineLength?: number
@@ -12118,27 +12124,23 @@ type _PerfectionistSortImportsSortImports = (_PerfectionistSortImportsMaxLineLen
12118
12124
 
12119
12125
  tsconfigRootDir?: string
12120
12126
 
12121
- partitionByNewLine?: boolean
12127
+ partitionByComment?: (string[] | boolean | string | {
12128
+ block?: (string[] | boolean | string)
12129
+ line?: (string[] | boolean | string)
12130
+ [k: string]: unknown | undefined
12131
+ })
12122
12132
 
12123
- specialCharacters?: ("remove" | "trim" | "keep")
12133
+ partitionByNewLine?: boolean
12124
12134
 
12125
12135
  newlinesBetween?: ("ignore" | "always" | "never")
12126
12136
 
12127
- ignoreCase?: boolean
12128
-
12129
- alphabet?: string
12130
-
12131
12137
  type?: ("alphabetical" | "natural" | "line-length" | "custom")
12132
12138
 
12133
- locales?: (string | string[])
12134
-
12135
12139
  groups?: (string | string[] | {
12136
12140
 
12137
12141
  newlinesBetween?: ("ignore" | "always" | "never")
12138
12142
  [k: string]: unknown | undefined
12139
12143
  })[]
12140
-
12141
- order?: ("asc" | "desc")
12142
12144
  })
12143
12145
  type _PerfectionistSortImportsMaxLineLengthRequiresLineLengthType = ({
12144
12146
  [k: string]: unknown | undefined
@@ -12150,17 +12152,21 @@ interface _PerfectionistSortImports_IsLineLength {
12150
12152
  // ----- perfectionist/sort-interfaces -----
12151
12153
  type PerfectionistSortInterfaces = {
12152
12154
 
12155
+ specialCharacters?: ("remove" | "trim" | "keep")
12156
+
12157
+ ignoreCase?: boolean
12158
+
12159
+ alphabet?: string
12160
+
12161
+ locales?: (string | string[])
12162
+
12163
+ order?: ("asc" | "desc")
12164
+
12153
12165
  ignorePattern?: string[]
12154
12166
  useConfigurationIf?: {
12155
12167
  allNamesMatchPattern?: string
12156
12168
  declarationMatchesPattern?: string
12157
12169
  }
12158
-
12159
- partitionByComment?: (string[] | boolean | string | {
12160
- block?: (string[] | boolean | string)
12161
- line?: (string[] | boolean | string)
12162
- [k: string]: unknown | undefined
12163
- })
12164
12170
  customGroups?: ({
12165
12171
  [k: string]: (string | string[]) | undefined
12166
12172
  } | ({
@@ -12201,29 +12207,35 @@ type PerfectionistSortInterfaces = {
12201
12207
 
12202
12208
  type?: ("alphabetical" | "natural" | "line-length" | "custom" | "unsorted")
12203
12209
 
12204
- partitionByNewLine?: boolean
12210
+ partitionByComment?: (string[] | boolean | string | {
12211
+ block?: (string[] | boolean | string)
12212
+ line?: (string[] | boolean | string)
12213
+ [k: string]: unknown | undefined
12214
+ })
12205
12215
 
12206
- specialCharacters?: ("remove" | "trim" | "keep")
12216
+ partitionByNewLine?: boolean
12207
12217
 
12208
12218
  newlinesBetween?: ("ignore" | "always" | "never")
12209
12219
 
12210
- ignoreCase?: boolean
12211
-
12212
- alphabet?: string
12213
-
12214
- locales?: (string | string[])
12215
-
12216
12220
  groups?: (string | string[] | {
12217
12221
 
12218
12222
  newlinesBetween?: ("ignore" | "always" | "never")
12219
12223
  [k: string]: unknown | undefined
12220
12224
  })[]
12221
-
12222
- order?: ("asc" | "desc")
12223
12225
  }[]
12224
12226
  // ----- perfectionist/sort-intersection-types -----
12225
12227
  type PerfectionistSortIntersectionTypes = []|[{
12226
12228
 
12229
+ specialCharacters?: ("remove" | "trim" | "keep")
12230
+
12231
+ ignoreCase?: boolean
12232
+
12233
+ alphabet?: string
12234
+
12235
+ locales?: (string | string[])
12236
+
12237
+ order?: ("asc" | "desc")
12238
+
12227
12239
  partitionByComment?: (string[] | boolean | string | {
12228
12240
  block?: (string[] | boolean | string)
12229
12241
  line?: (string[] | boolean | string)
@@ -12232,55 +12244,88 @@ type PerfectionistSortIntersectionTypes = []|[{
12232
12244
 
12233
12245
  partitionByNewLine?: boolean
12234
12246
 
12235
- specialCharacters?: ("remove" | "trim" | "keep")
12236
-
12237
12247
  newlinesBetween?: ("ignore" | "always" | "never")
12238
12248
 
12239
- ignoreCase?: boolean
12240
-
12241
- alphabet?: string
12242
-
12243
12249
  type?: ("alphabetical" | "natural" | "line-length" | "custom")
12244
12250
 
12245
- locales?: (string | string[])
12246
-
12247
12251
  groups?: (string | string[] | {
12248
12252
 
12249
12253
  newlinesBetween?: ("ignore" | "always" | "never")
12250
12254
  [k: string]: unknown | undefined
12251
12255
  })[]
12252
-
12253
- order?: ("asc" | "desc")
12254
12256
  }]
12255
12257
  // ----- perfectionist/sort-jsx-props -----
12256
12258
  type PerfectionistSortJsxProps = []|[{
12257
12259
 
12260
+ specialCharacters?: ("remove" | "trim" | "keep")
12261
+
12262
+ ignoreCase?: boolean
12263
+
12264
+ alphabet?: string
12265
+
12266
+ locales?: (string | string[])
12267
+
12268
+ order?: ("asc" | "desc")
12269
+
12258
12270
  ignorePattern?: string[]
12259
12271
 
12260
- specialCharacters?: ("remove" | "trim" | "keep")
12272
+ partitionByNewLine?: boolean
12273
+
12274
+ newlinesBetween?: ("ignore" | "always" | "never")
12261
12275
 
12262
12276
  customGroups?: {
12263
12277
  [k: string]: (string | string[]) | undefined
12264
12278
  }
12265
12279
 
12266
- ignoreCase?: boolean
12267
-
12268
- alphabet?: string
12269
-
12270
12280
  type?: ("alphabetical" | "natural" | "line-length" | "custom")
12271
12281
 
12272
- locales?: (string | string[])
12273
-
12274
12282
  groups?: (string | string[] | {
12275
12283
 
12276
12284
  newlinesBetween?: ("ignore" | "always" | "never")
12277
12285
  [k: string]: unknown | undefined
12278
12286
  })[]
12279
-
12280
- order?: ("asc" | "desc")
12281
12287
  }]
12282
12288
  // ----- perfectionist/sort-maps -----
12283
- type PerfectionistSortMaps = []|[{
12289
+ type PerfectionistSortMaps = {
12290
+
12291
+ specialCharacters?: ("remove" | "trim" | "keep")
12292
+
12293
+ ignoreCase?: boolean
12294
+
12295
+ alphabet?: string
12296
+
12297
+ locales?: (string | string[])
12298
+
12299
+ order?: ("asc" | "desc")
12300
+
12301
+ customGroups?: ({
12302
+
12303
+ groupName?: string
12304
+
12305
+ type?: ("alphabetical" | "line-length" | "natural" | "unsorted")
12306
+
12307
+ order?: ("desc" | "asc")
12308
+
12309
+ newlinesInside?: ("always" | "never")
12310
+ anyOf?: {
12311
+
12312
+ elementNamePattern?: string
12313
+ }[]
12314
+ } | {
12315
+
12316
+ groupName?: string
12317
+
12318
+ type?: ("alphabetical" | "line-length" | "natural" | "unsorted")
12319
+
12320
+ order?: ("desc" | "asc")
12321
+
12322
+ newlinesInside?: ("always" | "never")
12323
+
12324
+ elementNamePattern?: string
12325
+ })[]
12326
+ useConfigurationIf?: {
12327
+ allNamesMatchPattern?: string
12328
+ }
12284
12329
 
12285
12330
  partitionByComment?: (string[] | boolean | string | {
12286
12331
  block?: (string[] | boolean | string)
@@ -12290,26 +12335,28 @@ type PerfectionistSortMaps = []|[{
12290
12335
 
12291
12336
  partitionByNewLine?: boolean
12292
12337
 
12338
+ newlinesBetween?: ("ignore" | "always" | "never")
12339
+
12340
+ type?: ("alphabetical" | "natural" | "line-length" | "custom")
12341
+
12342
+ groups?: (string | string[] | {
12343
+
12344
+ newlinesBetween?: ("ignore" | "always" | "never")
12345
+ [k: string]: unknown | undefined
12346
+ })[]
12347
+ }[]
12348
+ // ----- perfectionist/sort-modules -----
12349
+ type PerfectionistSortModules = []|[{
12350
+
12293
12351
  specialCharacters?: ("remove" | "trim" | "keep")
12294
12352
 
12295
12353
  ignoreCase?: boolean
12296
12354
 
12297
12355
  alphabet?: string
12298
12356
 
12299
- type?: ("alphabetical" | "natural" | "line-length" | "custom")
12300
-
12301
12357
  locales?: (string | string[])
12302
12358
 
12303
12359
  order?: ("asc" | "desc")
12304
- }]
12305
- // ----- perfectionist/sort-modules -----
12306
- type PerfectionistSortModules = []|[{
12307
-
12308
- partitionByComment?: (string[] | boolean | string | {
12309
- block?: (string[] | boolean | string)
12310
- line?: (string[] | boolean | string)
12311
- [k: string]: unknown | undefined
12312
- })
12313
12360
 
12314
12361
  customGroups?: ({
12315
12362
 
@@ -12349,55 +12396,65 @@ type PerfectionistSortModules = []|[{
12349
12396
  elementNamePattern?: string
12350
12397
  })[]
12351
12398
 
12352
- partitionByNewLine?: boolean
12399
+ partitionByComment?: (string[] | boolean | string | {
12400
+ block?: (string[] | boolean | string)
12401
+ line?: (string[] | boolean | string)
12402
+ [k: string]: unknown | undefined
12403
+ })
12353
12404
 
12354
- specialCharacters?: ("remove" | "trim" | "keep")
12405
+ partitionByNewLine?: boolean
12355
12406
 
12356
12407
  newlinesBetween?: ("ignore" | "always" | "never")
12357
12408
 
12358
- ignoreCase?: boolean
12359
-
12360
- alphabet?: string
12361
-
12362
12409
  type?: ("alphabetical" | "natural" | "line-length" | "custom")
12363
12410
 
12364
- locales?: (string | string[])
12365
-
12366
12411
  groups?: (string | string[] | {
12367
12412
 
12368
12413
  newlinesBetween?: ("ignore" | "always" | "never")
12369
12414
  [k: string]: unknown | undefined
12370
12415
  })[]
12371
-
12372
- order?: ("asc" | "desc")
12373
12416
  }]
12374
12417
  // ----- perfectionist/sort-named-exports -----
12375
12418
  type PerfectionistSortNamedExports = []|[{
12376
12419
 
12420
+ specialCharacters?: ("remove" | "trim" | "keep")
12421
+
12422
+ ignoreCase?: boolean
12423
+
12424
+ alphabet?: string
12425
+
12426
+ locales?: (string | string[])
12427
+
12428
+ order?: ("asc" | "desc")
12429
+
12430
+ groupKind?: ("mixed" | "values-first" | "types-first")
12431
+
12377
12432
  partitionByComment?: (string[] | boolean | string | {
12378
12433
  block?: (string[] | boolean | string)
12379
12434
  line?: (string[] | boolean | string)
12380
12435
  [k: string]: unknown | undefined
12381
12436
  })
12382
12437
 
12383
- groupKind?: ("mixed" | "values-first" | "types-first")
12384
-
12385
12438
  partitionByNewLine?: boolean
12386
12439
 
12440
+ type?: ("alphabetical" | "natural" | "line-length" | "custom")
12441
+ }]
12442
+ // ----- perfectionist/sort-named-imports -----
12443
+ type PerfectionistSortNamedImports = []|[{
12444
+
12387
12445
  specialCharacters?: ("remove" | "trim" | "keep")
12388
12446
 
12389
12447
  ignoreCase?: boolean
12390
12448
 
12391
12449
  alphabet?: string
12392
12450
 
12393
- type?: ("alphabetical" | "natural" | "line-length" | "custom")
12394
-
12395
12451
  locales?: (string | string[])
12396
12452
 
12397
12453
  order?: ("asc" | "desc")
12398
- }]
12399
- // ----- perfectionist/sort-named-imports -----
12400
- type PerfectionistSortNamedImports = []|[{
12454
+
12455
+ groupKind?: ("mixed" | "values-first" | "types-first")
12456
+
12457
+ ignoreAlias?: boolean
12401
12458
 
12402
12459
  partitionByComment?: (string[] | boolean | string | {
12403
12460
  block?: (string[] | boolean | string)
@@ -12405,38 +12462,28 @@ type PerfectionistSortNamedImports = []|[{
12405
12462
  [k: string]: unknown | undefined
12406
12463
  })
12407
12464
 
12408
- groupKind?: ("mixed" | "values-first" | "types-first")
12409
-
12410
- ignoreAlias?: boolean
12411
-
12412
12465
  partitionByNewLine?: boolean
12413
12466
 
12467
+ type?: ("alphabetical" | "natural" | "line-length" | "custom")
12468
+ }]
12469
+ // ----- perfectionist/sort-object-types -----
12470
+ type PerfectionistSortObjectTypes = {
12471
+
12414
12472
  specialCharacters?: ("remove" | "trim" | "keep")
12415
12473
 
12416
12474
  ignoreCase?: boolean
12417
12475
 
12418
12476
  alphabet?: string
12419
12477
 
12420
- type?: ("alphabetical" | "natural" | "line-length" | "custom")
12421
-
12422
12478
  locales?: (string | string[])
12423
12479
 
12424
12480
  order?: ("asc" | "desc")
12425
- }]
12426
- // ----- perfectionist/sort-object-types -----
12427
- type PerfectionistSortObjectTypes = {
12428
12481
 
12429
12482
  ignorePattern?: string[]
12430
12483
  useConfigurationIf?: {
12431
12484
  allNamesMatchPattern?: string
12432
12485
  declarationMatchesPattern?: string
12433
12486
  }
12434
-
12435
- partitionByComment?: (string[] | boolean | string | {
12436
- block?: (string[] | boolean | string)
12437
- line?: (string[] | boolean | string)
12438
- [k: string]: unknown | undefined
12439
- })
12440
12487
  customGroups?: ({
12441
12488
  [k: string]: (string | string[]) | undefined
12442
12489
  } | ({
@@ -12477,29 +12524,35 @@ type PerfectionistSortObjectTypes = {
12477
12524
 
12478
12525
  type?: ("alphabetical" | "natural" | "line-length" | "custom" | "unsorted")
12479
12526
 
12480
- partitionByNewLine?: boolean
12527
+ partitionByComment?: (string[] | boolean | string | {
12528
+ block?: (string[] | boolean | string)
12529
+ line?: (string[] | boolean | string)
12530
+ [k: string]: unknown | undefined
12531
+ })
12481
12532
 
12482
- specialCharacters?: ("remove" | "trim" | "keep")
12533
+ partitionByNewLine?: boolean
12483
12534
 
12484
12535
  newlinesBetween?: ("ignore" | "always" | "never")
12485
12536
 
12486
- ignoreCase?: boolean
12487
-
12488
- alphabet?: string
12489
-
12490
- locales?: (string | string[])
12491
-
12492
12537
  groups?: (string | string[] | {
12493
12538
 
12494
12539
  newlinesBetween?: ("ignore" | "always" | "never")
12495
12540
  [k: string]: unknown | undefined
12496
12541
  })[]
12497
-
12498
- order?: ("asc" | "desc")
12499
12542
  }[]
12500
12543
  // ----- perfectionist/sort-objects -----
12501
12544
  type PerfectionistSortObjects = {
12502
12545
 
12546
+ specialCharacters?: ("remove" | "trim" | "keep")
12547
+
12548
+ ignoreCase?: boolean
12549
+
12550
+ alphabet?: string
12551
+
12552
+ locales?: (string | string[])
12553
+
12554
+ order?: ("asc" | "desc")
12555
+
12503
12556
  destructuredObjects?: (boolean | {
12504
12557
 
12505
12558
  groups?: boolean
@@ -12510,12 +12563,45 @@ type PerfectionistSortObjects = {
12510
12563
  allNamesMatchPattern?: string
12511
12564
  callingFunctionNamePattern?: string
12512
12565
  }
12513
-
12514
- partitionByComment?: (string[] | boolean | string | {
12515
- block?: (string[] | boolean | string)
12516
- line?: (string[] | boolean | string)
12517
- [k: string]: unknown | undefined
12518
- })
12566
+ customGroups?: ({
12567
+ [k: string]: (string | string[]) | undefined
12568
+ } | ({
12569
+
12570
+ groupName?: string
12571
+
12572
+ type?: ("alphabetical" | "line-length" | "natural" | "unsorted")
12573
+
12574
+ order?: ("desc" | "asc")
12575
+
12576
+ newlinesInside?: ("always" | "never")
12577
+ anyOf?: {
12578
+
12579
+ modifiers?: ("optional" | "required" | "multiline")[]
12580
+
12581
+ selector?: ("member" | "method" | "multiline" | "property")
12582
+
12583
+ elementValuePattern?: string
12584
+
12585
+ elementNamePattern?: string
12586
+ }[]
12587
+ } | {
12588
+
12589
+ groupName?: string
12590
+
12591
+ type?: ("alphabetical" | "line-length" | "natural" | "unsorted")
12592
+
12593
+ order?: ("desc" | "asc")
12594
+
12595
+ newlinesInside?: ("always" | "never")
12596
+
12597
+ modifiers?: ("optional" | "required" | "multiline")[]
12598
+
12599
+ selector?: ("member" | "method" | "multiline" | "property")
12600
+
12601
+ elementValuePattern?: string
12602
+
12603
+ elementNamePattern?: string
12604
+ })[])
12519
12605
 
12520
12606
  destructureOnly?: boolean
12521
12607
 
@@ -12525,38 +12611,34 @@ type PerfectionistSortObjects = {
12525
12611
 
12526
12612
  type?: ("alphabetical" | "natural" | "line-length" | "custom" | "unsorted")
12527
12613
 
12528
- partitionByNewLine?: boolean
12614
+ partitionByComment?: (string[] | boolean | string | {
12615
+ block?: (string[] | boolean | string)
12616
+ line?: (string[] | boolean | string)
12617
+ [k: string]: unknown | undefined
12618
+ })
12529
12619
 
12530
- specialCharacters?: ("remove" | "trim" | "keep")
12620
+ partitionByNewLine?: boolean
12531
12621
 
12532
12622
  newlinesBetween?: ("ignore" | "always" | "never")
12533
12623
 
12534
- customGroups?: {
12535
- [k: string]: (string | string[]) | undefined
12536
- }
12537
-
12538
- ignoreCase?: boolean
12539
-
12540
- alphabet?: string
12541
-
12542
- locales?: (string | string[])
12543
-
12544
12624
  groups?: (string | string[] | {
12545
12625
 
12546
12626
  newlinesBetween?: ("ignore" | "always" | "never")
12547
12627
  [k: string]: unknown | undefined
12548
12628
  })[]
12549
-
12550
- order?: ("asc" | "desc")
12551
12629
  }[]
12552
12630
  // ----- perfectionist/sort-sets -----
12553
12631
  type PerfectionistSortSets = {
12554
12632
 
12555
- partitionByComment?: (string[] | boolean | string | {
12556
- block?: (string[] | boolean | string)
12557
- line?: (string[] | boolean | string)
12558
- [k: string]: unknown | undefined
12559
- })
12633
+ specialCharacters?: ("remove" | "trim" | "keep")
12634
+
12635
+ ignoreCase?: boolean
12636
+
12637
+ alphabet?: string
12638
+
12639
+ locales?: (string | string[])
12640
+
12641
+ order?: ("asc" | "desc")
12560
12642
 
12561
12643
  groupKind?: ("mixed" | "literals-first" | "spreads-first")
12562
12644
 
@@ -12595,23 +12677,21 @@ type PerfectionistSortSets = {
12595
12677
 
12596
12678
  type?: ("alphabetical" | "natural" | "line-length" | "custom" | "unsorted")
12597
12679
 
12598
- partitionByNewLine?: boolean
12599
-
12600
- specialCharacters?: ("remove" | "trim" | "keep")
12601
-
12602
- ignoreCase?: boolean
12680
+ partitionByComment?: (string[] | boolean | string | {
12681
+ block?: (string[] | boolean | string)
12682
+ line?: (string[] | boolean | string)
12683
+ [k: string]: unknown | undefined
12684
+ })
12603
12685
 
12604
- alphabet?: string
12686
+ partitionByNewLine?: boolean
12605
12687
 
12606
- locales?: (string | string[])
12688
+ newlinesBetween?: ("ignore" | "always" | "never")
12607
12689
 
12608
12690
  groups?: (string | string[] | {
12609
12691
 
12610
12692
  newlinesBetween?: ("ignore" | "always" | "never")
12611
12693
  [k: string]: unknown | undefined
12612
12694
  })[]
12613
-
12614
- order?: ("asc" | "desc")
12615
12695
  }[]
12616
12696
  // ----- perfectionist/sort-switch-case -----
12617
12697
  type PerfectionistSortSwitchCase = []|[{
@@ -12622,15 +12702,25 @@ type PerfectionistSortSwitchCase = []|[{
12622
12702
 
12623
12703
  alphabet?: string
12624
12704
 
12625
- type?: ("alphabetical" | "natural" | "line-length" | "custom")
12626
-
12627
12705
  locales?: (string | string[])
12628
12706
 
12629
12707
  order?: ("asc" | "desc")
12708
+
12709
+ type?: ("alphabetical" | "natural" | "line-length" | "custom")
12630
12710
  }]
12631
12711
  // ----- perfectionist/sort-union-types -----
12632
12712
  type PerfectionistSortUnionTypes = []|[{
12633
12713
 
12714
+ specialCharacters?: ("remove" | "trim" | "keep")
12715
+
12716
+ ignoreCase?: boolean
12717
+
12718
+ alphabet?: string
12719
+
12720
+ locales?: (string | string[])
12721
+
12722
+ order?: ("asc" | "desc")
12723
+
12634
12724
  partitionByComment?: (string[] | boolean | string | {
12635
12725
  block?: (string[] | boolean | string)
12636
12726
  line?: (string[] | boolean | string)
@@ -12639,48 +12729,38 @@ type PerfectionistSortUnionTypes = []|[{
12639
12729
 
12640
12730
  partitionByNewLine?: boolean
12641
12731
 
12642
- specialCharacters?: ("remove" | "trim" | "keep")
12643
-
12644
12732
  newlinesBetween?: ("ignore" | "always" | "never")
12645
12733
 
12646
- ignoreCase?: boolean
12647
-
12648
- alphabet?: string
12649
-
12650
12734
  type?: ("alphabetical" | "natural" | "line-length" | "custom")
12651
12735
 
12652
- locales?: (string | string[])
12653
-
12654
12736
  groups?: (string | string[] | {
12655
12737
 
12656
12738
  newlinesBetween?: ("ignore" | "always" | "never")
12657
12739
  [k: string]: unknown | undefined
12658
12740
  })[]
12659
-
12660
- order?: ("asc" | "desc")
12661
12741
  }]
12662
12742
  // ----- perfectionist/sort-variable-declarations -----
12663
12743
  type PerfectionistSortVariableDeclarations = []|[{
12664
12744
 
12665
- partitionByComment?: (string[] | boolean | string | {
12666
- block?: (string[] | boolean | string)
12667
- line?: (string[] | boolean | string)
12668
- [k: string]: unknown | undefined
12669
- })
12670
-
12671
- partitionByNewLine?: boolean
12672
-
12673
12745
  specialCharacters?: ("remove" | "trim" | "keep")
12674
12746
 
12675
12747
  ignoreCase?: boolean
12676
12748
 
12677
12749
  alphabet?: string
12678
12750
 
12679
- type?: ("alphabetical" | "natural" | "line-length" | "custom")
12680
-
12681
12751
  locales?: (string | string[])
12682
12752
 
12683
12753
  order?: ("asc" | "desc")
12754
+
12755
+ partitionByComment?: (string[] | boolean | string | {
12756
+ block?: (string[] | boolean | string)
12757
+ line?: (string[] | boolean | string)
12758
+ [k: string]: unknown | undefined
12759
+ })
12760
+
12761
+ partitionByNewLine?: boolean
12762
+
12763
+ type?: ("alphabetical" | "natural" | "line-length" | "custom")
12684
12764
  }]
12685
12765
  // ----- prefer-arrow-callback -----
12686
12766
  type PreferArrowCallback = []|[{
@@ -14361,7 +14441,7 @@ type StyleQuoteProps = ([]|[("always" | "as-needed" | "consistent" | "consistent
14361
14441
  // ----- style/quotes -----
14362
14442
  type StyleQuotes = []|[("single" | "double" | "backtick")]|[("single" | "double" | "backtick"), ("avoid-escape" | {
14363
14443
  avoidEscape?: boolean
14364
- allowTemplateLiterals?: boolean
14444
+ allowTemplateLiterals?: (boolean | ("never" | "avoidEscape" | "always"))
14365
14445
  ignoreStringLiterals?: boolean
14366
14446
  })]
14367
14447
  // ----- style/rest-spread-spacing -----