1 | import { Linter } from "../index";
|
---|
2 |
|
---|
3 | export interface BestPractices extends Linter.RulesRecord {
|
---|
4 | /**
|
---|
5 | * Rule to enforce getter and setter pairs in objects.
|
---|
6 | *
|
---|
7 | * @since 0.22.0
|
---|
8 | * @see https://eslint.org/docs/rules/accessor-pairs
|
---|
9 | */
|
---|
10 | "accessor-pairs": Linter.RuleEntry<
|
---|
11 | [
|
---|
12 | Partial<{
|
---|
13 | /**
|
---|
14 | * @default true
|
---|
15 | */
|
---|
16 | setWithoutGet: boolean;
|
---|
17 | /**
|
---|
18 | * @default false
|
---|
19 | */
|
---|
20 | getWithoutSet: boolean;
|
---|
21 | }>,
|
---|
22 | ]
|
---|
23 | >;
|
---|
24 |
|
---|
25 | /**
|
---|
26 | * Rule to enforce `return` statements in callbacks of array methods.
|
---|
27 | *
|
---|
28 | * @since 2.0.0-alpha-1
|
---|
29 | * @see https://eslint.org/docs/rules/array-callback-return
|
---|
30 | */
|
---|
31 | "array-callback-return": Linter.RuleEntry<
|
---|
32 | [
|
---|
33 | Partial<{
|
---|
34 | /**
|
---|
35 | * @default false
|
---|
36 | */
|
---|
37 | allowImplicit: boolean;
|
---|
38 | }>,
|
---|
39 | ]
|
---|
40 | >;
|
---|
41 |
|
---|
42 | /**
|
---|
43 | * Rule to enforce the use of variables within the scope they are defined.
|
---|
44 | *
|
---|
45 | * @since 0.1.0
|
---|
46 | * @see https://eslint.org/docs/rules/block-scoped-var
|
---|
47 | */
|
---|
48 | "block-scoped-var": Linter.RuleEntry<[]>;
|
---|
49 |
|
---|
50 | /**
|
---|
51 | * Rule to enforce that class methods utilize `this`.
|
---|
52 | *
|
---|
53 | * @since 3.4.0
|
---|
54 | * @see https://eslint.org/docs/rules/class-methods-use-this
|
---|
55 | */
|
---|
56 | "class-methods-use-this": Linter.RuleEntry<
|
---|
57 | [
|
---|
58 | Partial<{
|
---|
59 | exceptMethods: string[];
|
---|
60 | }>,
|
---|
61 | ]
|
---|
62 | >;
|
---|
63 |
|
---|
64 | /**
|
---|
65 | * Rule to enforce a maximum cyclomatic complexity allowed in a program.
|
---|
66 | *
|
---|
67 | * @since 0.0.9
|
---|
68 | * @see https://eslint.org/docs/rules/complexity
|
---|
69 | */
|
---|
70 | complexity: Linter.RuleEntry<
|
---|
71 | [
|
---|
72 | | Partial<{
|
---|
73 | /**
|
---|
74 | * @default 20
|
---|
75 | */
|
---|
76 | max: number;
|
---|
77 | /**
|
---|
78 | * @deprecated
|
---|
79 | * @default 20
|
---|
80 | */
|
---|
81 | maximum: number;
|
---|
82 | }>
|
---|
83 | | number,
|
---|
84 | ]
|
---|
85 | >;
|
---|
86 |
|
---|
87 | /**
|
---|
88 | * Rule to require `return` statements to either always or never specify values.
|
---|
89 | *
|
---|
90 | * @since 0.4.0
|
---|
91 | * @see https://eslint.org/docs/rules/consistent-return
|
---|
92 | */
|
---|
93 | "consistent-return": Linter.RuleEntry<
|
---|
94 | [
|
---|
95 | Partial<{
|
---|
96 | /**
|
---|
97 | * @default false
|
---|
98 | */
|
---|
99 | treatUndefinedAsUnspecified: boolean;
|
---|
100 | }>,
|
---|
101 | ]
|
---|
102 | >;
|
---|
103 |
|
---|
104 | /**
|
---|
105 | * Rule to enforce consistent brace style for all control statements.
|
---|
106 | *
|
---|
107 | * @since 0.0.2
|
---|
108 | * @see https://eslint.org/docs/rules/curly
|
---|
109 | */
|
---|
110 | curly: Linter.RuleEntry<["all" | "multi" | "multi-line" | "multi-or-nest" | "consistent"]>;
|
---|
111 |
|
---|
112 | /**
|
---|
113 | * Rule to require `default` cases in `switch` statements.
|
---|
114 | *
|
---|
115 | * @since 0.6.0
|
---|
116 | * @see https://eslint.org/docs/rules/default-case
|
---|
117 | */
|
---|
118 | "default-case": Linter.RuleEntry<
|
---|
119 | [
|
---|
120 | Partial<{
|
---|
121 | /**
|
---|
122 | * @default '^no default$'
|
---|
123 | */
|
---|
124 | commentPattern: string;
|
---|
125 | }>,
|
---|
126 | ]
|
---|
127 | >;
|
---|
128 |
|
---|
129 | /**
|
---|
130 | * Rule to enforce consistent newlines before and after dots.
|
---|
131 | *
|
---|
132 | * @since 0.21.0
|
---|
133 | * @see https://eslint.org/docs/rules/dot-location
|
---|
134 | */
|
---|
135 | "dot-location": Linter.RuleEntry<["object" | "property"]>;
|
---|
136 |
|
---|
137 | /**
|
---|
138 | * Rule to enforce dot notation whenever possible.
|
---|
139 | *
|
---|
140 | * @since 0.0.7
|
---|
141 | * @see https://eslint.org/docs/rules/dot-notation
|
---|
142 | */
|
---|
143 | "dot-notation": Linter.RuleEntry<
|
---|
144 | [
|
---|
145 | Partial<{
|
---|
146 | /**
|
---|
147 | * @default true
|
---|
148 | */
|
---|
149 | allowKeywords: boolean;
|
---|
150 | allowPattern: string;
|
---|
151 | }>,
|
---|
152 | ]
|
---|
153 | >;
|
---|
154 |
|
---|
155 | /**
|
---|
156 | * Rule to require the use of `===` and `!==`.
|
---|
157 | *
|
---|
158 | * @since 0.0.2
|
---|
159 | * @see https://eslint.org/docs/rules/eqeqeq
|
---|
160 | */
|
---|
161 | eqeqeq:
|
---|
162 | | Linter.RuleEntry<
|
---|
163 | [
|
---|
164 | "always",
|
---|
165 | Partial<{
|
---|
166 | /**
|
---|
167 | * @default 'always'
|
---|
168 | */
|
---|
169 | null: "always" | "never" | "ignore";
|
---|
170 | }>,
|
---|
171 | ]
|
---|
172 | >
|
---|
173 | | Linter.RuleEntry<["smart" | "allow-null"]>;
|
---|
174 |
|
---|
175 | /**
|
---|
176 | * Rule to require `for-in` loops to include an `if` statement.
|
---|
177 | *
|
---|
178 | * @since 0.0.6
|
---|
179 | * @see https://eslint.org/docs/rules/guard-for-in
|
---|
180 | */
|
---|
181 | "guard-for-in": Linter.RuleEntry<[]>;
|
---|
182 |
|
---|
183 | /**
|
---|
184 | * Rule to enforce a maximum number of classes per file.
|
---|
185 | *
|
---|
186 | * @since 5.0.0-alpha.3
|
---|
187 | * @see https://eslint.org/docs/rules/max-classes-per-file
|
---|
188 | */
|
---|
189 | "max-classes-per-file": Linter.RuleEntry<[number]>;
|
---|
190 |
|
---|
191 | /**
|
---|
192 | * Rule to disallow the use of `alert`, `confirm`, and `prompt`.
|
---|
193 | *
|
---|
194 | * @since 0.0.5
|
---|
195 | * @see https://eslint.org/docs/rules/no-alert
|
---|
196 | */
|
---|
197 | "no-alert": Linter.RuleEntry<[]>;
|
---|
198 |
|
---|
199 | /**
|
---|
200 | * Rule to disallow the use of `arguments.caller` or `arguments.callee`.
|
---|
201 | *
|
---|
202 | * @since 0.0.6
|
---|
203 | * @see https://eslint.org/docs/rules/no-caller
|
---|
204 | */
|
---|
205 | "no-caller": Linter.RuleEntry<[]>;
|
---|
206 |
|
---|
207 | /**
|
---|
208 | * Rule to disallow lexical declarations in case clauses.
|
---|
209 | *
|
---|
210 | * @remarks
|
---|
211 | * Recommended by ESLint, the rule was enabled in `eslint:recommended`.
|
---|
212 | *
|
---|
213 | * @since 1.9.0
|
---|
214 | * @see https://eslint.org/docs/rules/no-case-declarations
|
---|
215 | */
|
---|
216 | "no-case-declarations": Linter.RuleEntry<[]>;
|
---|
217 |
|
---|
218 | /**
|
---|
219 | * Rule to disallow division operators explicitly at the beginning of regular expressions.
|
---|
220 | *
|
---|
221 | * @since 0.1.0
|
---|
222 | * @see https://eslint.org/docs/rules/no-div-regex
|
---|
223 | */
|
---|
224 | "no-div-regex": Linter.RuleEntry<[]>;
|
---|
225 |
|
---|
226 | /**
|
---|
227 | * Rule to disallow `else` blocks after `return` statements in `if` statements.
|
---|
228 | *
|
---|
229 | * @since 0.0.9
|
---|
230 | * @see https://eslint.org/docs/rules/no-else-return
|
---|
231 | */
|
---|
232 | "no-else-return": Linter.RuleEntry<
|
---|
233 | [
|
---|
234 | Partial<{
|
---|
235 | /**
|
---|
236 | * @default true
|
---|
237 | */
|
---|
238 | allowElseIf: boolean;
|
---|
239 | }>,
|
---|
240 | ]
|
---|
241 | >;
|
---|
242 |
|
---|
243 | /**
|
---|
244 | * Rule to disallow empty functions.
|
---|
245 | *
|
---|
246 | * @since 2.0.0
|
---|
247 | * @see https://eslint.org/docs/rules/no-empty-function
|
---|
248 | */
|
---|
249 | "no-empty-function": Linter.RuleEntry<
|
---|
250 | [
|
---|
251 | Partial<{
|
---|
252 | /**
|
---|
253 | * @default []
|
---|
254 | */
|
---|
255 | allow: Array<
|
---|
256 | | "functions"
|
---|
257 | | "arrowFunctions"
|
---|
258 | | "generatorFunctions"
|
---|
259 | | "methods"
|
---|
260 | | "generatorMethods"
|
---|
261 | | "getters"
|
---|
262 | | "setters"
|
---|
263 | | "constructors"
|
---|
264 | >;
|
---|
265 | }>,
|
---|
266 | ]
|
---|
267 | >;
|
---|
268 |
|
---|
269 | /**
|
---|
270 | * Rule to disallow empty destructuring patterns.
|
---|
271 | *
|
---|
272 | * @remarks
|
---|
273 | * Recommended by ESLint, the rule was enabled in `eslint:recommended`.
|
---|
274 | *
|
---|
275 | * @since 1.7.0
|
---|
276 | * @see https://eslint.org/docs/rules/no-empty-pattern
|
---|
277 | */
|
---|
278 | "no-empty-pattern": Linter.RuleEntry<[]>;
|
---|
279 |
|
---|
280 | /**
|
---|
281 | * Rule to disallow `null` comparisons without type-checking operators.
|
---|
282 | *
|
---|
283 | * @since 0.0.9
|
---|
284 | * @see https://eslint.org/docs/rules/no-eq-null
|
---|
285 | */
|
---|
286 | "no-eq-null": Linter.RuleEntry<[]>;
|
---|
287 |
|
---|
288 | /**
|
---|
289 | * Rule to disallow the use of `eval()`.
|
---|
290 | *
|
---|
291 | * @since 0.0.2
|
---|
292 | * @see https://eslint.org/docs/rules/no-eval
|
---|
293 | */
|
---|
294 | "no-eval": Linter.RuleEntry<
|
---|
295 | [
|
---|
296 | Partial<{
|
---|
297 | /**
|
---|
298 | * @default false
|
---|
299 | */
|
---|
300 | allowIndirect: boolean;
|
---|
301 | }>,
|
---|
302 | ]
|
---|
303 | >;
|
---|
304 |
|
---|
305 | /**
|
---|
306 | * Rule to disallow extending native types.
|
---|
307 | *
|
---|
308 | * @since 0.1.4
|
---|
309 | * @see https://eslint.org/docs/rules/no-extend-native
|
---|
310 | */
|
---|
311 | "no-extend-native": Linter.RuleEntry<
|
---|
312 | [
|
---|
313 | Partial<{
|
---|
314 | exceptions: string[];
|
---|
315 | }>,
|
---|
316 | ]
|
---|
317 | >;
|
---|
318 |
|
---|
319 | /**
|
---|
320 | * Rule to disallow unnecessary calls to `.bind()`.
|
---|
321 | *
|
---|
322 | * @since 0.8.0
|
---|
323 | * @see https://eslint.org/docs/rules/no-extra-bind
|
---|
324 | */
|
---|
325 | "no-extra-bind": Linter.RuleEntry<[]>;
|
---|
326 |
|
---|
327 | /**
|
---|
328 | * Rule to disallow unnecessary labels.
|
---|
329 | *
|
---|
330 | * @since 2.0.0-rc.0
|
---|
331 | * @see https://eslint.org/docs/rules/no-extra-label
|
---|
332 | */
|
---|
333 | "no-extra-label": Linter.RuleEntry<[]>;
|
---|
334 |
|
---|
335 | /**
|
---|
336 | * Rule to disallow fallthrough of `case` statements.
|
---|
337 | *
|
---|
338 | * @remarks
|
---|
339 | * Recommended by ESLint, the rule was enabled in `eslint:recommended`.
|
---|
340 | *
|
---|
341 | * @since 0.0.7
|
---|
342 | * @see https://eslint.org/docs/rules/no-fallthrough
|
---|
343 | */
|
---|
344 | "no-fallthrough": Linter.RuleEntry<
|
---|
345 | [
|
---|
346 | Partial<{
|
---|
347 | /**
|
---|
348 | * @default 'falls?\s?through'
|
---|
349 | */
|
---|
350 | commentPattern: string;
|
---|
351 | }>,
|
---|
352 | ]
|
---|
353 | >;
|
---|
354 |
|
---|
355 | /**
|
---|
356 | * Rule to disallow leading or trailing decimal points in numeric literals.
|
---|
357 | *
|
---|
358 | * @since 0.0.6
|
---|
359 | * @see https://eslint.org/docs/rules/no-floating-decimal
|
---|
360 | */
|
---|
361 | "no-floating-decimal": Linter.RuleEntry<[]>;
|
---|
362 |
|
---|
363 | /**
|
---|
364 | * Rule to disallow assignments to native objects or read-only global variables.
|
---|
365 | *
|
---|
366 | * @remarks
|
---|
367 | * Recommended by ESLint, the rule was enabled in `eslint:recommended`.
|
---|
368 | *
|
---|
369 | * @since 3.3.0
|
---|
370 | * @see https://eslint.org/docs/rules/no-global-assign
|
---|
371 | */
|
---|
372 | "no-global-assign": Linter.RuleEntry<
|
---|
373 | [
|
---|
374 | Partial<{
|
---|
375 | exceptions: string[];
|
---|
376 | }>,
|
---|
377 | ]
|
---|
378 | >;
|
---|
379 |
|
---|
380 | /**
|
---|
381 | * Rule to disallow shorthand type conversions.
|
---|
382 | *
|
---|
383 | * @since 1.0.0-rc-2
|
---|
384 | * @see https://eslint.org/docs/rules/no-implicit-coercion
|
---|
385 | */
|
---|
386 | "no-implicit-coercion": Linter.RuleEntry<
|
---|
387 | [
|
---|
388 | Partial<{
|
---|
389 | /**
|
---|
390 | * @default true
|
---|
391 | */
|
---|
392 | boolean: boolean;
|
---|
393 | /**
|
---|
394 | * @default true
|
---|
395 | */
|
---|
396 | number: boolean;
|
---|
397 | /**
|
---|
398 | * @default true
|
---|
399 | */
|
---|
400 | string: boolean;
|
---|
401 | /**
|
---|
402 | * @default []
|
---|
403 | */
|
---|
404 | allow: Array<"~" | "!!" | "+" | "*">;
|
---|
405 | }>,
|
---|
406 | ]
|
---|
407 | >;
|
---|
408 |
|
---|
409 | /**
|
---|
410 | * Rule to disallow variable and `function` declarations in the global scope.
|
---|
411 | *
|
---|
412 | * @since 2.0.0-alpha-1
|
---|
413 | * @see https://eslint.org/docs/rules/no-implicit-globals
|
---|
414 | */
|
---|
415 | "no-implicit-globals": Linter.RuleEntry<[]>;
|
---|
416 |
|
---|
417 | /**
|
---|
418 | * Rule to disallow the use of `eval()`-like methods.
|
---|
419 | *
|
---|
420 | * @since 0.0.7
|
---|
421 | * @see https://eslint.org/docs/rules/no-implied-eval
|
---|
422 | */
|
---|
423 | "no-implied-eval": Linter.RuleEntry<[]>;
|
---|
424 |
|
---|
425 | /**
|
---|
426 | * Rule to disallow `this` keywords outside of classes or class-like objects.
|
---|
427 | *
|
---|
428 | * @since 1.0.0-rc-2
|
---|
429 | * @see https://eslint.org/docs/rules/no-invalid-this
|
---|
430 | */
|
---|
431 | "no-invalid-this": Linter.RuleEntry<[]>;
|
---|
432 |
|
---|
433 | /**
|
---|
434 | * Rule to disallow the use of the `__iterator__` property.
|
---|
435 | *
|
---|
436 | * @since 0.0.9
|
---|
437 | * @see https://eslint.org/docs/rules/no-iterator
|
---|
438 | */
|
---|
439 | "no-iterator": Linter.RuleEntry<[]>;
|
---|
440 |
|
---|
441 | /**
|
---|
442 | * Rule to disallow labeled statements.
|
---|
443 | *
|
---|
444 | * @since 0.4.0
|
---|
445 | * @see https://eslint.org/docs/rules/no-labels
|
---|
446 | */
|
---|
447 | "no-labels": Linter.RuleEntry<
|
---|
448 | [
|
---|
449 | Partial<{
|
---|
450 | /**
|
---|
451 | * @default false
|
---|
452 | */
|
---|
453 | allowLoop: boolean;
|
---|
454 | /**
|
---|
455 | * @default false
|
---|
456 | */
|
---|
457 | allowSwitch: boolean;
|
---|
458 | }>,
|
---|
459 | ]
|
---|
460 | >;
|
---|
461 |
|
---|
462 | /**
|
---|
463 | * Rule to disallow unnecessary nested blocks.
|
---|
464 | *
|
---|
465 | * @since 0.4.0
|
---|
466 | * @see https://eslint.org/docs/rules/no-lone-blocks
|
---|
467 | */
|
---|
468 | "no-lone-blocks": Linter.RuleEntry<[]>;
|
---|
469 |
|
---|
470 | /**
|
---|
471 | * Rule to disallow function declarations that contain unsafe references inside loop statements.
|
---|
472 | *
|
---|
473 | * @since 0.0.9
|
---|
474 | * @see https://eslint.org/docs/rules/no-loop-func
|
---|
475 | */
|
---|
476 | "no-loop-func": Linter.RuleEntry<[]>;
|
---|
477 |
|
---|
478 | /**
|
---|
479 | * Rule to disallow magic numbers.
|
---|
480 | *
|
---|
481 | * @since 1.7.0
|
---|
482 | * @see https://eslint.org/docs/rules/no-magic-numbers
|
---|
483 | */
|
---|
484 | "no-magic-numbers": Linter.RuleEntry<
|
---|
485 | [
|
---|
486 | Partial<{
|
---|
487 | /**
|
---|
488 | * @default []
|
---|
489 | */
|
---|
490 | ignore: number[];
|
---|
491 | /**
|
---|
492 | * @default false
|
---|
493 | */
|
---|
494 | ignoreArrayIndexes: boolean;
|
---|
495 | /**
|
---|
496 | * @default false
|
---|
497 | */
|
---|
498 | enforceConst: boolean;
|
---|
499 | /**
|
---|
500 | * @default false
|
---|
501 | */
|
---|
502 | detectObjects: boolean;
|
---|
503 | }>,
|
---|
504 | ]
|
---|
505 | >;
|
---|
506 |
|
---|
507 | /**
|
---|
508 | * Rule to disallow multiple spaces.
|
---|
509 | *
|
---|
510 | * @since 0.9.0
|
---|
511 | * @see https://eslint.org/docs/rules/no-multi-spaces
|
---|
512 | */
|
---|
513 | "no-multi-spaces": Linter.RuleEntry<
|
---|
514 | [
|
---|
515 | Partial<{
|
---|
516 | /**
|
---|
517 | * @default false
|
---|
518 | */
|
---|
519 | ignoreEOLComments: boolean;
|
---|
520 | /**
|
---|
521 | * @default { Property: true }
|
---|
522 | */
|
---|
523 | exceptions: Record<string, boolean>;
|
---|
524 | }>,
|
---|
525 | ]
|
---|
526 | >;
|
---|
527 |
|
---|
528 | /**
|
---|
529 | * Rule to disallow multiline strings.
|
---|
530 | *
|
---|
531 | * @since 0.0.9
|
---|
532 | * @see https://eslint.org/docs/rules/no-multi-str
|
---|
533 | */
|
---|
534 | "no-multi-str": Linter.RuleEntry<[]>;
|
---|
535 |
|
---|
536 | /**
|
---|
537 | * Rule to disallow `new` operators outside of assignments or comparisons.
|
---|
538 | *
|
---|
539 | * @since 0.0.7
|
---|
540 | * @see https://eslint.org/docs/rules/no-new
|
---|
541 | */
|
---|
542 | "no-new": Linter.RuleEntry<[]>;
|
---|
543 |
|
---|
544 | /**
|
---|
545 | * Rule to disallow `new` operators with the `Function` object.
|
---|
546 | *
|
---|
547 | * @since 0.0.7
|
---|
548 | * @see https://eslint.org/docs/rules/no-new-func
|
---|
549 | */
|
---|
550 | "no-new-func": Linter.RuleEntry<[]>;
|
---|
551 |
|
---|
552 | /**
|
---|
553 | * Rule to disallow `new` operators with the `String`, `Number`, and `Boolean` objects.
|
---|
554 | *
|
---|
555 | * @since 0.0.6
|
---|
556 | * @see https://eslint.org/docs/rules/no-new-wrappers
|
---|
557 | */
|
---|
558 | "no-new-wrappers": Linter.RuleEntry<[]>;
|
---|
559 |
|
---|
560 | /**
|
---|
561 | * Rule to disallow octal literals.
|
---|
562 | *
|
---|
563 | * @remarks
|
---|
564 | * Recommended by ESLint, the rule was enabled in `eslint:recommended`.
|
---|
565 | *
|
---|
566 | * @since 0.0.6
|
---|
567 | * @see https://eslint.org/docs/rules/no-octal
|
---|
568 | */
|
---|
569 | "no-octal": Linter.RuleEntry<[]>;
|
---|
570 |
|
---|
571 | /**
|
---|
572 | * Rule to disallow octal escape sequences in string literals.
|
---|
573 | *
|
---|
574 | * @since 0.0.9
|
---|
575 | * @see https://eslint.org/docs/rules/no-octal-escape
|
---|
576 | */
|
---|
577 | "no-octal-escape": Linter.RuleEntry<[]>;
|
---|
578 |
|
---|
579 | /**
|
---|
580 | * Rule to disallow reassigning `function` parameters.
|
---|
581 | *
|
---|
582 | * @since 0.18.0
|
---|
583 | * @see https://eslint.org/docs/rules/no-param-reassign
|
---|
584 | */
|
---|
585 | "no-param-reassign": Linter.RuleEntry<
|
---|
586 | [
|
---|
587 | Partial<{
|
---|
588 | /**
|
---|
589 | * @default false
|
---|
590 | */
|
---|
591 | props: boolean;
|
---|
592 | /**
|
---|
593 | * @default []
|
---|
594 | */
|
---|
595 | ignorePropertyModificationsFor: string[];
|
---|
596 | }>,
|
---|
597 | ]
|
---|
598 | >;
|
---|
599 |
|
---|
600 | /**
|
---|
601 | * Rule to disallow the use of the `__proto__` property.
|
---|
602 | *
|
---|
603 | * @since 0.0.9
|
---|
604 | * @see https://eslint.org/docs/rules/no-proto
|
---|
605 | */
|
---|
606 | "no-proto": Linter.RuleEntry<[]>;
|
---|
607 |
|
---|
608 | /**
|
---|
609 | * Rule to disallow variable redeclaration.
|
---|
610 | *
|
---|
611 | * @remarks
|
---|
612 | * Recommended by ESLint, the rule was enabled in `eslint:recommended`.
|
---|
613 | *
|
---|
614 | * @since 0.0.9
|
---|
615 | * @see https://eslint.org/docs/rules/no-redeclare
|
---|
616 | */
|
---|
617 | "no-redeclare": Linter.RuleEntry<
|
---|
618 | [
|
---|
619 | Partial<{
|
---|
620 | /**
|
---|
621 | * @default true
|
---|
622 | */
|
---|
623 | builtinGlobals: boolean;
|
---|
624 | }>,
|
---|
625 | ]
|
---|
626 | >;
|
---|
627 |
|
---|
628 | /**
|
---|
629 | * Rule to disallow certain properties on certain objects.
|
---|
630 | *
|
---|
631 | * @since 3.5.0
|
---|
632 | * @see https://eslint.org/docs/rules/no-restricted-properties
|
---|
633 | */
|
---|
634 | "no-restricted-properties": Linter.RuleEntry<
|
---|
635 | [
|
---|
636 | ...Array<
|
---|
637 | | {
|
---|
638 | object: string;
|
---|
639 | property?: string | undefined;
|
---|
640 | message?: string | undefined;
|
---|
641 | }
|
---|
642 | | {
|
---|
643 | property: string;
|
---|
644 | message?: string | undefined;
|
---|
645 | }
|
---|
646 | >
|
---|
647 | ]
|
---|
648 | >;
|
---|
649 |
|
---|
650 | /**
|
---|
651 | * Rule to disallow assignment operators in `return` statements.
|
---|
652 | *
|
---|
653 | * @since 0.0.9
|
---|
654 | * @see https://eslint.org/docs/rules/no-return-assign
|
---|
655 | */
|
---|
656 | "no-return-assign": Linter.RuleEntry<["except-parens" | "always"]>;
|
---|
657 |
|
---|
658 | /**
|
---|
659 | * Rule to disallow unnecessary `return await`.
|
---|
660 | *
|
---|
661 | * @since 3.10.0
|
---|
662 | * @see https://eslint.org/docs/rules/no-return-await
|
---|
663 | */
|
---|
664 | "no-return-await": Linter.RuleEntry<[]>;
|
---|
665 |
|
---|
666 | /**
|
---|
667 | * Rule to disallow `javascript:` urls.
|
---|
668 | *
|
---|
669 | * @since 0.0.9
|
---|
670 | * @see https://eslint.org/docs/rules/no-script-url
|
---|
671 | */
|
---|
672 | "no-script-url": Linter.RuleEntry<[]>;
|
---|
673 |
|
---|
674 | /**
|
---|
675 | * Rule to disallow assignments where both sides are exactly the same.
|
---|
676 | *
|
---|
677 | * @remarks
|
---|
678 | * Recommended by ESLint, the rule was enabled in `eslint:recommended`.
|
---|
679 | *
|
---|
680 | * @since 2.0.0-rc.0
|
---|
681 | * @see https://eslint.org/docs/rules/no-self-assign
|
---|
682 | */
|
---|
683 | "no-self-assign": Linter.RuleEntry<[]>;
|
---|
684 |
|
---|
685 | /**
|
---|
686 | * Rule to disallow comparisons where both sides are exactly the same.
|
---|
687 | *
|
---|
688 | * @since 0.0.9
|
---|
689 | * @see https://eslint.org/docs/rules/no-self-compare
|
---|
690 | */
|
---|
691 | "no-self-compare": Linter.RuleEntry<[]>;
|
---|
692 |
|
---|
693 | /**
|
---|
694 | * Rule to disallow comma operators.
|
---|
695 | *
|
---|
696 | * @since 0.5.1
|
---|
697 | * @see https://eslint.org/docs/rules/no-sequences
|
---|
698 | */
|
---|
699 | "no-sequences": Linter.RuleEntry<[]>;
|
---|
700 |
|
---|
701 | /**
|
---|
702 | * Rule to disallow throwing literals as exceptions.
|
---|
703 | *
|
---|
704 | * @since 0.15.0
|
---|
705 | * @see https://eslint.org/docs/rules/no-throw-literal
|
---|
706 | */
|
---|
707 | "no-throw-literal": Linter.RuleEntry<[]>;
|
---|
708 |
|
---|
709 | /**
|
---|
710 | * Rule to disallow unmodified loop conditions.
|
---|
711 | *
|
---|
712 | * @since 2.0.0-alpha-2
|
---|
713 | * @see https://eslint.org/docs/rules/no-unmodified-loop-condition
|
---|
714 | */
|
---|
715 | "no-unmodified-loop-condition": Linter.RuleEntry<[]>;
|
---|
716 |
|
---|
717 | /**
|
---|
718 | * Rule to disallow unused expressions.
|
---|
719 | *
|
---|
720 | * @since 0.1.0
|
---|
721 | * @see https://eslint.org/docs/rules/no-unused-expressions
|
---|
722 | */
|
---|
723 | "no-unused-expressions": Linter.RuleEntry<
|
---|
724 | [
|
---|
725 | Partial<{
|
---|
726 | /**
|
---|
727 | * @default false
|
---|
728 | */
|
---|
729 | allowShortCircuit: boolean;
|
---|
730 | /**
|
---|
731 | * @default false
|
---|
732 | */
|
---|
733 | allowTernary: boolean;
|
---|
734 | /**
|
---|
735 | * @default false
|
---|
736 | */
|
---|
737 | allowTaggedTemplates: boolean;
|
---|
738 | }>,
|
---|
739 | ]
|
---|
740 | >;
|
---|
741 |
|
---|
742 | /**
|
---|
743 | * Rule to disallow unused labels.
|
---|
744 | *
|
---|
745 | * @remarks
|
---|
746 | * Recommended by ESLint, the rule was enabled in `eslint:recommended`.
|
---|
747 | *
|
---|
748 | * @since 2.0.0-rc.0
|
---|
749 | * @see https://eslint.org/docs/rules/no-unused-labels
|
---|
750 | */
|
---|
751 | "no-unused-labels": Linter.RuleEntry<[]>;
|
---|
752 |
|
---|
753 | /**
|
---|
754 | * Rule to disallow unnecessary calls to `.call()` and `.apply()`.
|
---|
755 | *
|
---|
756 | * @since 1.0.0-rc-1
|
---|
757 | * @see https://eslint.org/docs/rules/no-useless-call
|
---|
758 | */
|
---|
759 | "no-useless-call": Linter.RuleEntry<[]>;
|
---|
760 |
|
---|
761 | /**
|
---|
762 | * Rule to disallow unnecessary `catch` clauses.
|
---|
763 | *
|
---|
764 | * @remarks
|
---|
765 | * Recommended by ESLint, the rule was enabled in `eslint:recommended`.
|
---|
766 | *
|
---|
767 | * @since 5.11.0
|
---|
768 | * @see https://eslint.org/docs/rules/no-useless-catch
|
---|
769 | */
|
---|
770 | "no-useless-catch": Linter.RuleEntry<[]>;
|
---|
771 |
|
---|
772 | /**
|
---|
773 | * Rule to disallow unnecessary concatenation of literals or template literals.
|
---|
774 | *
|
---|
775 | * @since 1.3.0
|
---|
776 | * @see https://eslint.org/docs/rules/no-useless-concat
|
---|
777 | */
|
---|
778 | "no-useless-concat": Linter.RuleEntry<[]>;
|
---|
779 |
|
---|
780 | /**
|
---|
781 | * Rule to disallow unnecessary escape characters.
|
---|
782 | *
|
---|
783 | * @remarks
|
---|
784 | * Recommended by ESLint, the rule was enabled in `eslint:recommended`.
|
---|
785 | *
|
---|
786 | * @since 2.5.0
|
---|
787 | * @see https://eslint.org/docs/rules/no-useless-escape
|
---|
788 | */
|
---|
789 | "no-useless-escape": Linter.RuleEntry<[]>;
|
---|
790 |
|
---|
791 | /**
|
---|
792 | * Rule to disallow redundant return statements.
|
---|
793 | *
|
---|
794 | * @since 3.9.0
|
---|
795 | * @see https://eslint.org/docs/rules/no-useless-return
|
---|
796 | */
|
---|
797 | "no-useless-return": Linter.RuleEntry<[]>;
|
---|
798 |
|
---|
799 | /**
|
---|
800 | * Rule to disallow `void` operators.
|
---|
801 | *
|
---|
802 | * @since 0.8.0
|
---|
803 | * @see https://eslint.org/docs/rules/no-void
|
---|
804 | */
|
---|
805 | "no-void": Linter.RuleEntry<[]>;
|
---|
806 |
|
---|
807 | /**
|
---|
808 | * Rule to disallow specified warning terms in comments.
|
---|
809 | *
|
---|
810 | * @since 0.4.4
|
---|
811 | * @see https://eslint.org/docs/rules/no-warning-comments
|
---|
812 | */
|
---|
813 | "no-warning-comments": Linter.RuleEntry<
|
---|
814 | [
|
---|
815 | {
|
---|
816 | /**
|
---|
817 | * @default ["todo", "fixme", "xxx"]
|
---|
818 | */
|
---|
819 | terms: string[];
|
---|
820 | /**
|
---|
821 | * @default 'start'
|
---|
822 | */
|
---|
823 | location: "start" | "anywhere";
|
---|
824 | },
|
---|
825 | ]
|
---|
826 | >;
|
---|
827 |
|
---|
828 | /**
|
---|
829 | * Rule to disallow `with` statements.
|
---|
830 | *
|
---|
831 | * @remarks
|
---|
832 | * Recommended by ESLint, the rule was enabled in `eslint:recommended`.
|
---|
833 | *
|
---|
834 | * @since 0.0.2
|
---|
835 | * @see https://eslint.org/docs/rules/no-with
|
---|
836 | */
|
---|
837 | "no-with": Linter.RuleEntry<[]>;
|
---|
838 |
|
---|
839 | /**
|
---|
840 | * Rule to enforce using named capture group in regular expression.
|
---|
841 | *
|
---|
842 | * @since 5.15.0
|
---|
843 | * @see https://eslint.org/docs/rules/prefer-named-capture-group
|
---|
844 | */
|
---|
845 | "prefer-named-capture-group": Linter.RuleEntry<[]>;
|
---|
846 |
|
---|
847 | /**
|
---|
848 | * Rule to require using Error objects as Promise rejection reasons.
|
---|
849 | *
|
---|
850 | * @since 3.14.0
|
---|
851 | * @see https://eslint.org/docs/rules/prefer-promise-reject-errors
|
---|
852 | */
|
---|
853 | "prefer-promise-reject-errors": Linter.RuleEntry<
|
---|
854 | [
|
---|
855 | Partial<{
|
---|
856 | /**
|
---|
857 | * @default false
|
---|
858 | */
|
---|
859 | allowEmptyReject: boolean;
|
---|
860 | }>,
|
---|
861 | ]
|
---|
862 | >;
|
---|
863 |
|
---|
864 | /**
|
---|
865 | * Rule to enforce the consistent use of the radix argument when using `parseInt()`.
|
---|
866 | *
|
---|
867 | * @since 0.0.7
|
---|
868 | * @see https://eslint.org/docs/rules/radix
|
---|
869 | */
|
---|
870 | radix: Linter.RuleEntry<["always" | "as-needed"]>;
|
---|
871 |
|
---|
872 | /**
|
---|
873 | * Rule to disallow async functions which have no `await` expression.
|
---|
874 | *
|
---|
875 | * @since 3.11.0
|
---|
876 | * @see https://eslint.org/docs/rules/require-await
|
---|
877 | */
|
---|
878 | "require-await": Linter.RuleEntry<[]>;
|
---|
879 |
|
---|
880 | /**
|
---|
881 | * Rule to enforce the use of `u` flag on RegExp.
|
---|
882 | *
|
---|
883 | * @since 5.3.0
|
---|
884 | * @see https://eslint.org/docs/rules/require-unicode-regexp
|
---|
885 | */
|
---|
886 | "require-unicode-regexp": Linter.RuleEntry<[]>;
|
---|
887 |
|
---|
888 | /**
|
---|
889 | * Rule to require `var` declarations be placed at the top of their containing scope.
|
---|
890 | *
|
---|
891 | * @since 0.8.0
|
---|
892 | * @see https://eslint.org/docs/rules/vars-on-top
|
---|
893 | */
|
---|
894 | "vars-on-top": Linter.RuleEntry<[]>;
|
---|
895 |
|
---|
896 | /**
|
---|
897 | * Rule to require parentheses around immediate `function` invocations.
|
---|
898 | *
|
---|
899 | * @since 0.0.9
|
---|
900 | * @see https://eslint.org/docs/rules/wrap-iife
|
---|
901 | */
|
---|
902 | "wrap-iife": Linter.RuleEntry<
|
---|
903 | [
|
---|
904 | "outside" | "inside" | "any",
|
---|
905 | Partial<{
|
---|
906 | /**
|
---|
907 | * @default false
|
---|
908 | */
|
---|
909 | functionPrototypeMethods: boolean;
|
---|
910 | }>,
|
---|
911 | ]
|
---|
912 | >;
|
---|
913 |
|
---|
914 | /**
|
---|
915 | * Rule to require or disallow “Yoda” conditions.
|
---|
916 | *
|
---|
917 | * @since 0.7.1
|
---|
918 | * @see https://eslint.org/docs/rules/yoda
|
---|
919 | */
|
---|
920 | yoda:
|
---|
921 | | Linter.RuleEntry<
|
---|
922 | [
|
---|
923 | "never",
|
---|
924 | Partial<{
|
---|
925 | exceptRange: boolean;
|
---|
926 | onlyEquality: boolean;
|
---|
927 | }>,
|
---|
928 | ]
|
---|
929 | >
|
---|
930 | | Linter.RuleEntry<["always"]>;
|
---|
931 | }
|
---|