932 lines
23 KiB
TypeScript
Executable File
932 lines
23 KiB
TypeScript
Executable File
import { Linter } from "../index";
|
|
|
|
export interface BestPractices extends Linter.RulesRecord {
|
|
/**
|
|
* Rule to enforce getter and setter pairs in objects.
|
|
*
|
|
* @since 0.22.0
|
|
* @see https://eslint.org/docs/rules/accessor-pairs
|
|
*/
|
|
"accessor-pairs": Linter.RuleEntry<
|
|
[
|
|
Partial<{
|
|
/**
|
|
* @default true
|
|
*/
|
|
setWithoutGet: boolean;
|
|
/**
|
|
* @default false
|
|
*/
|
|
getWithoutSet: boolean;
|
|
}>,
|
|
]
|
|
>;
|
|
|
|
/**
|
|
* Rule to enforce `return` statements in callbacks of array methods.
|
|
*
|
|
* @since 2.0.0-alpha-1
|
|
* @see https://eslint.org/docs/rules/array-callback-return
|
|
*/
|
|
"array-callback-return": Linter.RuleEntry<
|
|
[
|
|
Partial<{
|
|
/**
|
|
* @default false
|
|
*/
|
|
allowImplicit: boolean;
|
|
}>,
|
|
]
|
|
>;
|
|
|
|
/**
|
|
* Rule to enforce the use of variables within the scope they are defined.
|
|
*
|
|
* @since 0.1.0
|
|
* @see https://eslint.org/docs/rules/block-scoped-var
|
|
*/
|
|
"block-scoped-var": Linter.RuleEntry<[]>;
|
|
|
|
/**
|
|
* Rule to enforce that class methods utilize `this`.
|
|
*
|
|
* @since 3.4.0
|
|
* @see https://eslint.org/docs/rules/class-methods-use-this
|
|
*/
|
|
"class-methods-use-this": Linter.RuleEntry<
|
|
[
|
|
Partial<{
|
|
exceptMethods: string[];
|
|
}>,
|
|
]
|
|
>;
|
|
|
|
/**
|
|
* Rule to enforce a maximum cyclomatic complexity allowed in a program.
|
|
*
|
|
* @since 0.0.9
|
|
* @see https://eslint.org/docs/rules/complexity
|
|
*/
|
|
complexity: Linter.RuleEntry<
|
|
[
|
|
| Partial<{
|
|
/**
|
|
* @default 20
|
|
*/
|
|
max: number;
|
|
/**
|
|
* @deprecated
|
|
* @default 20
|
|
*/
|
|
maximum: number;
|
|
}>
|
|
| number,
|
|
]
|
|
>;
|
|
|
|
/**
|
|
* Rule to require `return` statements to either always or never specify values.
|
|
*
|
|
* @since 0.4.0
|
|
* @see https://eslint.org/docs/rules/consistent-return
|
|
*/
|
|
"consistent-return": Linter.RuleEntry<
|
|
[
|
|
Partial<{
|
|
/**
|
|
* @default false
|
|
*/
|
|
treatUndefinedAsUnspecified: boolean;
|
|
}>,
|
|
]
|
|
>;
|
|
|
|
/**
|
|
* Rule to enforce consistent brace style for all control statements.
|
|
*
|
|
* @since 0.0.2
|
|
* @see https://eslint.org/docs/rules/curly
|
|
*/
|
|
curly: Linter.RuleEntry<["all" | "multi" | "multi-line" | "multi-or-nest" | "consistent"]>;
|
|
|
|
/**
|
|
* Rule to require `default` cases in `switch` statements.
|
|
*
|
|
* @since 0.6.0
|
|
* @see https://eslint.org/docs/rules/default-case
|
|
*/
|
|
"default-case": Linter.RuleEntry<
|
|
[
|
|
Partial<{
|
|
/**
|
|
* @default '^no default$'
|
|
*/
|
|
commentPattern: string;
|
|
}>,
|
|
]
|
|
>;
|
|
|
|
/**
|
|
* Rule to enforce consistent newlines before and after dots.
|
|
*
|
|
* @since 0.21.0
|
|
* @see https://eslint.org/docs/rules/dot-location
|
|
*/
|
|
"dot-location": Linter.RuleEntry<["object" | "property"]>;
|
|
|
|
/**
|
|
* Rule to enforce dot notation whenever possible.
|
|
*
|
|
* @since 0.0.7
|
|
* @see https://eslint.org/docs/rules/dot-notation
|
|
*/
|
|
"dot-notation": Linter.RuleEntry<
|
|
[
|
|
Partial<{
|
|
/**
|
|
* @default true
|
|
*/
|
|
allowKeywords: boolean;
|
|
allowPattern: string;
|
|
}>,
|
|
]
|
|
>;
|
|
|
|
/**
|
|
* Rule to require the use of `===` and `!==`.
|
|
*
|
|
* @since 0.0.2
|
|
* @see https://eslint.org/docs/rules/eqeqeq
|
|
*/
|
|
eqeqeq:
|
|
| Linter.RuleEntry<
|
|
[
|
|
"always",
|
|
Partial<{
|
|
/**
|
|
* @default 'always'
|
|
*/
|
|
null: "always" | "never" | "ignore";
|
|
}>,
|
|
]
|
|
>
|
|
| Linter.RuleEntry<["smart" | "allow-null"]>;
|
|
|
|
/**
|
|
* Rule to require `for-in` loops to include an `if` statement.
|
|
*
|
|
* @since 0.0.6
|
|
* @see https://eslint.org/docs/rules/guard-for-in
|
|
*/
|
|
"guard-for-in": Linter.RuleEntry<[]>;
|
|
|
|
/**
|
|
* Rule to enforce a maximum number of classes per file.
|
|
*
|
|
* @since 5.0.0-alpha.3
|
|
* @see https://eslint.org/docs/rules/max-classes-per-file
|
|
*/
|
|
"max-classes-per-file": Linter.RuleEntry<[number]>;
|
|
|
|
/**
|
|
* Rule to disallow the use of `alert`, `confirm`, and `prompt`.
|
|
*
|
|
* @since 0.0.5
|
|
* @see https://eslint.org/docs/rules/no-alert
|
|
*/
|
|
"no-alert": Linter.RuleEntry<[]>;
|
|
|
|
/**
|
|
* Rule to disallow the use of `arguments.caller` or `arguments.callee`.
|
|
*
|
|
* @since 0.0.6
|
|
* @see https://eslint.org/docs/rules/no-caller
|
|
*/
|
|
"no-caller": Linter.RuleEntry<[]>;
|
|
|
|
/**
|
|
* Rule to disallow lexical declarations in case clauses.
|
|
*
|
|
* @remarks
|
|
* Recommended by ESLint, the rule was enabled in `eslint:recommended`.
|
|
*
|
|
* @since 1.9.0
|
|
* @see https://eslint.org/docs/rules/no-case-declarations
|
|
*/
|
|
"no-case-declarations": Linter.RuleEntry<[]>;
|
|
|
|
/**
|
|
* Rule to disallow division operators explicitly at the beginning of regular expressions.
|
|
*
|
|
* @since 0.1.0
|
|
* @see https://eslint.org/docs/rules/no-div-regex
|
|
*/
|
|
"no-div-regex": Linter.RuleEntry<[]>;
|
|
|
|
/**
|
|
* Rule to disallow `else` blocks after `return` statements in `if` statements.
|
|
*
|
|
* @since 0.0.9
|
|
* @see https://eslint.org/docs/rules/no-else-return
|
|
*/
|
|
"no-else-return": Linter.RuleEntry<
|
|
[
|
|
Partial<{
|
|
/**
|
|
* @default true
|
|
*/
|
|
allowElseIf: boolean;
|
|
}>,
|
|
]
|
|
>;
|
|
|
|
/**
|
|
* Rule to disallow empty functions.
|
|
*
|
|
* @since 2.0.0
|
|
* @see https://eslint.org/docs/rules/no-empty-function
|
|
*/
|
|
"no-empty-function": Linter.RuleEntry<
|
|
[
|
|
Partial<{
|
|
/**
|
|
* @default []
|
|
*/
|
|
allow: Array<
|
|
| "functions"
|
|
| "arrowFunctions"
|
|
| "generatorFunctions"
|
|
| "methods"
|
|
| "generatorMethods"
|
|
| "getters"
|
|
| "setters"
|
|
| "constructors"
|
|
>;
|
|
}>,
|
|
]
|
|
>;
|
|
|
|
/**
|
|
* Rule to disallow empty destructuring patterns.
|
|
*
|
|
* @remarks
|
|
* Recommended by ESLint, the rule was enabled in `eslint:recommended`.
|
|
*
|
|
* @since 1.7.0
|
|
* @see https://eslint.org/docs/rules/no-empty-pattern
|
|
*/
|
|
"no-empty-pattern": Linter.RuleEntry<[]>;
|
|
|
|
/**
|
|
* Rule to disallow `null` comparisons without type-checking operators.
|
|
*
|
|
* @since 0.0.9
|
|
* @see https://eslint.org/docs/rules/no-eq-null
|
|
*/
|
|
"no-eq-null": Linter.RuleEntry<[]>;
|
|
|
|
/**
|
|
* Rule to disallow the use of `eval()`.
|
|
*
|
|
* @since 0.0.2
|
|
* @see https://eslint.org/docs/rules/no-eval
|
|
*/
|
|
"no-eval": Linter.RuleEntry<
|
|
[
|
|
Partial<{
|
|
/**
|
|
* @default false
|
|
*/
|
|
allowIndirect: boolean;
|
|
}>,
|
|
]
|
|
>;
|
|
|
|
/**
|
|
* Rule to disallow extending native types.
|
|
*
|
|
* @since 0.1.4
|
|
* @see https://eslint.org/docs/rules/no-extend-native
|
|
*/
|
|
"no-extend-native": Linter.RuleEntry<
|
|
[
|
|
Partial<{
|
|
exceptions: string[];
|
|
}>,
|
|
]
|
|
>;
|
|
|
|
/**
|
|
* Rule to disallow unnecessary calls to `.bind()`.
|
|
*
|
|
* @since 0.8.0
|
|
* @see https://eslint.org/docs/rules/no-extra-bind
|
|
*/
|
|
"no-extra-bind": Linter.RuleEntry<[]>;
|
|
|
|
/**
|
|
* Rule to disallow unnecessary labels.
|
|
*
|
|
* @since 2.0.0-rc.0
|
|
* @see https://eslint.org/docs/rules/no-extra-label
|
|
*/
|
|
"no-extra-label": Linter.RuleEntry<[]>;
|
|
|
|
/**
|
|
* Rule to disallow fallthrough of `case` statements.
|
|
*
|
|
* @remarks
|
|
* Recommended by ESLint, the rule was enabled in `eslint:recommended`.
|
|
*
|
|
* @since 0.0.7
|
|
* @see https://eslint.org/docs/rules/no-fallthrough
|
|
*/
|
|
"no-fallthrough": Linter.RuleEntry<
|
|
[
|
|
Partial<{
|
|
/**
|
|
* @default 'falls?\s?through'
|
|
*/
|
|
commentPattern: string;
|
|
}>,
|
|
]
|
|
>;
|
|
|
|
/**
|
|
* Rule to disallow leading or trailing decimal points in numeric literals.
|
|
*
|
|
* @since 0.0.6
|
|
* @see https://eslint.org/docs/rules/no-floating-decimal
|
|
*/
|
|
"no-floating-decimal": Linter.RuleEntry<[]>;
|
|
|
|
/**
|
|
* Rule to disallow assignments to native objects or read-only global variables.
|
|
*
|
|
* @remarks
|
|
* Recommended by ESLint, the rule was enabled in `eslint:recommended`.
|
|
*
|
|
* @since 3.3.0
|
|
* @see https://eslint.org/docs/rules/no-global-assign
|
|
*/
|
|
"no-global-assign": Linter.RuleEntry<
|
|
[
|
|
Partial<{
|
|
exceptions: string[];
|
|
}>,
|
|
]
|
|
>;
|
|
|
|
/**
|
|
* Rule to disallow shorthand type conversions.
|
|
*
|
|
* @since 1.0.0-rc-2
|
|
* @see https://eslint.org/docs/rules/no-implicit-coercion
|
|
*/
|
|
"no-implicit-coercion": Linter.RuleEntry<
|
|
[
|
|
Partial<{
|
|
/**
|
|
* @default true
|
|
*/
|
|
boolean: boolean;
|
|
/**
|
|
* @default true
|
|
*/
|
|
number: boolean;
|
|
/**
|
|
* @default true
|
|
*/
|
|
string: boolean;
|
|
/**
|
|
* @default []
|
|
*/
|
|
allow: Array<"~" | "!!" | "+" | "*">;
|
|
}>,
|
|
]
|
|
>;
|
|
|
|
/**
|
|
* Rule to disallow variable and `function` declarations in the global scope.
|
|
*
|
|
* @since 2.0.0-alpha-1
|
|
* @see https://eslint.org/docs/rules/no-implicit-globals
|
|
*/
|
|
"no-implicit-globals": Linter.RuleEntry<[]>;
|
|
|
|
/**
|
|
* Rule to disallow the use of `eval()`-like methods.
|
|
*
|
|
* @since 0.0.7
|
|
* @see https://eslint.org/docs/rules/no-implied-eval
|
|
*/
|
|
"no-implied-eval": Linter.RuleEntry<[]>;
|
|
|
|
/**
|
|
* Rule to disallow `this` keywords outside of classes or class-like objects.
|
|
*
|
|
* @since 1.0.0-rc-2
|
|
* @see https://eslint.org/docs/rules/no-invalid-this
|
|
*/
|
|
"no-invalid-this": Linter.RuleEntry<[]>;
|
|
|
|
/**
|
|
* Rule to disallow the use of the `__iterator__` property.
|
|
*
|
|
* @since 0.0.9
|
|
* @see https://eslint.org/docs/rules/no-iterator
|
|
*/
|
|
"no-iterator": Linter.RuleEntry<[]>;
|
|
|
|
/**
|
|
* Rule to disallow labeled statements.
|
|
*
|
|
* @since 0.4.0
|
|
* @see https://eslint.org/docs/rules/no-labels
|
|
*/
|
|
"no-labels": Linter.RuleEntry<
|
|
[
|
|
Partial<{
|
|
/**
|
|
* @default false
|
|
*/
|
|
allowLoop: boolean;
|
|
/**
|
|
* @default false
|
|
*/
|
|
allowSwitch: boolean;
|
|
}>,
|
|
]
|
|
>;
|
|
|
|
/**
|
|
* Rule to disallow unnecessary nested blocks.
|
|
*
|
|
* @since 0.4.0
|
|
* @see https://eslint.org/docs/rules/no-lone-blocks
|
|
*/
|
|
"no-lone-blocks": Linter.RuleEntry<[]>;
|
|
|
|
/**
|
|
* Rule to disallow function declarations that contain unsafe references inside loop statements.
|
|
*
|
|
* @since 0.0.9
|
|
* @see https://eslint.org/docs/rules/no-loop-func
|
|
*/
|
|
"no-loop-func": Linter.RuleEntry<[]>;
|
|
|
|
/**
|
|
* Rule to disallow magic numbers.
|
|
*
|
|
* @since 1.7.0
|
|
* @see https://eslint.org/docs/rules/no-magic-numbers
|
|
*/
|
|
"no-magic-numbers": Linter.RuleEntry<
|
|
[
|
|
Partial<{
|
|
/**
|
|
* @default []
|
|
*/
|
|
ignore: number[];
|
|
/**
|
|
* @default false
|
|
*/
|
|
ignoreArrayIndexes: boolean;
|
|
/**
|
|
* @default false
|
|
*/
|
|
enforceConst: boolean;
|
|
/**
|
|
* @default false
|
|
*/
|
|
detectObjects: boolean;
|
|
}>,
|
|
]
|
|
>;
|
|
|
|
/**
|
|
* Rule to disallow multiple spaces.
|
|
*
|
|
* @since 0.9.0
|
|
* @see https://eslint.org/docs/rules/no-multi-spaces
|
|
*/
|
|
"no-multi-spaces": Linter.RuleEntry<
|
|
[
|
|
Partial<{
|
|
/**
|
|
* @default false
|
|
*/
|
|
ignoreEOLComments: boolean;
|
|
/**
|
|
* @default { Property: true }
|
|
*/
|
|
exceptions: Record<string, boolean>;
|
|
}>,
|
|
]
|
|
>;
|
|
|
|
/**
|
|
* Rule to disallow multiline strings.
|
|
*
|
|
* @since 0.0.9
|
|
* @see https://eslint.org/docs/rules/no-multi-str
|
|
*/
|
|
"no-multi-str": Linter.RuleEntry<[]>;
|
|
|
|
/**
|
|
* Rule to disallow `new` operators outside of assignments or comparisons.
|
|
*
|
|
* @since 0.0.7
|
|
* @see https://eslint.org/docs/rules/no-new
|
|
*/
|
|
"no-new": Linter.RuleEntry<[]>;
|
|
|
|
/**
|
|
* Rule to disallow `new` operators with the `Function` object.
|
|
*
|
|
* @since 0.0.7
|
|
* @see https://eslint.org/docs/rules/no-new-func
|
|
*/
|
|
"no-new-func": Linter.RuleEntry<[]>;
|
|
|
|
/**
|
|
* Rule to disallow `new` operators with the `String`, `Number`, and `Boolean` objects.
|
|
*
|
|
* @since 0.0.6
|
|
* @see https://eslint.org/docs/rules/no-new-wrappers
|
|
*/
|
|
"no-new-wrappers": Linter.RuleEntry<[]>;
|
|
|
|
/**
|
|
* Rule to disallow octal literals.
|
|
*
|
|
* @remarks
|
|
* Recommended by ESLint, the rule was enabled in `eslint:recommended`.
|
|
*
|
|
* @since 0.0.6
|
|
* @see https://eslint.org/docs/rules/no-octal
|
|
*/
|
|
"no-octal": Linter.RuleEntry<[]>;
|
|
|
|
/**
|
|
* Rule to disallow octal escape sequences in string literals.
|
|
*
|
|
* @since 0.0.9
|
|
* @see https://eslint.org/docs/rules/no-octal-escape
|
|
*/
|
|
"no-octal-escape": Linter.RuleEntry<[]>;
|
|
|
|
/**
|
|
* Rule to disallow reassigning `function` parameters.
|
|
*
|
|
* @since 0.18.0
|
|
* @see https://eslint.org/docs/rules/no-param-reassign
|
|
*/
|
|
"no-param-reassign": Linter.RuleEntry<
|
|
[
|
|
Partial<{
|
|
/**
|
|
* @default false
|
|
*/
|
|
props: boolean;
|
|
/**
|
|
* @default []
|
|
*/
|
|
ignorePropertyModificationsFor: string[];
|
|
}>,
|
|
]
|
|
>;
|
|
|
|
/**
|
|
* Rule to disallow the use of the `__proto__` property.
|
|
*
|
|
* @since 0.0.9
|
|
* @see https://eslint.org/docs/rules/no-proto
|
|
*/
|
|
"no-proto": Linter.RuleEntry<[]>;
|
|
|
|
/**
|
|
* Rule to disallow variable redeclaration.
|
|
*
|
|
* @remarks
|
|
* Recommended by ESLint, the rule was enabled in `eslint:recommended`.
|
|
*
|
|
* @since 0.0.9
|
|
* @see https://eslint.org/docs/rules/no-redeclare
|
|
*/
|
|
"no-redeclare": Linter.RuleEntry<
|
|
[
|
|
Partial<{
|
|
/**
|
|
* @default true
|
|
*/
|
|
builtinGlobals: boolean;
|
|
}>,
|
|
]
|
|
>;
|
|
|
|
/**
|
|
* Rule to disallow certain properties on certain objects.
|
|
*
|
|
* @since 3.5.0
|
|
* @see https://eslint.org/docs/rules/no-restricted-properties
|
|
*/
|
|
"no-restricted-properties": Linter.RuleEntry<
|
|
[
|
|
...Array<
|
|
| {
|
|
object: string;
|
|
property?: string;
|
|
message?: string;
|
|
}
|
|
| {
|
|
property: string;
|
|
message?: string;
|
|
}
|
|
>
|
|
]
|
|
>;
|
|
|
|
/**
|
|
* Rule to disallow assignment operators in `return` statements.
|
|
*
|
|
* @since 0.0.9
|
|
* @see https://eslint.org/docs/rules/no-return-assign
|
|
*/
|
|
"no-return-assign": Linter.RuleEntry<["except-parens" | "always"]>;
|
|
|
|
/**
|
|
* Rule to disallow unnecessary `return await`.
|
|
*
|
|
* @since 3.10.0
|
|
* @see https://eslint.org/docs/rules/no-return-await
|
|
*/
|
|
"no-return-await": Linter.RuleEntry<[]>;
|
|
|
|
/**
|
|
* Rule to disallow `javascript:` urls.
|
|
*
|
|
* @since 0.0.9
|
|
* @see https://eslint.org/docs/rules/no-script-url
|
|
*/
|
|
"no-script-url": Linter.RuleEntry<[]>;
|
|
|
|
/**
|
|
* Rule to disallow assignments where both sides are exactly the same.
|
|
*
|
|
* @remarks
|
|
* Recommended by ESLint, the rule was enabled in `eslint:recommended`.
|
|
*
|
|
* @since 2.0.0-rc.0
|
|
* @see https://eslint.org/docs/rules/no-self-assign
|
|
*/
|
|
"no-self-assign": Linter.RuleEntry<[]>;
|
|
|
|
/**
|
|
* Rule to disallow comparisons where both sides are exactly the same.
|
|
*
|
|
* @since 0.0.9
|
|
* @see https://eslint.org/docs/rules/no-self-compare
|
|
*/
|
|
"no-self-compare": Linter.RuleEntry<[]>;
|
|
|
|
/**
|
|
* Rule to disallow comma operators.
|
|
*
|
|
* @since 0.5.1
|
|
* @see https://eslint.org/docs/rules/no-sequences
|
|
*/
|
|
"no-sequences": Linter.RuleEntry<[]>;
|
|
|
|
/**
|
|
* Rule to disallow throwing literals as exceptions.
|
|
*
|
|
* @since 0.15.0
|
|
* @see https://eslint.org/docs/rules/no-throw-literal
|
|
*/
|
|
"no-throw-literal": Linter.RuleEntry<[]>;
|
|
|
|
/**
|
|
* Rule to disallow unmodified loop conditions.
|
|
*
|
|
* @since 2.0.0-alpha-2
|
|
* @see https://eslint.org/docs/rules/no-unmodified-loop-condition
|
|
*/
|
|
"no-unmodified-loop-condition": Linter.RuleEntry<[]>;
|
|
|
|
/**
|
|
* Rule to disallow unused expressions.
|
|
*
|
|
* @since 0.1.0
|
|
* @see https://eslint.org/docs/rules/no-unused-expressions
|
|
*/
|
|
"no-unused-expressions": Linter.RuleEntry<
|
|
[
|
|
Partial<{
|
|
/**
|
|
* @default false
|
|
*/
|
|
allowShortCircuit: boolean;
|
|
/**
|
|
* @default false
|
|
*/
|
|
allowTernary: boolean;
|
|
/**
|
|
* @default false
|
|
*/
|
|
allowTaggedTemplates: boolean;
|
|
}>,
|
|
]
|
|
>;
|
|
|
|
/**
|
|
* Rule to disallow unused labels.
|
|
*
|
|
* @remarks
|
|
* Recommended by ESLint, the rule was enabled in `eslint:recommended`.
|
|
*
|
|
* @since 2.0.0-rc.0
|
|
* @see https://eslint.org/docs/rules/no-unused-labels
|
|
*/
|
|
"no-unused-labels": Linter.RuleEntry<[]>;
|
|
|
|
/**
|
|
* Rule to disallow unnecessary calls to `.call()` and `.apply()`.
|
|
*
|
|
* @since 1.0.0-rc-1
|
|
* @see https://eslint.org/docs/rules/no-useless-call
|
|
*/
|
|
"no-useless-call": Linter.RuleEntry<[]>;
|
|
|
|
/**
|
|
* Rule to disallow unnecessary `catch` clauses.
|
|
*
|
|
* @remarks
|
|
* Recommended by ESLint, the rule was enabled in `eslint:recommended`.
|
|
*
|
|
* @since 5.11.0
|
|
* @see https://eslint.org/docs/rules/no-useless-catch
|
|
*/
|
|
"no-useless-catch": Linter.RuleEntry<[]>;
|
|
|
|
/**
|
|
* Rule to disallow unnecessary concatenation of literals or template literals.
|
|
*
|
|
* @since 1.3.0
|
|
* @see https://eslint.org/docs/rules/no-useless-concat
|
|
*/
|
|
"no-useless-concat": Linter.RuleEntry<[]>;
|
|
|
|
/**
|
|
* Rule to disallow unnecessary escape characters.
|
|
*
|
|
* @remarks
|
|
* Recommended by ESLint, the rule was enabled in `eslint:recommended`.
|
|
*
|
|
* @since 2.5.0
|
|
* @see https://eslint.org/docs/rules/no-useless-escape
|
|
*/
|
|
"no-useless-escape": Linter.RuleEntry<[]>;
|
|
|
|
/**
|
|
* Rule to disallow redundant return statements.
|
|
*
|
|
* @since 3.9.0
|
|
* @see https://eslint.org/docs/rules/no-useless-return
|
|
*/
|
|
"no-useless-return": Linter.RuleEntry<[]>;
|
|
|
|
/**
|
|
* Rule to disallow `void` operators.
|
|
*
|
|
* @since 0.8.0
|
|
* @see https://eslint.org/docs/rules/no-void
|
|
*/
|
|
"no-void": Linter.RuleEntry<[]>;
|
|
|
|
/**
|
|
* Rule to disallow specified warning terms in comments.
|
|
*
|
|
* @since 0.4.4
|
|
* @see https://eslint.org/docs/rules/no-warning-comments
|
|
*/
|
|
"no-warning-comments": Linter.RuleEntry<
|
|
[
|
|
{
|
|
/**
|
|
* @default ["todo", "fixme", "xxx"]
|
|
*/
|
|
terms: string[];
|
|
/**
|
|
* @default 'start'
|
|
*/
|
|
location: "start" | "anywhere";
|
|
},
|
|
]
|
|
>;
|
|
|
|
/**
|
|
* Rule to disallow `with` statements.
|
|
*
|
|
* @remarks
|
|
* Recommended by ESLint, the rule was enabled in `eslint:recommended`.
|
|
*
|
|
* @since 0.0.2
|
|
* @see https://eslint.org/docs/rules/no-with
|
|
*/
|
|
"no-with": Linter.RuleEntry<[]>;
|
|
|
|
/**
|
|
* Rule to enforce using named capture group in regular expression.
|
|
*
|
|
* @since 5.15.0
|
|
* @see https://eslint.org/docs/rules/prefer-named-capture-group
|
|
*/
|
|
"prefer-named-capture-group": Linter.RuleEntry<[]>;
|
|
|
|
/**
|
|
* Rule to require using Error objects as Promise rejection reasons.
|
|
*
|
|
* @since 3.14.0
|
|
* @see https://eslint.org/docs/rules/prefer-promise-reject-errors
|
|
*/
|
|
"prefer-promise-reject-errors": Linter.RuleEntry<
|
|
[
|
|
Partial<{
|
|
/**
|
|
* @default false
|
|
*/
|
|
allowEmptyReject: boolean;
|
|
}>,
|
|
]
|
|
>;
|
|
|
|
/**
|
|
* Rule to enforce the consistent use of the radix argument when using `parseInt()`.
|
|
*
|
|
* @since 0.0.7
|
|
* @see https://eslint.org/docs/rules/radix
|
|
*/
|
|
radix: Linter.RuleEntry<["always" | "as-needed"]>;
|
|
|
|
/**
|
|
* Rule to disallow async functions which have no `await` expression.
|
|
*
|
|
* @since 3.11.0
|
|
* @see https://eslint.org/docs/rules/require-await
|
|
*/
|
|
"require-await": Linter.RuleEntry<[]>;
|
|
|
|
/**
|
|
* Rule to enforce the use of `u` flag on RegExp.
|
|
*
|
|
* @since 5.3.0
|
|
* @see https://eslint.org/docs/rules/require-unicode-regexp
|
|
*/
|
|
"require-unicode-regexp": Linter.RuleEntry<[]>;
|
|
|
|
/**
|
|
* Rule to require `var` declarations be placed at the top of their containing scope.
|
|
*
|
|
* @since 0.8.0
|
|
* @see https://eslint.org/docs/rules/vars-on-top
|
|
*/
|
|
"vars-on-top": Linter.RuleEntry<[]>;
|
|
|
|
/**
|
|
* Rule to require parentheses around immediate `function` invocations.
|
|
*
|
|
* @since 0.0.9
|
|
* @see https://eslint.org/docs/rules/wrap-iife
|
|
*/
|
|
"wrap-iife": Linter.RuleEntry<
|
|
[
|
|
"outside" | "inside" | "any",
|
|
Partial<{
|
|
/**
|
|
* @default false
|
|
*/
|
|
functionPrototypeMethods: boolean;
|
|
}>,
|
|
]
|
|
>;
|
|
|
|
/**
|
|
* Rule to require or disallow “Yoda” conditions.
|
|
*
|
|
* @since 0.7.1
|
|
* @see https://eslint.org/docs/rules/yoda
|
|
*/
|
|
yoda:
|
|
| Linter.RuleEntry<
|
|
[
|
|
"never",
|
|
Partial<{
|
|
exceptRange: boolean;
|
|
onlyEquality: boolean;
|
|
}>,
|
|
]
|
|
>
|
|
| Linter.RuleEntry<["always"]>;
|
|
}
|