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.
