@lichthagel/eslint-config 1.0.12 → 1.0.13

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
@@ -8003,11 +8003,15 @@ type PaddingLineBetweenStatements = {
8003
8003
  // ----- perfectionist/sort-array-includes -----
8004
8004
  type PerfectionistSortArrayIncludes = {
8005
8005
 
8006
- partitionByComment?: (string[] | boolean | string | {
8007
- block?: (string[] | boolean | string)
8008
- line?: (string[] | boolean | string)
8009
- [k: string]: unknown | undefined
8010
- })
8006
+ specialCharacters?: ("remove" | "trim" | "keep")
8007
+
8008
+ ignoreCase?: boolean
8009
+
8010
+ alphabet?: string
8011
+
8012
+ locales?: (string | string[])
8013
+
8014
+ order?: ("asc" | "desc")
8011
8015
 
8012
8016
  groupKind?: ("mixed" | "literals-first" | "spreads-first")
8013
8017
 
@@ -8046,34 +8050,36 @@ type PerfectionistSortArrayIncludes = {
8046
8050
 
8047
8051
  type?: ("alphabetical" | "natural" | "line-length" | "custom" | "unsorted")
8048
8052
 
8049
- partitionByNewLine?: boolean
8050
-
8051
- specialCharacters?: ("remove" | "trim" | "keep")
8052
-
8053
- ignoreCase?: boolean
8053
+ partitionByComment?: (string[] | boolean | string | {
8054
+ block?: (string[] | boolean | string)
8055
+ line?: (string[] | boolean | string)
8056
+ [k: string]: unknown | undefined
8057
+ })
8054
8058
 
8055
- alphabet?: string
8059
+ partitionByNewLine?: boolean
8056
8060
 
8057
- locales?: (string | string[])
8061
+ newlinesBetween?: ("ignore" | "always" | "never")
8058
8062
 
8059
8063
  groups?: (string | string[] | {
8060
8064
 
8061
8065
  newlinesBetween?: ("ignore" | "always" | "never")
8062
8066
  [k: string]: unknown | undefined
8063
8067
  })[]
8064
-
8065
- order?: ("asc" | "desc")
8066
8068
  }[]
8067
8069
  // ----- perfectionist/sort-classes -----
8068
8070
  type PerfectionistSortClasses = []|[{
8069
8071
 
8070
- ignoreCallbackDependenciesPatterns?: string[]
8072
+ specialCharacters?: ("remove" | "trim" | "keep")
8071
8073
 
8072
- partitionByComment?: (string[] | boolean | string | {
8073
- block?: (string[] | boolean | string)
8074
- line?: (string[] | boolean | string)
8075
- [k: string]: unknown | undefined
8076
- })
8074
+ ignoreCase?: boolean
8075
+
8076
+ alphabet?: string
8077
+
8078
+ locales?: (string | string[])
8079
+
8080
+ order?: ("asc" | "desc")
8081
+
8082
+ ignoreCallbackDependenciesPatterns?: string[]
8077
8083
 
8078
8084
  customGroups?: ({
8079
8085
 
@@ -8086,14 +8092,14 @@ type PerfectionistSortClasses = []|[{
8086
8092
  newlinesInside?: ("always" | "never")
8087
8093
  anyOf?: {
8088
8094
 
8089
- elementValuePattern?: string
8090
-
8091
8095
  decoratorNamePattern?: string
8092
8096
 
8093
8097
  modifiers?: ("async" | "protected" | "private" | "public" | "static" | "abstract" | "override" | "readonly" | "decorated" | "declare" | "optional")[]
8094
8098
 
8095
8099
  selector?: ("accessor-property" | "index-signature" | "constructor" | "static-block" | "get-method" | "set-method" | "function-property" | "property" | "method")
8096
8100
 
8101
+ elementValuePattern?: string
8102
+
8097
8103
  elementNamePattern?: string
8098
8104
  }[]
8099
8105
  } | {
@@ -8106,47 +8112,47 @@ type PerfectionistSortClasses = []|[{
8106
8112
 
8107
8113
  newlinesInside?: ("always" | "never")
8108
8114
 
8109
- elementValuePattern?: string
8110
-
8111
8115
  decoratorNamePattern?: string
8112
8116
 
8113
8117
  modifiers?: ("async" | "protected" | "private" | "public" | "static" | "abstract" | "override" | "readonly" | "decorated" | "declare" | "optional")[]
8114
8118
 
8115
8119
  selector?: ("accessor-property" | "index-signature" | "constructor" | "static-block" | "get-method" | "set-method" | "function-property" | "property" | "method")
8116
8120
 
8121
+ elementValuePattern?: string
8122
+
8117
8123
  elementNamePattern?: string
8118
8124
  })[]
8119
8125
 
8120
- partitionByNewLine?: boolean
8126
+ partitionByComment?: (string[] | boolean | string | {
8127
+ block?: (string[] | boolean | string)
8128
+ line?: (string[] | boolean | string)
8129
+ [k: string]: unknown | undefined
8130
+ })
8121
8131
 
8122
- specialCharacters?: ("remove" | "trim" | "keep")
8132
+ partitionByNewLine?: boolean
8123
8133
 
8124
8134
  newlinesBetween?: ("ignore" | "always" | "never")
8125
8135
 
8126
- ignoreCase?: boolean
8127
-
8128
- alphabet?: string
8129
-
8130
8136
  type?: ("alphabetical" | "natural" | "line-length" | "custom")
8131
8137
 
8132
- locales?: (string | string[])
8133
-
8134
8138
  groups?: (string | string[] | {
8135
8139
 
8136
8140
  newlinesBetween?: ("ignore" | "always" | "never")
8137
8141
  [k: string]: unknown | undefined
8138
8142
  })[]
8139
-
8140
- order?: ("asc" | "desc")
8141
8143
  }]
8142
8144
  // ----- perfectionist/sort-decorators -----
8143
8145
  type PerfectionistSortDecorators = []|[{
8144
8146
 
8145
- partitionByComment?: (string[] | boolean | string | {
8146
- block?: (string[] | boolean | string)
8147
- line?: (string[] | boolean | string)
8148
- [k: string]: unknown | undefined
8149
- })
8147
+ specialCharacters?: ("remove" | "trim" | "keep")
8148
+
8149
+ ignoreCase?: boolean
8150
+
8151
+ alphabet?: string
8152
+
8153
+ locales?: (string | string[])
8154
+
8155
+ order?: ("asc" | "desc")
8150
8156
 
8151
8157
  sortOnParameters?: boolean
8152
8158
 
@@ -8158,57 +8164,65 @@ type PerfectionistSortDecorators = []|[{
8158
8164
 
8159
8165
  sortOnClasses?: boolean
8160
8166
 
8161
- specialCharacters?: ("remove" | "trim" | "keep")
8167
+ partitionByComment?: (string[] | boolean | string | {
8168
+ block?: (string[] | boolean | string)
8169
+ line?: (string[] | boolean | string)
8170
+ [k: string]: unknown | undefined
8171
+ })
8162
8172
 
8163
8173
  customGroups?: {
8164
8174
  [k: string]: (string | string[]) | undefined
8165
8175
  }
8166
8176
 
8167
- ignoreCase?: boolean
8168
-
8169
- alphabet?: string
8170
-
8171
8177
  type?: ("alphabetical" | "natural" | "line-length" | "custom")
8172
8178
 
8173
- locales?: (string | string[])
8174
-
8175
8179
  groups?: (string | string[] | {
8176
8180
 
8177
8181
  newlinesBetween?: ("ignore" | "always" | "never")
8178
8182
  [k: string]: unknown | undefined
8179
8183
  })[]
8180
-
8181
- order?: ("asc" | "desc")
8182
8184
  }]
8183
8185
  // ----- perfectionist/sort-enums -----
8184
8186
  type PerfectionistSortEnums = []|[{
8185
8187
 
8188
+ specialCharacters?: ("remove" | "trim" | "keep")
8189
+
8190
+ ignoreCase?: boolean
8191
+
8192
+ alphabet?: string
8193
+
8194
+ locales?: (string | string[])
8195
+
8196
+ order?: ("asc" | "desc")
8197
+
8198
+ forceNumericSort?: boolean
8199
+
8200
+ sortByValue?: boolean
8201
+
8186
8202
  partitionByComment?: (string[] | boolean | string | {
8187
8203
  block?: (string[] | boolean | string)
8188
8204
  line?: (string[] | boolean | string)
8189
8205
  [k: string]: unknown | undefined
8190
8206
  })
8191
8207
 
8192
- forceNumericSort?: boolean
8193
-
8194
- sortByValue?: boolean
8195
-
8196
8208
  partitionByNewLine?: boolean
8197
8209
 
8210
+ type?: ("alphabetical" | "natural" | "line-length" | "custom")
8211
+ }]
8212
+ // ----- perfectionist/sort-exports -----
8213
+ type PerfectionistSortExports = []|[{
8214
+
8198
8215
  specialCharacters?: ("remove" | "trim" | "keep")
8199
8216
 
8200
8217
  ignoreCase?: boolean
8201
8218
 
8202
8219
  alphabet?: string
8203
8220
 
8204
- type?: ("alphabetical" | "natural" | "line-length" | "custom")
8205
-
8206
8221
  locales?: (string | string[])
8207
8222
 
8208
8223
  order?: ("asc" | "desc")
8209
- }]
8210
- // ----- perfectionist/sort-exports -----
8211
- type PerfectionistSortExports = []|[{
8224
+
8225
+ groupKind?: ("mixed" | "values-first" | "types-first")
8212
8226
 
8213
8227
  partitionByComment?: (string[] | boolean | string | {
8214
8228
  block?: (string[] | boolean | string)
@@ -8216,51 +8230,49 @@ type PerfectionistSortExports = []|[{
8216
8230
  [k: string]: unknown | undefined
8217
8231
  })
8218
8232
 
8219
- groupKind?: ("mixed" | "values-first" | "types-first")
8220
-
8221
8233
  partitionByNewLine?: boolean
8222
8234
 
8235
+ type?: ("alphabetical" | "natural" | "line-length" | "custom")
8236
+ }]
8237
+ // ----- perfectionist/sort-heritage-clauses -----
8238
+ type PerfectionistSortHeritageClauses = []|[{
8239
+
8223
8240
  specialCharacters?: ("remove" | "trim" | "keep")
8224
8241
 
8225
8242
  ignoreCase?: boolean
8226
8243
 
8227
8244
  alphabet?: string
8228
8245
 
8229
- type?: ("alphabetical" | "natural" | "line-length" | "custom")
8230
-
8231
8246
  locales?: (string | string[])
8232
8247
 
8233
8248
  order?: ("asc" | "desc")
8234
- }]
8235
- // ----- perfectionist/sort-heritage-clauses -----
8236
- type PerfectionistSortHeritageClauses = []|[{
8237
-
8238
- specialCharacters?: ("remove" | "trim" | "keep")
8239
8249
 
8240
8250
  customGroups?: {
8241
8251
  [k: string]: (string | string[]) | undefined
8242
8252
  }
8243
8253
 
8244
- ignoreCase?: boolean
8245
-
8246
- alphabet?: string
8247
-
8248
8254
  type?: ("alphabetical" | "natural" | "line-length" | "custom")
8249
8255
 
8250
- locales?: (string | string[])
8251
-
8252
8256
  groups?: (string | string[] | {
8253
8257
 
8254
8258
  newlinesBetween?: ("ignore" | "always" | "never")
8255
8259
  [k: string]: unknown | undefined
8256
8260
  })[]
8257
-
8258
- order?: ("asc" | "desc")
8259
8261
  }]
8260
8262
  // ----- perfectionist/sort-imports -----
8261
8263
  type PerfectionistSortImports = []|[_PerfectionistSortImportsSortImports]
8262
8264
  type _PerfectionistSortImportsSortImports = (_PerfectionistSortImportsMaxLineLengthRequiresLineLengthType & {
8263
8265
 
8266
+ specialCharacters?: ("remove" | "trim" | "keep")
8267
+
8268
+ ignoreCase?: boolean
8269
+
8270
+ alphabet?: string
8271
+
8272
+ locales?: (string | string[])
8273
+
8274
+ order?: ("asc" | "desc")
8275
+
8264
8276
  customGroups?: {
8265
8277
 
8266
8278
  value?: {
@@ -8272,12 +8284,6 @@ type _PerfectionistSortImportsSortImports = (_PerfectionistSortImportsMaxLineLen
8272
8284
  }
8273
8285
  }
8274
8286
 
8275
- partitionByComment?: (string[] | boolean | string | {
8276
- block?: (string[] | boolean | string)
8277
- line?: (string[] | boolean | string)
8278
- [k: string]: unknown | undefined
8279
- })
8280
-
8281
8287
  internalPattern?: string[]
8282
8288
 
8283
8289
  maxLineLength?: number
@@ -8288,27 +8294,23 @@ type _PerfectionistSortImportsSortImports = (_PerfectionistSortImportsMaxLineLen
8288
8294
 
8289
8295
  tsconfigRootDir?: string
8290
8296
 
8291
- partitionByNewLine?: boolean
8297
+ partitionByComment?: (string[] | boolean | string | {
8298
+ block?: (string[] | boolean | string)
8299
+ line?: (string[] | boolean | string)
8300
+ [k: string]: unknown | undefined
8301
+ })
8292
8302
 
8293
- specialCharacters?: ("remove" | "trim" | "keep")
8303
+ partitionByNewLine?: boolean
8294
8304
 
8295
8305
  newlinesBetween?: ("ignore" | "always" | "never")
8296
8306
 
8297
- ignoreCase?: boolean
8298
-
8299
- alphabet?: string
8300
-
8301
8307
  type?: ("alphabetical" | "natural" | "line-length" | "custom")
8302
8308
 
8303
- locales?: (string | string[])
8304
-
8305
8309
  groups?: (string | string[] | {
8306
8310
 
8307
8311
  newlinesBetween?: ("ignore" | "always" | "never")
8308
8312
  [k: string]: unknown | undefined
8309
8313
  })[]
8310
-
8311
- order?: ("asc" | "desc")
8312
8314
  })
8313
8315
  type _PerfectionistSortImportsMaxLineLengthRequiresLineLengthType = ({
8314
8316
  [k: string]: unknown | undefined
@@ -8320,17 +8322,21 @@ interface _PerfectionistSortImports_IsLineLength {
8320
8322
  // ----- perfectionist/sort-interfaces -----
8321
8323
  type PerfectionistSortInterfaces = {
8322
8324
 
8325
+ specialCharacters?: ("remove" | "trim" | "keep")
8326
+
8327
+ ignoreCase?: boolean
8328
+
8329
+ alphabet?: string
8330
+
8331
+ locales?: (string | string[])
8332
+
8333
+ order?: ("asc" | "desc")
8334
+
8323
8335
  ignorePattern?: string[]
8324
8336
  useConfigurationIf?: {
8325
8337
  allNamesMatchPattern?: string
8326
8338
  declarationMatchesPattern?: string
8327
8339
  }
8328
-
8329
- partitionByComment?: (string[] | boolean | string | {
8330
- block?: (string[] | boolean | string)
8331
- line?: (string[] | boolean | string)
8332
- [k: string]: unknown | undefined
8333
- })
8334
8340
  customGroups?: ({
8335
8341
  [k: string]: (string | string[]) | undefined
8336
8342
  } | ({
@@ -8371,29 +8377,35 @@ type PerfectionistSortInterfaces = {
8371
8377
 
8372
8378
  type?: ("alphabetical" | "natural" | "line-length" | "custom" | "unsorted")
8373
8379
 
8374
- partitionByNewLine?: boolean
8380
+ partitionByComment?: (string[] | boolean | string | {
8381
+ block?: (string[] | boolean | string)
8382
+ line?: (string[] | boolean | string)
8383
+ [k: string]: unknown | undefined
8384
+ })
8375
8385
 
8376
- specialCharacters?: ("remove" | "trim" | "keep")
8386
+ partitionByNewLine?: boolean
8377
8387
 
8378
8388
  newlinesBetween?: ("ignore" | "always" | "never")
8379
8389
 
8380
- ignoreCase?: boolean
8381
-
8382
- alphabet?: string
8383
-
8384
- locales?: (string | string[])
8385
-
8386
8390
  groups?: (string | string[] | {
8387
8391
 
8388
8392
  newlinesBetween?: ("ignore" | "always" | "never")
8389
8393
  [k: string]: unknown | undefined
8390
8394
  })[]
8391
-
8392
- order?: ("asc" | "desc")
8393
8395
  }[]
8394
8396
  // ----- perfectionist/sort-intersection-types -----
8395
8397
  type PerfectionistSortIntersectionTypes = []|[{
8396
8398
 
8399
+ specialCharacters?: ("remove" | "trim" | "keep")
8400
+
8401
+ ignoreCase?: boolean
8402
+
8403
+ alphabet?: string
8404
+
8405
+ locales?: (string | string[])
8406
+
8407
+ order?: ("asc" | "desc")
8408
+
8397
8409
  partitionByComment?: (string[] | boolean | string | {
8398
8410
  block?: (string[] | boolean | string)
8399
8411
  line?: (string[] | boolean | string)
@@ -8402,55 +8414,88 @@ type PerfectionistSortIntersectionTypes = []|[{
8402
8414
 
8403
8415
  partitionByNewLine?: boolean
8404
8416
 
8405
- specialCharacters?: ("remove" | "trim" | "keep")
8406
-
8407
8417
  newlinesBetween?: ("ignore" | "always" | "never")
8408
8418
 
8409
- ignoreCase?: boolean
8410
-
8411
- alphabet?: string
8412
-
8413
8419
  type?: ("alphabetical" | "natural" | "line-length" | "custom")
8414
8420
 
8415
- locales?: (string | string[])
8416
-
8417
8421
  groups?: (string | string[] | {
8418
8422
 
8419
8423
  newlinesBetween?: ("ignore" | "always" | "never")
8420
8424
  [k: string]: unknown | undefined
8421
8425
  })[]
8422
-
8423
- order?: ("asc" | "desc")
8424
8426
  }]
8425
8427
  // ----- perfectionist/sort-jsx-props -----
8426
8428
  type PerfectionistSortJsxProps = []|[{
8427
8429
 
8430
+ specialCharacters?: ("remove" | "trim" | "keep")
8431
+
8432
+ ignoreCase?: boolean
8433
+
8434
+ alphabet?: string
8435
+
8436
+ locales?: (string | string[])
8437
+
8438
+ order?: ("asc" | "desc")
8439
+
8428
8440
  ignorePattern?: string[]
8429
8441
 
8430
- specialCharacters?: ("remove" | "trim" | "keep")
8442
+ partitionByNewLine?: boolean
8443
+
8444
+ newlinesBetween?: ("ignore" | "always" | "never")
8431
8445
 
8432
8446
  customGroups?: {
8433
8447
  [k: string]: (string | string[]) | undefined
8434
8448
  }
8435
8449
 
8436
- ignoreCase?: boolean
8437
-
8438
- alphabet?: string
8439
-
8440
8450
  type?: ("alphabetical" | "natural" | "line-length" | "custom")
8441
8451
 
8442
- locales?: (string | string[])
8443
-
8444
8452
  groups?: (string | string[] | {
8445
8453
 
8446
8454
  newlinesBetween?: ("ignore" | "always" | "never")
8447
8455
  [k: string]: unknown | undefined
8448
8456
  })[]
8449
-
8450
- order?: ("asc" | "desc")
8451
8457
  }]
8452
8458
  // ----- perfectionist/sort-maps -----
8453
- type PerfectionistSortMaps = []|[{
8459
+ type PerfectionistSortMaps = {
8460
+
8461
+ specialCharacters?: ("remove" | "trim" | "keep")
8462
+
8463
+ ignoreCase?: boolean
8464
+
8465
+ alphabet?: string
8466
+
8467
+ locales?: (string | string[])
8468
+
8469
+ order?: ("asc" | "desc")
8470
+
8471
+ customGroups?: ({
8472
+
8473
+ groupName?: string
8474
+
8475
+ type?: ("alphabetical" | "line-length" | "natural" | "unsorted")
8476
+
8477
+ order?: ("desc" | "asc")
8478
+
8479
+ newlinesInside?: ("always" | "never")
8480
+ anyOf?: {
8481
+
8482
+ elementNamePattern?: string
8483
+ }[]
8484
+ } | {
8485
+
8486
+ groupName?: string
8487
+
8488
+ type?: ("alphabetical" | "line-length" | "natural" | "unsorted")
8489
+
8490
+ order?: ("desc" | "asc")
8491
+
8492
+ newlinesInside?: ("always" | "never")
8493
+
8494
+ elementNamePattern?: string
8495
+ })[]
8496
+ useConfigurationIf?: {
8497
+ allNamesMatchPattern?: string
8498
+ }
8454
8499
 
8455
8500
  partitionByComment?: (string[] | boolean | string | {
8456
8501
  block?: (string[] | boolean | string)
@@ -8460,26 +8505,28 @@ type PerfectionistSortMaps = []|[{
8460
8505
 
8461
8506
  partitionByNewLine?: boolean
8462
8507
 
8508
+ newlinesBetween?: ("ignore" | "always" | "never")
8509
+
8510
+ type?: ("alphabetical" | "natural" | "line-length" | "custom")
8511
+
8512
+ groups?: (string | string[] | {
8513
+
8514
+ newlinesBetween?: ("ignore" | "always" | "never")
8515
+ [k: string]: unknown | undefined
8516
+ })[]
8517
+ }[]
8518
+ // ----- perfectionist/sort-modules -----
8519
+ type PerfectionistSortModules = []|[{
8520
+
8463
8521
  specialCharacters?: ("remove" | "trim" | "keep")
8464
8522
 
8465
8523
  ignoreCase?: boolean
8466
8524
 
8467
8525
  alphabet?: string
8468
8526
 
8469
- type?: ("alphabetical" | "natural" | "line-length" | "custom")
8470
-
8471
8527
  locales?: (string | string[])
8472
8528
 
8473
8529
  order?: ("asc" | "desc")
8474
- }]
8475
- // ----- perfectionist/sort-modules -----
8476
- type PerfectionistSortModules = []|[{
8477
-
8478
- partitionByComment?: (string[] | boolean | string | {
8479
- block?: (string[] | boolean | string)
8480
- line?: (string[] | boolean | string)
8481
- [k: string]: unknown | undefined
8482
- })
8483
8530
 
8484
8531
  customGroups?: ({
8485
8532
 
@@ -8519,55 +8566,65 @@ type PerfectionistSortModules = []|[{
8519
8566
  elementNamePattern?: string
8520
8567
  })[]
8521
8568
 
8522
- partitionByNewLine?: boolean
8569
+ partitionByComment?: (string[] | boolean | string | {
8570
+ block?: (string[] | boolean | string)
8571
+ line?: (string[] | boolean | string)
8572
+ [k: string]: unknown | undefined
8573
+ })
8523
8574
 
8524
- specialCharacters?: ("remove" | "trim" | "keep")
8575
+ partitionByNewLine?: boolean
8525
8576
 
8526
8577
  newlinesBetween?: ("ignore" | "always" | "never")
8527
8578
 
8528
- ignoreCase?: boolean
8529
-
8530
- alphabet?: string
8531
-
8532
8579
  type?: ("alphabetical" | "natural" | "line-length" | "custom")
8533
8580
 
8534
- locales?: (string | string[])
8535
-
8536
8581
  groups?: (string | string[] | {
8537
8582
 
8538
8583
  newlinesBetween?: ("ignore" | "always" | "never")
8539
8584
  [k: string]: unknown | undefined
8540
8585
  })[]
8541
-
8542
- order?: ("asc" | "desc")
8543
8586
  }]
8544
8587
  // ----- perfectionist/sort-named-exports -----
8545
8588
  type PerfectionistSortNamedExports = []|[{
8546
8589
 
8590
+ specialCharacters?: ("remove" | "trim" | "keep")
8591
+
8592
+ ignoreCase?: boolean
8593
+
8594
+ alphabet?: string
8595
+
8596
+ locales?: (string | string[])
8597
+
8598
+ order?: ("asc" | "desc")
8599
+
8600
+ groupKind?: ("mixed" | "values-first" | "types-first")
8601
+
8547
8602
  partitionByComment?: (string[] | boolean | string | {
8548
8603
  block?: (string[] | boolean | string)
8549
8604
  line?: (string[] | boolean | string)
8550
8605
  [k: string]: unknown | undefined
8551
8606
  })
8552
8607
 
8553
- groupKind?: ("mixed" | "values-first" | "types-first")
8554
-
8555
8608
  partitionByNewLine?: boolean
8556
8609
 
8610
+ type?: ("alphabetical" | "natural" | "line-length" | "custom")
8611
+ }]
8612
+ // ----- perfectionist/sort-named-imports -----
8613
+ type PerfectionistSortNamedImports = []|[{
8614
+
8557
8615
  specialCharacters?: ("remove" | "trim" | "keep")
8558
8616
 
8559
8617
  ignoreCase?: boolean
8560
8618
 
8561
8619
  alphabet?: string
8562
8620
 
8563
- type?: ("alphabetical" | "natural" | "line-length" | "custom")
8564
-
8565
8621
  locales?: (string | string[])
8566
8622
 
8567
8623
  order?: ("asc" | "desc")
8568
- }]
8569
- // ----- perfectionist/sort-named-imports -----
8570
- type PerfectionistSortNamedImports = []|[{
8624
+
8625
+ groupKind?: ("mixed" | "values-first" | "types-first")
8626
+
8627
+ ignoreAlias?: boolean
8571
8628
 
8572
8629
  partitionByComment?: (string[] | boolean | string | {
8573
8630
  block?: (string[] | boolean | string)
@@ -8575,38 +8632,28 @@ type PerfectionistSortNamedImports = []|[{
8575
8632
  [k: string]: unknown | undefined
8576
8633
  })
8577
8634
 
8578
- groupKind?: ("mixed" | "values-first" | "types-first")
8579
-
8580
- ignoreAlias?: boolean
8581
-
8582
8635
  partitionByNewLine?: boolean
8583
8636
 
8637
+ type?: ("alphabetical" | "natural" | "line-length" | "custom")
8638
+ }]
8639
+ // ----- perfectionist/sort-object-types -----
8640
+ type PerfectionistSortObjectTypes = {
8641
+
8584
8642
  specialCharacters?: ("remove" | "trim" | "keep")
8585
8643
 
8586
8644
  ignoreCase?: boolean
8587
8645
 
8588
8646
  alphabet?: string
8589
8647
 
8590
- type?: ("alphabetical" | "natural" | "line-length" | "custom")
8591
-
8592
8648
  locales?: (string | string[])
8593
8649
 
8594
8650
  order?: ("asc" | "desc")
8595
- }]
8596
- // ----- perfectionist/sort-object-types -----
8597
- type PerfectionistSortObjectTypes = {
8598
8651
 
8599
8652
  ignorePattern?: string[]
8600
8653
  useConfigurationIf?: {
8601
8654
  allNamesMatchPattern?: string
8602
8655
  declarationMatchesPattern?: string
8603
8656
  }
8604
-
8605
- partitionByComment?: (string[] | boolean | string | {
8606
- block?: (string[] | boolean | string)
8607
- line?: (string[] | boolean | string)
8608
- [k: string]: unknown | undefined
8609
- })
8610
8657
  customGroups?: ({
8611
8658
  [k: string]: (string | string[]) | undefined
8612
8659
  } | ({
@@ -8647,29 +8694,35 @@ type PerfectionistSortObjectTypes = {
8647
8694
 
8648
8695
  type?: ("alphabetical" | "natural" | "line-length" | "custom" | "unsorted")
8649
8696
 
8650
- partitionByNewLine?: boolean
8697
+ partitionByComment?: (string[] | boolean | string | {
8698
+ block?: (string[] | boolean | string)
8699
+ line?: (string[] | boolean | string)
8700
+ [k: string]: unknown | undefined
8701
+ })
8651
8702
 
8652
- specialCharacters?: ("remove" | "trim" | "keep")
8703
+ partitionByNewLine?: boolean
8653
8704
 
8654
8705
  newlinesBetween?: ("ignore" | "always" | "never")
8655
8706
 
8656
- ignoreCase?: boolean
8657
-
8658
- alphabet?: string
8659
-
8660
- locales?: (string | string[])
8661
-
8662
8707
  groups?: (string | string[] | {
8663
8708
 
8664
8709
  newlinesBetween?: ("ignore" | "always" | "never")
8665
8710
  [k: string]: unknown | undefined
8666
8711
  })[]
8667
-
8668
- order?: ("asc" | "desc")
8669
8712
  }[]
8670
8713
  // ----- perfectionist/sort-objects -----
8671
8714
  type PerfectionistSortObjects = {
8672
8715
 
8716
+ specialCharacters?: ("remove" | "trim" | "keep")
8717
+
8718
+ ignoreCase?: boolean
8719
+
8720
+ alphabet?: string
8721
+
8722
+ locales?: (string | string[])
8723
+
8724
+ order?: ("asc" | "desc")
8725
+
8673
8726
  destructuredObjects?: (boolean | {
8674
8727
 
8675
8728
  groups?: boolean
@@ -8680,12 +8733,45 @@ type PerfectionistSortObjects = {
8680
8733
  allNamesMatchPattern?: string
8681
8734
  callingFunctionNamePattern?: string
8682
8735
  }
8683
-
8684
- partitionByComment?: (string[] | boolean | string | {
8685
- block?: (string[] | boolean | string)
8686
- line?: (string[] | boolean | string)
8687
- [k: string]: unknown | undefined
8688
- })
8736
+ customGroups?: ({
8737
+ [k: string]: (string | string[]) | undefined
8738
+ } | ({
8739
+
8740
+ groupName?: string
8741
+
8742
+ type?: ("alphabetical" | "line-length" | "natural" | "unsorted")
8743
+
8744
+ order?: ("desc" | "asc")
8745
+
8746
+ newlinesInside?: ("always" | "never")
8747
+ anyOf?: {
8748
+
8749
+ modifiers?: ("optional" | "required" | "multiline")[]
8750
+
8751
+ selector?: ("member" | "method" | "multiline" | "property")
8752
+
8753
+ elementValuePattern?: string
8754
+
8755
+ elementNamePattern?: string
8756
+ }[]
8757
+ } | {
8758
+
8759
+ groupName?: string
8760
+
8761
+ type?: ("alphabetical" | "line-length" | "natural" | "unsorted")
8762
+
8763
+ order?: ("desc" | "asc")
8764
+
8765
+ newlinesInside?: ("always" | "never")
8766
+
8767
+ modifiers?: ("optional" | "required" | "multiline")[]
8768
+
8769
+ selector?: ("member" | "method" | "multiline" | "property")
8770
+
8771
+ elementValuePattern?: string
8772
+
8773
+ elementNamePattern?: string
8774
+ })[])
8689
8775
 
8690
8776
  destructureOnly?: boolean
8691
8777
 
@@ -8695,38 +8781,34 @@ type PerfectionistSortObjects = {
8695
8781
 
8696
8782
  type?: ("alphabetical" | "natural" | "line-length" | "custom" | "unsorted")
8697
8783
 
8698
- partitionByNewLine?: boolean
8784
+ partitionByComment?: (string[] | boolean | string | {
8785
+ block?: (string[] | boolean | string)
8786
+ line?: (string[] | boolean | string)
8787
+ [k: string]: unknown | undefined
8788
+ })
8699
8789
 
8700
- specialCharacters?: ("remove" | "trim" | "keep")
8790
+ partitionByNewLine?: boolean
8701
8791
 
8702
8792
  newlinesBetween?: ("ignore" | "always" | "never")
8703
8793
 
8704
- customGroups?: {
8705
- [k: string]: (string | string[]) | undefined
8706
- }
8707
-
8708
- ignoreCase?: boolean
8709
-
8710
- alphabet?: string
8711
-
8712
- locales?: (string | string[])
8713
-
8714
8794
  groups?: (string | string[] | {
8715
8795
 
8716
8796
  newlinesBetween?: ("ignore" | "always" | "never")
8717
8797
  [k: string]: unknown | undefined
8718
8798
  })[]
8719
-
8720
- order?: ("asc" | "desc")
8721
8799
  }[]
8722
8800
  // ----- perfectionist/sort-sets -----
8723
8801
  type PerfectionistSortSets = {
8724
8802
 
8725
- partitionByComment?: (string[] | boolean | string | {
8726
- block?: (string[] | boolean | string)
8727
- line?: (string[] | boolean | string)
8728
- [k: string]: unknown | undefined
8729
- })
8803
+ specialCharacters?: ("remove" | "trim" | "keep")
8804
+
8805
+ ignoreCase?: boolean
8806
+
8807
+ alphabet?: string
8808
+
8809
+ locales?: (string | string[])
8810
+
8811
+ order?: ("asc" | "desc")
8730
8812
 
8731
8813
  groupKind?: ("mixed" | "literals-first" | "spreads-first")
8732
8814
 
@@ -8765,23 +8847,21 @@ type PerfectionistSortSets = {
8765
8847
 
8766
8848
  type?: ("alphabetical" | "natural" | "line-length" | "custom" | "unsorted")
8767
8849
 
8768
- partitionByNewLine?: boolean
8769
-
8770
- specialCharacters?: ("remove" | "trim" | "keep")
8771
-
8772
- ignoreCase?: boolean
8850
+ partitionByComment?: (string[] | boolean | string | {
8851
+ block?: (string[] | boolean | string)
8852
+ line?: (string[] | boolean | string)
8853
+ [k: string]: unknown | undefined
8854
+ })
8773
8855
 
8774
- alphabet?: string
8856
+ partitionByNewLine?: boolean
8775
8857
 
8776
- locales?: (string | string[])
8858
+ newlinesBetween?: ("ignore" | "always" | "never")
8777
8859
 
8778
8860
  groups?: (string | string[] | {
8779
8861
 
8780
8862
  newlinesBetween?: ("ignore" | "always" | "never")
8781
8863
  [k: string]: unknown | undefined
8782
8864
  })[]
8783
-
8784
- order?: ("asc" | "desc")
8785
8865
  }[]
8786
8866
  // ----- perfectionist/sort-switch-case -----
8787
8867
  type PerfectionistSortSwitchCase = []|[{
@@ -8792,15 +8872,25 @@ type PerfectionistSortSwitchCase = []|[{
8792
8872
 
8793
8873
  alphabet?: string
8794
8874
 
8795
- type?: ("alphabetical" | "natural" | "line-length" | "custom")
8796
-
8797
8875
  locales?: (string | string[])
8798
8876
 
8799
8877
  order?: ("asc" | "desc")
8878
+
8879
+ type?: ("alphabetical" | "natural" | "line-length" | "custom")
8800
8880
  }]
8801
8881
  // ----- perfectionist/sort-union-types -----
8802
8882
  type PerfectionistSortUnionTypes = []|[{
8803
8883
 
8884
+ specialCharacters?: ("remove" | "trim" | "keep")
8885
+
8886
+ ignoreCase?: boolean
8887
+
8888
+ alphabet?: string
8889
+
8890
+ locales?: (string | string[])
8891
+
8892
+ order?: ("asc" | "desc")
8893
+
8804
8894
  partitionByComment?: (string[] | boolean | string | {
8805
8895
  block?: (string[] | boolean | string)
8806
8896
  line?: (string[] | boolean | string)
@@ -8809,48 +8899,38 @@ type PerfectionistSortUnionTypes = []|[{
8809
8899
 
8810
8900
  partitionByNewLine?: boolean
8811
8901
 
8812
- specialCharacters?: ("remove" | "trim" | "keep")
8813
-
8814
8902
  newlinesBetween?: ("ignore" | "always" | "never")
8815
8903
 
8816
- ignoreCase?: boolean
8817
-
8818
- alphabet?: string
8819
-
8820
8904
  type?: ("alphabetical" | "natural" | "line-length" | "custom")
8821
8905
 
8822
- locales?: (string | string[])
8823
-
8824
8906
  groups?: (string | string[] | {
8825
8907
 
8826
8908
  newlinesBetween?: ("ignore" | "always" | "never")
8827
8909
  [k: string]: unknown | undefined
8828
8910
  })[]
8829
-
8830
- order?: ("asc" | "desc")
8831
8911
  }]
8832
8912
  // ----- perfectionist/sort-variable-declarations -----
8833
8913
  type PerfectionistSortVariableDeclarations = []|[{
8834
8914
 
8835
- partitionByComment?: (string[] | boolean | string | {
8836
- block?: (string[] | boolean | string)
8837
- line?: (string[] | boolean | string)
8838
- [k: string]: unknown | undefined
8839
- })
8840
-
8841
- partitionByNewLine?: boolean
8842
-
8843
8915
  specialCharacters?: ("remove" | "trim" | "keep")
8844
8916
 
8845
8917
  ignoreCase?: boolean
8846
8918
 
8847
8919
  alphabet?: string
8848
8920
 
8849
- type?: ("alphabetical" | "natural" | "line-length" | "custom")
8850
-
8851
8921
  locales?: (string | string[])
8852
8922
 
8853
8923
  order?: ("asc" | "desc")
8924
+
8925
+ partitionByComment?: (string[] | boolean | string | {
8926
+ block?: (string[] | boolean | string)
8927
+ line?: (string[] | boolean | string)
8928
+ [k: string]: unknown | undefined
8929
+ })
8930
+
8931
+ partitionByNewLine?: boolean
8932
+
8933
+ type?: ("alphabetical" | "natural" | "line-length" | "custom")
8854
8934
  }]
8855
8935
  // ----- prefer-arrow-callback -----
8856
8936
  type PreferArrowCallback = []|[{