@cling/eslint-config

Rules

`eslint`

Possible Errors

These rules relate to possible syntax or logic errors in JavaScript code:

enforce "for" loop update clause moving the counter in the right direction. (for-direction)
enforce return statements in getters (getter-return)
disallow using an async function as a Promise executor (no-async-promise-executor)
disallow comparing against -0 (no-compare-neg-zero)
disallow assignment operators in conditional expressions (no-cond-assign)
disallow constant expressions in conditions (no-constant-condition)
disallow control characters in regular expressions (no-control-regex)
disallow the use of debugger (no-debugger)
disallow duplicate arguments in function definitions (no-dupe-args)
disallow duplicate conditions in if-else-if chains (no-dupe-else-if)
disallow duplicate keys in object literals (no-dupe-keys)
disallow duplicate case labels (no-duplicate-case)
disallow empty block statements (no-empty)
disallow empty character classes in regular expressions (no-empty-character-class)
disallow reassigning exceptions in catch clauses (no-ex-assign)
disallow unnecessary boolean casts (no-extra-boolean-cast)
disallow unnecessary semicolons (no-extra-semi)
disallow reassigning function declarations (no-func-assign)
disallow assigning to imported bindings (no-import-assign)
disallow variable or function declarations in nested blocks (no-inner-declarations)
disallow invalid regular expression strings in RegExp constructors (no-invalid-regexp)
disallow irregular whitespace (no-irregular-whitespace)
disallow characters which are made with multiple code points in character class syntax (no-misleading-character-class)
disallow calling global object properties as functions (no-obj-calls)
disallow calling some Object.prototype methods directly on objects (no-prototype-builtins)
disallow multiple spaces in regular expressions (no-regex-spaces)
disallow returning values from setters (no-setter-return)
disallow sparse arrays (no-sparse-arrays)
disallow confusing multiline expressions (no-unexpected-multiline)
disallow unreachable code after return, throw, continue, and break statements (no-unreachable)
disallow control flow statements in finally blocks (no-unsafe-finally)
disallow negating the left operand of relational operators (no-unsafe-negation)
require calls to isNaN() when checking for NaN (use-isnan)
enforce comparing typeof expressions against valid strings (valid-typeof)

Best Practices

These rules relate to better ways of doing things to help you avoid problems:

disallow lexical declarations in case clauses (no-case-declarations)
disallow empty destructuring patterns (no-empty-pattern)
disallow fallthrough of case statements (no-fallthrough)
disallow assignments to native objects or read-only global variables (no-global-assign)
disallow octal literals (no-octal)
disallow variable redeclaration (no-redeclare)
disallow assignments where both sides are exactly the same (no-self-assign)
disallow unused labels (no-unused-labels)
disallow unnecessary catch clauses (no-useless-catch)
disallow unnecessary escape characters (no-useless-escape)
disallow with statements (no-with)

Strict Mode

These rules relate to strict mode directives:

disallow deleting variables (no-delete-var)
disallow identifiers from shadowing restricted names (no-shadow-restricted-names)
disallow the use of undeclared variables unless mentioned in /*global */ comments (no-undef)

Stylistic Issues

These rules relate to style guidelines, and are therefore quite subjective:

disallow mixed spaces and tabs for indentation (no-mixed-spaces-and-tabs)
require super() calls in constructors (constructor-super)
disallow reassigning class members (no-class-assign)
disallow reassigning const variables (no-const-assign)
disallow duplicate class members (no-dupe-class-members)
disallow new operators with the Symbol object (no-new-symbol)
disallow this/super before calling super() in constructors (no-this-before-super)
require generator functions to contain yield (require-yield)

`import`

Static analysis

Ensure imports point to a file/module that can be resolved. (no-unresolved)
Ensure named imports correspond to a named export in the remote file. (named)
Ensure a default export is present, given a default import. (default)
Ensure imported namespaces contain dereferenced properties as they are dereferenced. (namespace)
Restrict which files can be imported in a given folder (no-restricted-paths)
Forbid import of modules using absolute paths (no-absolute-path)
Forbid require() calls with expressions (no-dynamic-require)
Forbid webpack loader syntax in imports (no-webpack-loader-syntax)
Forbid a module from importing itself (no-self-import)
Forbid a module from importing a module with a dependency path back to itself (no-cycle)
Prevent unnecessary path segments in import and require statements (no-useless-path-segments)
Prevent importing packages through relative paths (no-relative-packages)

Helpful warnings

Report any invalid exports, i.e. re-export of the same name (export)
Report use of exported name as identifier of default export (no-named-as-default)
Report use of exported name as property of default export (no-named-as-default-member)
Report imported names marked with @deprecated documentation tag (no-deprecated)
Forbid the use of extraneous packages (no-extraneous-dependencies)
Forbid the use of mutable exports with var or let. (var)
Report modules without exports, or exports without matching import in another module (no-unused-modules)

Module systems

Report potentially ambiguous parse goal (script vs. module) (script)
Report CommonJS require calls and module.exports or exports.*. (require)
Report AMD require and define calls. (require)
Forbid imports with CommonJS exports (no-import-module-exports)

Style guide

Ensure all imports appear before other statements (first)
Ensure all exports appear after other statements (exports-last)
Report repeated import of the same module in multiple places (no-duplicates)
Forbid namespace (a.k.a. "wildcard" *) imports (no-namespace)
Ensure consistent use of file extension within the import path (extensions)
Enforce a convention in module import order (order)
Enforce a newline after import statements (newline-after-import)
Prefer a default export if module exports a single name (prefer-default-export)
Forbid unassigned imports (no-unassigned-import)
Forbid named default exports (no-named-default)
Forbid anonymous values as default exports (no-anonymous-default-export)
Enforce a leading comment with the webpackChunkName for dynamic imports (dynamic-import-chunkname)

`unicorn`

Various awesome ESLint rules

Improve regexes by making them shorter, consistent, and safer. (unicorn/better-regex)
Enforce a specific parameter name in catch clauses. (unicorn/catch-error-name)
Use destructured variables over properties. (unicorn/consistent-destructuring)
Move function definitions to the highest possible scope. (unicorn/consistent-function-scoping)
Enforce no spaces between braces. (unicorn/empty-brace-spaces)
Enforce passing a message value when creating a built-in error. (unicorn/error-message)
Require escape sequences to use uppercase values. (unicorn/escape-case)
Add expiration conditions to TODO comments. (unicorn/expiring-todo-comments)
Enforce explicitly comparing the length or size property of a value. (unicorn/explicit-length-check)
Enforce a case style for filenames. (unicorn/filename-case)
Enforce specific import styles per module. (unicorn/import-style)
Enforce the use of new for all builtins, except String, Number, Boolean, Symbol and BigInt. (unicorn/new-for-builtins)
Enforce specifying rules to disable in eslint-disable comments. (unicorn/no-abusive-eslint-disable)
Prevent passing a function reference directly to iterator methods. (unicorn/no-array-callback-reference)
Disallow using the this argument in array methods. (unicorn/no-array-method-this-argument)
Enforce combining multiple Array#push() into one call. (unicorn/no-array-push-push)
Do not use leading/trailing space between console.log parameters. (unicorn/no-console-spaces)
Do not use document.cookie directly. (unicorn/no-document-cookie)
Do not use a for loop that can be replaced with a for-of loop. (unicorn/no-for-loop)
Enforce the use of Unicode escapes instead of hexadecimal escapes. (unicorn/no-hex-escape)
Require Array.isArray() instead of instanceof Array. (unicorn/no-instanceof-array)
Disallow if statements as the only statement in if blocks without else. (unicorn/no-lonely-if)
Disallow nested ternary expressions. (unicorn/no-nested-ternary)
Disallow new Array(). (unicorn/no-new-array)
Enforce the use of Buffer.from() and Buffer.alloc() instead of the deprecated new Buffer(). (unicorn/no-new-buffer)
Disallow the use of objects as default parameters. (unicorn/no-object-as-default-parameter)
Disallow process.exit(). (unicorn/no-process-exit)
Forbid classes that only have static members. (unicorn/no-static-only-class)
Disallow assigning this to a variable. (unicorn/no-this-assignment)
Disallow unreadable array destructuring. (unicorn/no-unreadable-array-destructuring)
Disallow useless undefined. (unicorn/no-useless-undefined)
Disallow number literals with zero fractions or dangling dots. (unicorn/no-zero-fractions)
Enforce proper case for numeric literals. (unicorn/number-literal-case)
Enforce the style of numeric separators by correctly grouping digits. (unicorn/numeric-separators-style)
Prefer .addEventListener() and .removeEventListener() over on-functions. (unicorn/prefer-add-event-listener)
Prefer .find(…) over the first element from .filter(…). (unicorn/prefer-array-find)
Prefer Array#flat() over legacy techniques to flatten arrays. (unicorn/prefer-array-flat)
Prefer .flatMap(…) over .map(…).flat(). (unicorn/prefer-array-flat-map)
Prefer Array#indexOf() over Array#findIndex() when looking for the index of an item. (unicorn/prefer-array-index-of)
Prefer .some(…) over .filter(…).length check and .find(…). (unicorn/prefer-array-some)
Prefer Date.now() to get the number of milliseconds since the Unix Epoch. (unicorn/prefer-date-now)
Prefer default parameters over reassignment. (unicorn/prefer-default-parameters)
Prefer Node#append() over Node#appendChild(). (unicorn/prefer-dom-node-append)
Prefer using .dataset on DOM elements over .setAttribute(…). (unicorn/prefer-dom-node-dataset)
Prefer childNode.remove() over parentNode.removeChild(childNode). (unicorn/prefer-dom-node-remove)
Prefer .textContent over .innerText. (unicorn/prefer-dom-node-text-content)
Prefer .includes() over .indexOf() and Array#some() when checking for existence or non-existence. (unicorn/prefer-includes)
Prefer KeyboardEvent#key over KeyboardEvent#keyCode. (unicorn/prefer-keyboard-event-key)
Enforce the use of Math.trunc instead of bitwise operators. (unicorn/prefer-math-trunc)
Prefer .before() over .insertBefore(), .replaceWith() over .replaceChild(), prefer one of .before(), .after(), .append() or .prepend() over insertAdjacentText() and insertAdjacentElement(). (unicorn/prefer-modern-dom-apis)
Prefer JavaScript modules (ESM) over CommonJS. (unicorn/prefer-module)
Prefer negative index over .length - index for {String,Array,TypedArray}#slice(), Array#splice() and Array#at(). (unicorn/prefer-negative-index)
Prefer using the node: protocol when importing Node.js builtin modules. (unicorn/prefer-node-protocol)
Prefer Number static properties over global ones. (unicorn/prefer-number-properties)
Prefer omitting the catch binding parameter. (unicorn/prefer-optional-catch-binding)
Prefer borrowing methods from the prototype instead of the instance. (unicorn/prefer-prototype-methods)
Prefer .querySelector() over .getElementById(), .querySelectorAll() over .getElementsByClassName() and .getElementsByTagName(). (unicorn/prefer-query-selector)
Prefer Reflect.apply() over Function#apply(). (unicorn/prefer-reflect-apply)
Prefer RegExp#test() over String#match() and RegExp#exec(). (unicorn/prefer-regexp-test)
Prefer Set#has() over Array#includes() when checking for existence or non-existence. (unicorn/prefer-set-has)
Prefer the spread operator over Array.from(…), Array#concat(…) and Array#slice(). (unicorn/prefer-spread)
Prefer String#slice() over String#substr() and String#substring(). (unicorn/prefer-string-slice)
Prefer String#startsWith() & String#endsWith() over RegExp#test(). (unicorn/prefer-string-starts-ends-with)
Prefer String#trimStart() / String#trimEnd() over String#trimLeft() / String#trimRight(). (unicorn/prefer-string-trim-start-end)
Prefer switch over multiple else-if. (unicorn/prefer-switch)
Prefer ternary expressions over simple if-else statements. (unicorn/prefer-ternary)
Enforce throwing TypeError in type checking conditions. (unicorn/prefer-type-error)
Prevent abbreviations. (unicorn/prevent-abbreviations)
Enforce using the separator argument with Array#join(). (unicorn/require-array-join-separator)
Enforce using the digits argument with Number#toFixed(). (unicorn/require-number-to-fixed-digits-argument)
Enforce using the targetOrigin argument with window.postMessage(). (unicorn/require-post-message-target-origin)
Require new when throwing an error. (unicorn/throw-new-error)

@ridedott/eslint-plugin

Comment rules

Single line comments should not be in a block comment. (@ridedott/no-single-line-comment-block)
There should not be template literals without expressions. (@ridedott/no-single-line-comment-block)

`eslint-plugin-jest`

Enforce assertion to be made in a test body (expect-expect)
Enforce lowercase test names (lowercase-name)
Disallow commented out tests (no-commented-out-tests)
Prevent calling expect conditionally (no-conditional-expect)
Disallow use of deprecated functions (no-deprecated-functions)
Disallow disabled tests (no-disabled-tests)
Avoid using a callback in asynchronous tests and hooks (no-done-callback)
Disallow using exports in files containing tests (no-export)
Disallow focused tests (no-focused-tests)
Disallow string interpolation inside snapshots (no-interpolation-in-snapshots)
Disallow Jasmine globals (no-jasmine-globals)
Disallow importing Jest (no-jest-import)
Disallow manually importing from mocks (no-mocks-import)
Disallow using expect outside of it or test blocks (no-standalone-expect)
Suggest using toBeCalledWith() or toHaveBeenCalledWith() (prefer-called-with)
Suggest using toStrictEqual() (prefer-strict-equal)
Require a message for toThrow() (require-to-throw-message)
Require test cases and hooks to be inside a describe block (require-top-level-describe)
Enforce valid describe() callback (valid-describe)
Enforce valid expect() usage (valid-expect)
Enforce having return statement when testing with promises (valid-expect-in-promise)

`typescript-eslint`

Supported Rules

Require that member overloads be consecutive (@typescript-eslint/adjacent-overload-signatures)
Disallows awaiting a value that is not a Thenable (@typescript-eslint/await-thenable)
Bans @ts- comments from being used or requires descriptions after directive (@typescript-eslint/ban-ts-comment)
Bans // tslint:<rule-flag> comments from being used (@typescript-eslint/ban-tslint-comment)
Bans specific types from being used (@typescript-eslint/ban-types)
Ensures that literals on classes are exposed in a consistent style (@typescript-eslint/class-literal-property-style)
Enforce or disallow the use of the record type (@typescript-eslint/consistent-indexed-object-style)
Consistent with type definition either interface or type (@typescript-eslint/consistent-type-definitions)
Require explicit return and argument types on exported functions' and classes' public class methods (@typescript-eslint/explicit-module-boundary-types)
Require a specific member delimiter style for interfaces and type literals (@typescript-eslint/member-delimiter-style)
Enforces using a particular method signature syntax. (@typescript-eslint/method-signature-style)
Enforces naming conventions for everything across a codebase 💭(@typescript-eslint/naming-convention)
Requires that .toString() is only called on objects which provide useful information when stringified 💭(@typescript-eslint/no-base-to-string)
Disallow non-null assertion in locations that may be confusing (@typescript-eslint/no-confusing-non-null-assertion)
Requires expressions of type void to appear in statement position 💭(@typescript-eslint/no-confusing-void-expression)
Disallow the delete operator with computed key expressions (@typescript-eslint/no-dynamic-delete)
Disallow the declaration of empty interfaces (@typescript-eslint/no-empty-interface)
Disallow usage of the any type (@typescript-eslint/no-explicit-any)
Disallow extra non-null assertion (@typescript-eslint/no-extra-non-null-assertion)
Requires Promise-like values to be handled appropriately (@typescript-eslint/no-floating-promises)
Disallow iterating over an array with a for-in loop (@typescript-eslint/no-for-in-array)
Disallows explicit type declarations for variables or parameters initialized to a number, string, or boolean (@typescript-eslint/no-inferrable-types)
Enforce valid definition of new and constructor (@typescript-eslint/no-misused-new)
Avoid using promises in places not designed to handle them (@typescript-eslint/no-misused-promises)
Disallow the use of custom TypeScript modules and namespaces (@typescript-eslint/no-namespace)
Disallows using a non-null assertion after an optional chain expression (@typescript-eslint/no-non-null-asserted-optional-chain)
Disallow the use of parameter properties in class constructors (@typescript-eslint/no-parameter-properties)
Disallows invocation of require() (@typescript-eslint/no-require-imports)
Disallow aliasing this (@typescript-eslint/no-this-alias)
Warns when a namespace qualifier is unnecessary 💭(@typescript-eslint/no-unnecessary-qualifier)
Enforces that type arguments will not be used if not required 💭(@typescript-eslint/no-unnecessary-type-arguments)
Warns if a type assertion does not change the type of an expression ✅ 🔧 💭(@typescript-eslint/no-unnecessary-type-assertion)
Disallows unnecessary constraints on generic types (@typescript-eslint/no-unnecessary-type-constraint)
Disallows calling an function with an any type value 💭(@typescript-eslint/no-unsafe-argument)
Disallows assigning any to variables and properties (@typescript-eslint/no-unsafe-assignment)
Disallows calling an any type value (@typescript-eslint/no-unsafe-call)
Disallows member access on any typed variables (@typescript-eslint/no-unsafe-member-access)
Disallows returning any from a function (@typescript-eslint/no-unsafe-return)
Disallows the use of require statements except in import statements (@typescript-eslint/no-var-requires)
Prefers a non-null assertion over explicit type cast when possible 💭(@typescript-eslint/non-nullable-type-assertion-style)
Prefer usage of as const over literal type (@typescript-eslint/prefer-as-const)
Prefer initializing each enums member value (@typescript-eslint/prefer-enum-initializers)
Prefer a ‘for-of’ loop over a standard ‘for’ loop if the index is only used to access the array being iterated (@typescript-eslint/prefer-for-of)
Use function types instead of interfaces with call signatures (@typescript-eslint/prefer-function-type)
Enforce includes method over indexOf method 💭(@typescript-eslint/prefer-includes)
Require that all enum members be literal values to prevent unintended enum member name shadow issues (@typescript-eslint/prefer-literal-enum-member)
Require the use of the namespace keyword instead of the module keyword to declare custom TypeScript modules (@typescript-eslint/prefer-namespace-keyword)
Enforce the usage of the nullish coalescing operator instead of logical chaining 💭(@typescript-eslint/prefer-nullish-coalescing)
Prefer using concise optional chain expressions instead of chained logical ands (@typescript-eslint/prefer-optional-chain)
Prefer using type parameter when calling Array#reduce instead of casting 💭(@typescript-eslint/prefer-reduce-type-parameter)
Enforce that RegExp#exec is used instead of String#match if no global flag is provided ✅ 🔧 💭(@typescript-eslint/prefer-regexp-exec)
Enforce the use of String#startsWith and String#endsWith instead of other equivalent methods of checking substrings 💭(@typescript-eslint/prefer-string-starts-ends-with)
Recommends using @ts-expect-error over @ts-ignore (@typescript-eslint/prefer-ts-expect-error)
Requires any function or method that returns a Promise to be marked async 💭(@typescript-eslint/promise-function-async)
Requires Array#sort calls to always provide a compareFunction 💭(@typescript-eslint/require-array-sort-compare)
When adding two variables, operands must both be of type number or of type string (@typescript-eslint/restrict-plus-operands)
Enforce template literal expressions to be of string type (@typescript-eslint/restrict-template-expressions)
Enforces that members of a type union/intersection are sorted alphabetically (@typescript-eslint/sort-type-union-intersection-members)
Restricts the types allowed in boolean expressions 💭(@typescript-eslint/strict-boolean-expressions)
Exhaustiveness checking in switch with union type 💭(@typescript-eslint/switch-exhaustiveness-check)
Sets preference level for triple slash directives versus ES6-style import declarations (@typescript-eslint/triple-slash-reference)
Require consistent spacing around type annotations (@typescript-eslint/type-annotation-spacing)
Requires type annotations to exist (@typescript-eslint/typedef)
Enforces unbound methods are called with their expected scope (@typescript-eslint/unbound-method)
Warns for any two overloads that could be unified into one by using a union or an optional/rest parameter (@typescript-eslint/unified-signatures) // ## Extension Rules
Enforce consistent brace style for blocks (@typescript-eslint/brace-style)
Enforces consistent spacing before and after commas (@typescript-eslint/comma-spacing)
Enforce default parameters to be last (@typescript-eslint/default-param-last)
enforce dot notation whenever possible 💭(@typescript-eslint/dot-notation)
Require or disallow spacing between function identifiers and their invocations (@typescript-eslint/func-call-spacing)
Enforce consistent indentation (@typescript-eslint/indent)
require or disallow initialization in variable declarations (@typescript-eslint/init-declarations)
Enforce consistent spacing before and after keywords (@typescript-eslint/keyword-spacing)
Require or disallow an empty line between class members (@typescript-eslint/lines-between-class-members)
Disallow generic Array constructors (@typescript-eslint/no-array-constructor)
Disallow duplicate class members (@typescript-eslint/no-dupe-class-members)
Disallow duplicate imports (@typescript-eslint/no-duplicate-imports)
Disallow empty functions (@typescript-eslint/no-empty-function)
Disallow unnecessary semicolons (@typescript-eslint/no-extra-semi)
Disallow the use of eval()-like methods (@typescript-eslint/no-implied-eval)
Disallow this keywords outside of classes or class-like objects (@typescript-eslint/no-invalid-this)
Disallow function declarations that contain unsafe references inside loop statements (@typescript-eslint/no-loop-func)
Disallow literal numbers that lose precision (@typescript-eslint/no-loss-of-precision)
Disallow magic numbers (@typescript-eslint/no-magic-numbers)
Disallow variable redeclaration (@typescript-eslint/no-redeclare)
Disallow variable declarations from shadowing variables declared in the outer scope (@typescript-eslint/no-shadow)
Disallow throwing literals as exceptions 💭(@typescript-eslint/no-throw-literal)
Disallow unused expressions (@typescript-eslint/no-unused-expressions)
Disallow unused variables (@typescript-eslint/no-unused-vars)
Disallow the use of variables before they are defined (@typescript-eslint/no-use-before-define)
Disallow unnecessary constructors (@typescript-eslint/no-useless-constructor)

Extension Rules

In some cases, ESLint provides a rule itself, but it doesn't support TypeScript syntax; either it crashes, or it ignores the syntax, or it falsely reports against it. In these cases, we create what we call an extension rule; a rule within our plugin that has the same functionality, but also supports TypeScript.

Enforce consistent spacing inside braces (@typescript-eslint/object-curly-spacing)
Disallow async functions which have no await expression (@typescript-eslint/require-await)
Enforces consistent returning of awaited values (@typescript-eslint/return-await)
Require or disallow semicolons instead of ASI (@typescript-eslint/semi)
This rule is aimed at ensuring there are spaces around infix operators. (@typescript-eslint/space-infix-ops)