TypeScript lint options

Popularity (by total correct streak): 3
Popularity (by number of users): 1


adjacent-overload-signatures Enforces function overloads to be consecutive  
ban-types Bans specific types from being used (revised)
member-access Requires explicit visibility declarations for class members  
member-ordering Enforces member ordering (revised)
no-any Disallows usages of any as a type declaration  
no-empty-interface Forbids empty interfaces  
no-import-side-effect Avoid import statements with side-effect  
no-inferrable-types Disallows explicit type declarations for variables or parameters initialized to a number, string, or boolean  
no-internal-module Disallows internal module  
no-magic-numbers Disallows the use of constant number values outside of variable assignments. (revised)
no-namespace Disallows use of internal modules and namespaces (revised)
no-non-null-assertion Disallows non-null assertions  
no-reference Disallows /// <reference path=> imports (revised)
no-unnecessary-type-assertion Warns if a type assertion does not change the type of an expression  
no-var-requires Disallows the use of require statements except in import statements (revised)
only-arrow-functions Disallows traditional (non-arrow) function expressions  
prefer-for-of Recommends a ‘for-of’ loop over a standard ‘for’ loop if the index is only used to access the array being iterated  
promise-function-async Requires any function or method that returns a promise to be marked async  
typedef Requires type definitions to exist  
typedef-whitespace Requires or disallows whitespace for type definitions (revised)
unified-signatures Warns for any two overloads that could be unified into one by using a union or an optional/rest parameter  
await-promise Warns for an awaited value that is not a Promise  
ban Bans the use of specific functions or global methods  
curly Enforces braces for if/for/do/while statements  
forin Requires a for ... in statement to be filtered with an if statement  
import-blacklist Disallows importing the specified modules directly via import and require (revised)
label-position Only allows labels in sensible locations (revised)
no-arg Disallows use of arguments.callee  
no-bitwise Disallows bitwise operators (revised)
no-conditional-assignment Disallows any type of assignment in conditionals (revised)
no-console Bans the use of specified console methods  
no-construct Disallows access to the constructors of String, Number, and Boolean (revised)
no-debugger Disallows debugger statements  
no-duplicate-super Warns if ‘super()’ appears twice in a constructor  
no-duplicate-variable Disallows duplicate variable declarations in the same block scope (revised)
no-empty Disallows empty blocks. Blocks with a comment inside are not considered empty  
no-eval Disallows eval function invocations  
no-floating-promises Promises returned by functions must be handled appropriately (revised)
no-for-in-array Disallows iterating over an array with a for-in loop  
no-inferred-empty-object-type Disallow type inference of {} (empty object type) at function and constructor call sites  
no-invalid-template-strings Warns on use of ${ in non-template strings  
no-invalid-this Disallows using the this keyword outside of classes.  
no-misused-new Warns on apparent attempts to define constructors for interfaces or new for classes  
no-null-keyword Disallows use of the null keyword literal  
no-object-literal-type-assertion Forbids an object literal to appear in a type assertion expression  
no-shadowed-variable Disallows shadowing variable declarations  
no-sparse-arrays Forbids array literals to contain missing elements  
no-string-literal Disallows object access via string literals  
no-string-throw Flags throwing plain strings or concatenations of strings because only Errors produce proper stack traces  
no-switch-case-fall-through Disallows falling through case statements  
no-unbound-method Warns when a method is used as outside of a method call  
no-unsafe-any Warns when using an expression of type ‘any’ in a dynamic way (revised)
no-unsafe-finally Disallows control flow statements, such as return, continue, break and throws in finally blocks  
no-unused-expression Disallows unused expression statements (revised)
no-unused-variable Disallows unused imports, variables, functions and private class members (revised)
no-use-before-declare Disallows usage of variables before their declaration  
no-var-keyword Disallows usage of the var keyword  
no-void-expression Requires expressions of type void to appear in statement position  
radix Requires the radix parameter to be specified when calling parseInt  
restrict-plus-operands When adding two variables, operands must both be of type number or of type string  
strict-boolean-expressions Restricts the types allowed in boolean expressions (revised)
strict-type-predicates Warns for type predicates that are always true or always false  
switch-default Require a default case in all switch statements  
triple-equals Requires === and !== in place of == and !=  
typeof-compare Makes sure result of typeof is compared to correct string values  
use-isnan Enforces use of the isNaN() function to check for NaN references instead of a comparison to the NaN constant  
cyclomatic-complexity Enforces a threshold of cyclomatic complexity  
deprecation Warns when deprecated APIs are used  
eofline Ensures the file ends with a newline  
indent Enforces indentation with tabs or spaces  
linebreak-style Enforces a consistent linebreak style  
max-classes-per-file A file may not contain more than the specified number of classes  
max-file-line-count Requires files to remain under a certain number of lines  
max-line-length Requires lines to be under a certain max length  
no-default-export Disallows default exports in ES6-style modules  
no-mergeable-namespace Disallows mergeable namespaces in the same file  
no-require-imports Disallows invocation of require()  
object-literal-sort-keys Requires keys in object literals to be sorted alphabetically  
prefer-const Requires that variable declarations use const instead of let and var if possible  
trailing-comma Requires or disallows trailing commas in array and object literals, destructuring assignments, function typings, named imports and exports and function parameters  
align Enforces vertical alignment  
array-type Requires using either ‘T[]’ or ‘Array' for arrays  
arrow-parens Requires parentheses around the parameters of arrow function definitions  
arrow-return-shorthand Suggests to convert () => { return x; } to () => x  
callable-types An interface or literal type with just a call signature can be written as a function type  
class-name Enforces PascalCased class and interface names  
comment-format Enforces formatting rules for single-line comments  
completed-docs Enforces documentation for important items be filled out  
file-header Enforces a certain header comment for all files, matched by a regular expression  
import-spacing Ensures proper spacing between import statement keywords  
interface-name Requires interface names to begin with a capital ‘I’  
interface-over-type-literal Prefer an interface declaration over a type literal (type T = { ... })  
jsdoc-format Enforces basic format rules for JSDoc comments  
match-default-export-name Requires that a default import have the same name as the declaration it imports (revised)
newline-before-return Enforces blank line before return when not the only line in the block  
new-parens Requires parentheses when invoking a constructor via the new keyword  
no-angle-bracket-type-assertion Requires the use of as Type for type assertions instead of <Type>  
no-boolean-literal-compare Warns on comparison to a boolean literal, as in x === true  
no-irregular-whitespace Disallow irregular whitespace outside of strings and comments  
no-parameter-properties Disallows parameter properties in class constructors  
no-reference-import Don’t if you import “foo” anyway  
no-trailing-whitespace Disallows trailing whitespace at the end of a line  
no-unnecessary-callback-wrapper Replaces x => f(x) with just f (revised)
no-unnecessary-initializer Forbids a ‘var’/’let’ statement or destructuring initializer to be initialized to ‘undefined’  
no-unnecessary-qualifier Warns when a namespace qualifier (A.x) is unnecessary  
number-literal-format Checks that decimal literals should begin with ‘0.’ instead of just ‘.’, and should not end with a trailing ‘0’  
object-literal-key-quotes Enforces consistent object literal property quote style  
object-literal-shorthand Enforces use of ES6 object literal shorthand when possible  
one-line Requires the specified tokens to be on the same line as the expression preceding them  
one-variable-per-declaration Disallows multiple variable definitions in the same declaration statement  
ordered-imports Requires that import statements be alphabetized  
prefer-function-over-method Warns for class methods that do not use ‘this’  
prefer-method-signature Prefer foo(): void over foo: () => void in interfaces and types  
prefer-switch Prefer a switch statement to an if statement with simple === comparisons  
prefer-template Prefer a template expression over string literal concatenation  
quotemark Requires single or double quotes for string literals  
return-undefined Prefer return; in void functions and return undefined; in value-returning functions  
semicolon Enforces consistent semicolon usage at the end of every statement  
space-before-function-paren Require or disallow a space before function parenthesis  
variable-name Checks variable names for various errors  
whitespace Enforces whitespace style conventions  

Quisition is a browser-based flashcard system that repeats old cards and introduces new ones at optimal time intervals. You can create your own card packs or use those developed by others.