Rules

Inner functions should not be accessed at default parameter declaration

this should be accessed after calling super in constructor of inherited class

Negative index should not be used on arrays

Arrow function should use parentheses to return an object literal

Assignment should not be made to property of primitive value

Array methods should not be called on the arguments object itself

An equality operator should be used instead of an assignment operator in a conditional statement

Reassignment should not be made to a variable that is declared using const keyword

The __proto__ property of an object should be assigned with a proper value.

Back reference in a regular expression should be used after the referred group

Bitwise operators should not be used where logical operators are expected

The result of String.prototype.charAt() should not be compared with a string of length 2 or more

The comparison operator should not be applied 2 or more times in a row

The result of integer-returning built-in API should not be compared with a float number

The conditional operator should be used in correct order

Character escapes should be used properly when constructing a regular expression from string literal

The handler function itself should be used at addEventListener() and removeEventListener()

finally block should not execute return or throw after try-catch block already executes return or throw

The index variable of for statement should be initialized and updated properly

String.prototype.matchAll() should be called with a global regular expression

The month argument of Date methods should not be specified as 12

Math.min and Math.max functions should be combined in correct order

The logical negation operator should be used in correct order

String functions should not be used on number values

Non-existent properties of number value should not be accessed

Object literal should not be used for comparison

in and instanceof should have a right operand of proper type

Property descriptors should be defined properly

A character range from an uppercase to a lowercase should not be used in a regular expression

Empty character classes should not be used in regular expressions

Regular expression should not be wrapped as a string at String.prototype.replace()

removeEventListener() should be called with a correct listener

String.prototype.replaceAll() should not be called with a non-global regular expression

The callback function of forEach() should not return a value uselessly

Result of String.prototype.toLowerCase() and String.prototype.toUpperCase() should be compared with a lower and upper case string

The test() method of a global regular expression should be used with caution

Suspicious type coercion should be avoided

Result of typeof should be compared with correct value

Strict mode should be declared properly

Non-constructor function should not be called with the new operator as a constructor

Non-function object should not be called as a function

require() should not be called as a constructor

Strict equality should not be used for two values with different types

Comparing NaN directly should be avoided

switch statement should not have duplicate case clauses

Function should not have duplicate parameter names

Property should not be redeclared in object literals or classes

RegExp.prototype.test() should not be used on always matching regular expressions

The search and the replace strings of String.prototype.replace() should not be the same

Getter or setter functions should avoid an infinite call by accessing themselves

All occurrences should be replaced when escaping a special character

Class should inherit from a constructor

null or undefined check should be consistent for all accesses of a variable

Read or write-only private fields should be accessed properly

Non-iterable values should not be iterated

The content of a JSX text node should not be in the form of JavaScript comment

The length property should not be misspelled as lenght

Built-in API should be called with the correct number of arguments

Built-in API should be called with arguments of correct types

Default values should be of expected types

Regular expression alternatives that are prefixes should be placed in proper order

^ and $ anchors should be placed properly in a regular expression

Comparison expressions should not be placed as indexOf() argument itself

await operator should be used at async function call when the resolved value is needed

else keyword should be used properly in if...else sequence

length property should not be omitted for the array in a loop condition

Return value of function without any return statement should not be used

Constructor of inherited class should call super

throw statement should be used to actually throw an exception

Assignments to exports variable and its properties should be properly exported

Iterator objects should not be misused as arrays

The resolve and reject function should not be called multiple times in a Promise executor

super() should be called only once in the constructor

Result of built-in API call should not be ignored when it has no side effect

Value should not be assigned to LHS which is not a reference

Properties of variables with null or undefined values should not be accessed

Radix or precision arguments of Number-related functions should not exceed the limit

React's APIs should not have typo

React component method only supported in createReactClass() API should not be overridden in ES6 class component

Return values of React lifecycle methods and API callback functions should have valid types

Generator object should not be used as a child of React element

The child node of a React context consumer should be specified properly

contextType property of a React component should be specified properly

dangerouslySetInnerHTML prop for a React DOM element should be in the form of {__html: ...}

When using dangerouslySetInnerHTML prop for a React DOM element, children should not be specified

React DOM element's attribute should not have a value of the wrong type

Event handler of a React element should not be a string

return false should not be used in a React event handler

The initial state of React component should be set to an object or null

length property itself should not be checked in the code for React child element

React special props should not be accessed

React DOM element's style property name or value should not be wrong

style property of a React DOM element should be an object

React property name in React DOM element should be pre-defined one

Updating the state inside the specific lifecycle methods of a React component should be avoided

Assignment should not be made to this.state in the React component's specific methods

React event handler should have proper this object binding

ref prop should not be used on React function components

this object should not be used in React function components

React API should be called with the correct number of arguments

React API should be called with arguments of correct types

React component should receive prop values of correct propTypes

Global event handlers added at React Effect Hooks should be properly removed at the cleanup function

Global event handlers should be properly removed during React component lifecycle

event.persist() should be called when using React synthetic events inside an asynchronous callback function

Using specific APIs inside React.render() should be avoided

Form elements should be either controlled or uncontrolled

React type checker creator itself should not be used as a prop type

innerHTML prop for a React DOM element should not be used

this should not be accessed in React static lifecycle methods

React static property should not be defined as an instance property

Properties of the uninitialized this.props should not be accessed

Unsafe legacy lifecycle methods should not be defined together with newly added replacements

Void elements should neither have children nor dangerouslySetInnerHTML prop

An initial value should be provided at Array.prototype.reduce() if the array can be empty

A reference is used on both sides of compound assignment operator

Lexical variables (let, const and class) must be declared before they are used

An extraneous semicolon should be avoided to prevent an unintentional logic change

caller and callee properties should not be accessed on arguments object for strict mode function

In strict mode, read-only variables cannot be assigned

caller and arguments properties should not be accessed on strict mode function

Strict mode function should not be called with invalid this access

switch and its cases should be compared with equal types

JavaScript syntax error

Imported bindings should be defined and exported from the requested module

Uninitialized local variables should not be accessed

Array callback function should not be used for an array with empty slots.

Unreachable code should not be used

Read-only property of Vue should not be assigned

Return value of function-typed Vue options should be a valid type

Arrow function with this accesses should not be used as a Vue instance option

Vue component name should be defined with valid string

Vue directive should be defined with a right format

Vue directive should be defined with values of correct types

Vue dynamic component should have a dynamically bound is attribute

return false should not be used in a Vue event handler

HTML syntax error in Vue template

Vue instance should be mounted on a proper element

Vue prop should be declared properly

Vue's global API Vue.set and Vue.delete should be called with proper argument

<transition-group> component of Vue should be used properly

Deprecated features of Vue should not be used

Each attribute of a Vue element should be unique

Property should be unique between Vue options

Each slot passed to a component should have unique name

The child of a <transition> component should have changes to trigger the transition

Computed properties should be accessed properly according to the existence of getter or setter

Properties of $refs should not be accessed when the component is not mounted

v-else directive should be used in proper place

Vue API should be called with the correct number of arguments

Vue API should be called with arguments of correct types

Vue option should be defined with a valid type

Vue component should receive prop values of correct prop types

Vue options should be used in proper place

Global event handlers should be properly removed during Vue component lifecycle

Ref objects should be used after unwrapping

Validator functions for Vue prop and event should have return values

Lifecycle hooks and watchers should not be registered after await in an async function

Computed and data properties should not be used inside the data() of a Vue component

The first variable of v-for should not be used as an index of the iterated array

v-slot directive should be used properly

Vue template should have a single root element

Vue option should not have typo

v-on directive should not have passive and prevent modifiers at the same time

ref attribute should not be redundantly defined

Template should not be defined redundantly for a Vue component

Vue option's property name should not be a reserved name of Vue

this object should not be used in the Vue setup function

The data function of a Vue component should return a newly created object

Element iterated with v-for should not have a static key attribute

Vue <template> element should not have v-show directive

Uninitialized properties of a Vue instance should not be accessed

v-once directive should be used properly

v-bind should not be used on Vue directives

if branch bodies should be formatted unambiguously

The indentation of else branch should be unambiguous

Callback function argument of Array functions should have return statement

Variables should be declared before they are assigned

The same value is assigned to the variable again

await operator should not be used on a non-Promise value

with statement should not be used

Constant expression should not be used in the conditional statements

Functions or variables should not be redeclared

Parentheses should not be used for an already parenthesized expression

Character classes in a regular expression should not have duplicate characters

Empty block statements should not be used in conditional statements

for-in loop should not be used on arrays

Branches in the conditional statements should not have the same implementation

Comma should not be missing between function arguments or array elements

The inequality operator should be preferred over negating the equality comparison result

Execution should not fall through after reject call in a Promise executor

Using the return value of ReactDOM.render() should be avoided

Deprecated prop for a React DOM element should not be used

React.PureComponent prop should not be specified with a newly created object

React DOM elements should be nested properly

key prop should be defined at each element inside the children of a React element

this.state value may not be directly used when updating the state in React component

A component extending React.PureComponent should not override shouldComponentUpdate() lifecycle method

Unused ownProps parameter of the React Redux mapStateToProps function should be removed

Return value of getSnapshotBeforeUpdate() should be used

The dependency of a React Hook should not be specified with a newly created object

The argument function of React.forwardRef() should use its second ref parameter

React Memoize Hooks should not be used fruitlessly

Useless PropTypes declaration should be removed

Overridden shouldComponentUpdate() should not always return a truthy value

Operands always having the same value should be avoided

Setter functions should not return values

Loop iteration should not be skipped after removing an element with Array.prototype.splice()

Cases in switch statement should not fall through to the next one

Functions should not be called with extra arguments

The logical negation operator should not be applied 3 or more times in a row

Unexpected global variable declaration should be avoided

Unused local variables and functions should be removed

Result of expressions should be used

Unused imported bindings should be removed

Unused label should be removed

Unused parameters of local function should be removed

Unused private fields in a class should be removed

Unused require() should be removed

Dead variables should not be used

Elements added to an array should be used

Arrow functions cannot be bound

Function.prototype.call() should not be used when this context remains the same

A catch clause should not just rethrow the exception

delete operator should not be used on local variables

Loop should not be used when only a single iteration is needed

Branches of v-if directive should not have the same implementation

The Vue component iterated with v-for should have a v-bind:key attribute

Getter function of computed property should have return values

Props of a Vue component should not be mutated

Vue inline event handlers should not be redundantly used

<textarea> with v-model directive should not have children

Variables declared in a Vue template should be used

Local components declared in a Vue component should be used

v-if directive should use variables defined at v-for appearing on the same element