TypeScript (and JavaScript) Plugin

Rules for linting JavaScript and TypeScript code, including the latest and greatest powerful typed linting rules.
This plugin comes packaged with the flint npm package.

Presets

Flint’s TypeScript plugin provides the following presets:

Preset	Recommended	Description
`logical`	✅ Always	Common rules for finding bugs and enforcing good logical practices.
`logicalStrict`	☑️ When Ready	Additional rules for finding bugs and enforcing good logical practices.
`stylistic`	✅ Always	Common rules for consistent styling and best stylistic practices.
`stylisticStrict`	☑️ When Ready	Additional rules for consistent styling and best stylistic practices.
`untyped`		Extra rules for files that aren’t type-checked by TypeScript.

If you are just getting started with linting, Flint recommends using the logical and stylistic presets:

import { defineConfig, ts } from "flint";

export default defineConfig({
  use: [
    {
      files: ts.files.all,
      rules: [ts.presets.logical, ts.presets.stylistic],
    },
  ],
});

If you are experienced with both JavaScript/TypeScript and linting, Flint recommends using the logicalStrict and stylisticStrict presets:

import { defineConfig, ts } from "flint";

export default defineConfig({
  use: [
    {
      files: ts.files.all,
      rules: [ts.presets.logicalStrict, ts.presets.stylisticStrict],
    },
  ],
});

`logical`

Rules that find bugs and enforce good logical practices for most-to-all JavaScript and TypeScript files.

import { defineConfig, ts } from "flint";

export default defineConfig({
  use: [
    {
      files: ts.files.all,
      rules: ts.presets.logical,
    },
  ],
});

`logicalStrict`

Additional logical rules that enforce best practices which are not always straightforward to implement. These rules are recommended for projects where a majority of developers are experienced with both JavaScript/TypeScript and using a linter.

import { defineConfig, ts } from "flint";

export default defineConfig({
  use: [
    {
      files: ts.files.all,
      rules: ts.presets.logicalStrict,
    },
  ],
});

This preset’s rules are a superset of those in logical.

`stylistic`

Rules that enforce consistent styling and best stylistic practices for most-to-all JavaScript and TypeScript files.

import { defineConfig, ts } from "flint";

export default defineConfig({
  use: [
    {
      files: ts.files.all,
      rules: ts.presets.stylistic,
    },
  ],
});

`stylisticStrict`

Additional stylistic rules that enforce best practices which are not always straightforward to implement. These rules are recommended for projects where a majority of developers are experienced with both JavaScript/TypeScript and using a linter.

import { defineConfig, ts } from "flint";

export default defineConfig({
  use: [
    {
      files: ts.files.all,
      rules: ts.presets.stylisticStrict,
    },
  ],
});

This preset’s rules are a superset of those in stylistic.

`untyped`

Rules that fill in rudimentary safety practices that would normally be caught by TypeScript.

import { defineConfig, ts } from "flint";

export default defineConfig({
  use: [
    {
      files: ts.files.all,
      rules: ts.presets.untyped,
    },
  ],
});

The untyped preset is broadly applicable for JavaScript files that aren’t type-checked by TypeScript. For long-lived projects, Flint recommends using this only as a stopgap measure pending converting files fully to TypeScript.

Rules

Implemented: 244 of 404 (60.3%)

Flint Rule	Preset
`accessorPairTypes`Reports mismatched types between getter and setter accessor pairs.	logical
`anyArguments`Reports calling a function with a value typed as `any` as an argument.	logical
`anyAssignments`Reports assigning a value with type `any` to variables and properties.	logical
`anyCalls`Reports calling a value with type `any`.	logical
`anyMemberAccess`Reports member access on a value with type `any`.	logical
`anyReturns`Reports returning a value with type `any` from a function.	logical
`arguments`Reports using the arguments object instead of rest parameters.	logical
`arrayConstructors`Reports using the `Array` constructor to create arrays instead of array literal syntax.	logical
`arrayElementDeletions`Reports using the `delete` operator on array values.	logical
`arrayEmptyCallbackSlots`Reports array methods with callbacks that will never be invoked on arrays with empty slots.	logical
`arrayMapIdentities`Reports using `.flatMap()` with an identity function that returns its argument unchanged.	logical
`arrayUnnecessaryLengthChecks`Reports unnecessary array length checks before `.some()` or `.every()` calls.	logical
`asyncFunctionAwaits`	logical
`asyncPromiseExecutors`Reports using async functions as Promise executor functions.	logical
`asyncUnnecessaryPromiseWrappers`Reports unnecessary `Promise.resolve()` or `Promise.reject()` in async contexts.	logical
`awaitThenable`	logical
`caseDuplicates`Reports switch statements with duplicate case clause test expressions.	logical
`caseFallthroughs`Reports switch case clauses that fall through unexpectedly.	logical
`catchCallbackTypes`Reports `Promise` catch callback parameters that are not typed as unknown.	logical
`charAtComparisons`Reports comparing charAt() results with strings longer than one character.	logical
`constVariables`	logical
`dateConstructorClones`Prefer passing a `Date` directly to the `Date` constructor when cloning, rather than calling `getTime()`.	logical
`debuggerStatements`Reports using debugger statements.	logical
`defaultCaseLast`Reports switch statements where the default clause is not last.	logical
`deprecated`Disallow using code marked as @deprecated.	logical
`dynamicDeletes`Disallow using the delete operator on computed key expressions.	logical
`elseIfDuplicates`Reports duplicate conditions in if-else-if chains that make code unreachable.	logical
`emptyDestructures`Reports using empty destructuring patterns that destructure no values.	logical
`emptyEnums`Reports empty enum declarations with no members.	logical
`emptyExports`Reports empty export statements that don't make a file a module.	logical
`emptyObjectTypes`Reports empty object type literals and empty interfaces that are often used incorrectly.	logical
`enumMixedValues`	logical
`enumValueConsistency`Reports enums that contain both string and number members.	logical
`enumValueDuplicates`Reports enum members with duplicate values.	logical
`equalityOperators`	logical
`errorUnnecessaryCaptureStackTraces`Reports unnecessary Error.captureStackTrace() calls in Error subclass constructors.	logical
`evals`Reports uses of the eval function.	logical
`exceptionAssignments`Reports reassigning exception parameters in catch clauses.	logical
`explicitAnys`Reports explicit uses of the any type.	logical
`exportMutables`Reports exporting mutable bindings (let or var).	logical
`fetchMethodBodies`Disallow providing a body with GET or HEAD fetch requests.	logical
`finallyStatementSafety`Reports control flow statements in `finally` blocks that can override control flow in `try`/`catch` blocks.	logical
`floatingPromises`	logical
`forInArrays`Reports iterating over an array with a for-in loop.	logical
`functionCurryingRedundancy`Reports using `.apply()` or `.call()` or when the context (`this` value) provides no benefit.	logical
`functionNewCalls`Reports using the Function constructor to create functions from strings.	logical
`generatorFunctionYields`Reports generator functions that do not yield values.	logical
`impliedEvals`Reports using string arguments in setTimeout, setInterval, setImmediate, execScript, or the Function constructor.	logical
`importEmptyBlocks`Reports empty named import blocks.	logical
`importSelf`	logical
`importTypeSideEffects`Reports imports that use inline type qualifiers on all specifiers when a top-level type qualifier should be used instead.	logical
`instanceOfArrays`Reports using `instanceof Array` instead of `Array.isArray()`.	logical
`irregularWhitespaces`Reports irregular whitespace characters that can cause issues with code parsing and display.	logical
`isNaNComparisons`Reports comparisons with NaN, which should use Number.isNaN() instead.	logical
`meaninglessVoidOperators`Reports using the void operator on expressions that are already void or undefined.	logical
`misleadingVoidExpressions`Require expressions of type void to appear in statement position.	logical
`misusedPromises`	logical
`moduleSpecifierLists`Require non-empty specifier lists in import and export statements.	logical
`namespaceDeclarations`Reports using legacy `namespace` declarations.	logical
`negativeZeroComparisons`Reports comparisons with -0 that may not behave as expected.	logical
`newDefinitions`Reports misleading constructor and `new` definitions in interfaces and classes.	logical
`newExpressions`Reports standalone new expressions that don't use the constructed object.	logical
`nonNullAssertedOptionalChains`Reports non-null assertions on optional chain expressions.	logical
`nonOctalDecimalEscapes`Reports non-octal decimal escape sequences (\8 and \9) in string literals.	logical
`numberMethodRanges`Reports when number method arguments are outside their valid range.	logical
`numericErasingOperations`Reports operations that always result in zero, such as multiplication by zero.	logical
`numericPrecision`Reports numeric literals that lose precision when converted to JavaScript numbers.	logical
`objectCalls`Prefer `{}` object literal notation or `Object.create` instead of calling or constructing `Object`.	logical
`objectPrototypeBuiltIns`Reports direct calls to Object.prototype methods on object instances.	logical
`objectSpreadUnnecessaryFallbacks`Reports empty object fallbacks in object spread expressions that have no effect.	logical
`parameterPropertyAssignment`	logical
`parameterReassignments`Disallow reassignment of function parameters.	logical
`parseIntRadixes`Reports parseInt calls that are missing or have an invalid radix parameter.	logical
`plusOperands`	logical
`promiseExecutorReturns`	logical
`promiseFinallyReturns`	logical
`promiseMethodSingleArrayArguments`	logical
`promiseRejectErrors`	logical
`recursionOnlyArguments`Reports function parameters that are only used in recursive calls.	logical
`redundantTypeConstituents`Reports union and intersection type constituents that are redundant or override other types.	logical
`regexAllGlobalFlags`Reports `matchAll()` and `replaceAll()` calls with regex arguments missing the global flag.	logical
`regexAmbiguousInvalidity`Reports regex patterns that use ambiguous or invalid syntax from Annex B.	logical
`regexContradictoryAssertions`Reports elements in regular expressions that contradict assertions.	logical
`regexControlCharacterEscapes`Reports control characters that are not escaped using standard escape sequences.	logical
`regexControlCharacters`Reports control characters in regular expressions.	logical
`regexDuplicateCharacterClassCharacters`Reports duplicate characters in regular expression character classes.	logical
`regexDuplicateDisjunctions`	logical
`regexEmptyAlternatives`Reports empty alternatives in regular expressions that may indicate a mistake.	logical
`regexEmptyCapturingGroups`Reports capturing groups that only capture empty strings.	logical
`regexEmptyCharacterClasses`Reports character classes that match no characters.	logical
`regexEmptyGroups`Reports empty groups in regular expressions.	logical
`regexEmptyLazyQuantifiers`Reports lazy quantifiers at the end of regular expressions.	logical
`regexEmptyLookaroundsAssertions`Reports empty lookahead and lookbehind assertions in regular expressions.	logical
`regexEmptyStringLiterals`Reports empty string literals in character classes.	logical
`regexIgnoreCaseFlags`Reports regex patterns that can be simplified by using the i (ignore case) flag.	logical
`regexInvisibleCharacters`Reports invisible characters in regex patterns that should use escape sequences instead.	logical
`regexLiterals`Use a regular expression literal when the pattern is static.	logical
`regexLookaroundQuantifierOptimizations`Reports non-constant quantifiers in lookaround assertions that could be simplified.	logical
`regexMisleadingCapturingGroups`Reports capturing groups that capture less text than their pattern suggests.	logical
`regexMisleadingQuantifiers`Reports quantifiers whose minimum implies they must match but whose element can match empty.	logical
`regexMisleadingUnicodeCharacters`Reports characters in regex character classes that appear as single visual characters but are made of multiple code points.	logical
`regexNonStandardFlags`Reports non-standard regular expression flags.	logical
`regexObscureRanges`Reports obscure character ranges in regular expressions.	logical
`regexOctalEscapes`Reports octal escape sequences in regular expressions.	logical
`regexQuantifierOptimizations`	logical
`regexSetOperationOptimizations`Reports set operations in regular expressions that can be simplified.	logical
`regexStandaloneBackslashes`Reports standalone backslashes in regex patterns that look like incomplete escape sequences.	logical
`regexSuperLinearBacktracking`Reports regular expressions with exponential or polynomial backtracking.	logical
`regexSuperLinearMoves`Reports quantifiers that can cause quadratic regex matching time.	logical
`regexUnnecessaryAssertions`	logical
`regexUnnecessaryBackreferences`	logical
`regexUnnecessaryCharacterClasses`Reports character classes that wrap a single element that does not require brackets.	logical
`regexUnnecessaryCharacterRanges`Reports character class ranges that span only one or two characters.	logical
`regexUnnecessaryDisjunctions`Reports single-character alternatives in string disjunctions.	logical
`regexUnnecessaryDollarReplacements`Reports replacement string references to capturing groups that do not exist in the pattern.	logical
`regexUnnecessaryLookaroundAssertions`	logical
`regexUnnecessaryNestedAssertions`	logical
`regexUnnecessaryNestedQuantifiers`	logical
`regexUnnecessaryNumericQuantifiers`	logical
`regexUnnecessaryOptionalAssertions`	logical
`regexUnnecessaryReferentialBackreferences`	logical
`regexUnnecessarySetOperands`	logical
`regexUnusedCapturingGroups`	logical
`regexUnusedFlags`	logical
`regexUnusedLazyQuantifiers`	logical
`regexUnusedQuantifiers`	logical
`regexValidity`	logical
`regexZeroQuantifiers`	logical
`requireImports`	logical
`returnAwaitPromises`	logical
`selfAssignments`Reports self-assignments which have no effect and are likely errors.	logical
`singleVariableDeclarations`	logical
`sparseArrays`Reports array literals with holes (sparse arrays).	logical
`strictBooleanExpressions`	logical
`stringCaseMismatches`	logical
`templateExpressionValues`	logical
`thisAliases`	logical
`throwErrors`	logical
`tripleSlashReferences`	logical
`tripleSlashReferenceValidity`	logical
`tsComments`	logical
`typeConstituentDuplicates`	logical
`unboundMethods`	logical
`unnecessaryBind`	logical
`unnecessaryCatches`Reports catch clauses that only rethrow the caught error without modification.	logical
`unnecessaryComparisons`	logical
`unnecessaryConditions`	logical
`unnecessaryContinues`	logical
`unnecessaryLogicalComparisons`	logical
`unnecessaryMathClamps`	logical
`unnecessaryNumericFractions`	logical
`unnecessarySpreads`	logical
`unnecessaryTemplateExpressions`	logical
`unnecessaryTypeArguments`	logical
`unnecessaryTypeAssertions`	logical
`unnecessaryTypeConstraints`	logical
`unnecessaryTypeConversions`	logical
`unnecessaryTypeParameters`	logical
`unnecessaryUndefinedDefaults`	logical
`unnecessaryUseStricts`	logical
`unsafeDeclarationmerging`	logical
`unsafeEnumComparisons`	logical
`unsafeFunctionTypes`	logical
`unsafeToString`	logical
`unsafeTypeAssertions`	logical
`unsafeUnaryNegations`	logical
`unusedExpressions`	logical
`unusedPrivateClassMembers`	logical
`unusedSwitchStatements`	logical
`unusedValues`	logical
`unusedVariables`	logical
`uselessDefaultAssignments`	logical
`wrapperObjects`Flags using `new` with `Boolean`, `Number`, or `String`, which creates wrapper objects instead of primitives.	logical
`wrapperObjectTypes`	logical
`accessorThisRecursion`Reports recursive access to this within getters and setters.	logical (strict)
`arrayReduceTypeArguments`Reports `Array#reduce` calls using type assertions on initial values instead of type arguments.	logical (strict)
`awaitInsidePromiseMethods`	logical (strict)
`caughtErrorCauses`	logical (strict)
`dateNowTimestamps`Prefer the shorter `Date.now()` to get the number of milliseconds since the Unix Epoch.	logical (strict)
`directivePairs`	logical (strict)
`enumMemberLiterals`Requires all enum members to be literal values.	logical (strict)
`errorMessages`Requires a message value when creating a built-in error.	logical (strict)
`errorSubclassProperties`Reports incorrect Error subclass definitions that don't follow best practices.	logical (strict)
`invalidVoidTypes`	logical (strict)
`nonNullAssertedNullishCoalesces`Reports non-null assertions on the left side of nullish coalescing operators.	logical (strict)
`nonNullAssertions`	logical (strict)
`numberStaticMethods`Reports using legacy global functions instead of `Number` static methods.	logical (strict)
`returnThisTypes`	logical (strict)
`selfComparisons`Reports comparing a value to itself.	logical (strict)
`stringCodePoints`	logical (strict)
`unifiedSignatures`	logical (strict)
`extraneousClasses`Reports classes used as static namespaces.	logicalStrict
`importExtraneousDependencies`	none
`accessorPairGroups`Reports getter and setter accessors for the same property that are not adjacent.	stylistic
`arrayDeleteUnnecessaryCounts`Reports using `.length` or `Infinity` as the `deleteCount` or `skipCount` argument of `Array#splice()` or `Array#toSpliced()`.	stylistic
`arrayExistenceChecksConsistency`Reports inconsistent styles for checking element existence using index methods.	stylistic
`arrayFinds`Reports using `.filter()[0]` instead of `.find()` when looking for a single element.	stylistic
`arrayFlatUnnecessaryDepths`Reports using `1` as the depth argument of `.flat()` since it is the default.	stylistic
`arrayIncludes`Reports using `.indexOf()` comparisons that can be replaced with `.includes()`.	stylistic
`arrayLoops`Reports using `.forEach()` when a for-of loop can be used.	stylistic
`arrayMutableReverses`Reports `.reverse()` calls on arrays that mutate the original array.	stylistic
`arrayMutableSorts`Reports `.sort()` calls on arrays that mutate the original array.	stylistic
`arraySliceUnnecessaryEnd`Reports unnecessary `end` argument in `.slice()` calls when it equals the length or is `Infinity`.	stylistic
`arrayTernarySpreadingConsistency`Reports inconsistent types when spreading a ternary in an array literal.	stylistic
`arrayTypes`Reports array type syntax that doesn't match the configured style.	stylistic
`asConstAssertions`Reports using explicit literal types when `as const` can be used.	stylistic
`assignmentOperatorShorthands`Prefer logical assignment operator shorthand expressions.	stylistic
`builtinConstructorNews`Enforces using new for constructors that require it, and disallows new for primitive coercion functions.	stylistic
`chainedAssignments`Reports using chained assignment expressions (e.g., a = b = c).	stylistic
`classLiteralProperties`Reports getters that return literal values instead of using readonly class fields.	stylistic
`consecutiveNonNullAssertions`Reports unnecessary extra non-null assertions.	stylistic
`constructorGenericCalls`Reports inconsistent placement of type arguments in constructor calls.	stylistic
`emptyBlocks`Reports empty block statements that should contain code.	stylistic
`emptyModuleAttributes`Reports empty import/export attributes that serve no purpose.	stylistic
`emptyStaticBlocks`Reports empty static initialization blocks within class declarations.	stylistic
`emptyTypeParameterLists`Reports empty type parameter lists in type aliases and interfaces.	stylistic
`exponentiationOperators`Prefers the ** operator over Math.pow().	stylistic
`exportFromImports`Reports imports that are re-exported and could use export...from syntax instead.	stylistic
`forDirections`Reports for loops with counter variables that move in the wrong direction.	stylistic
`functionApplySpreads`Prefer the spread operator over `.apply()` calls.	stylistic
`functionTypeDeclarations`	stylistic
`importCycles`	stylistic
`importDuplicates`	stylistic
`importUnnecessaryPathSegments`	stylistic
`indexedObjectTypes`Reports indexed object types that don't match the configured style.	stylistic
`jsdocAccessTags`	stylistic
`jsdocEmptyBlocks`	stylistic
`jsdocEmptyTags`	stylistic
`jsdocImplementsTags`	stylistic
`jsdocParameterNames`	stylistic
`jsdocPropertyNames`	stylistic
`jsdocRedundantTypes`	stylistic
`jsdocTemplateNames`	stylistic
`jsdocTypesSyntax`	stylistic
`jsdocUnnecessaryReturns`	stylistic
`jsdocUnnecessaryYields`	stylistic
`jsdocValidTypes`	stylistic
`jsdocValues`	stylistic
`jsdocYields`	stylistic
`literalConstructorWrappers`Prefers literal syntax over constructor function calls for primitive values.	stylistic
`methodSignatureStyles`	stylistic
`multilineAmbiguities`Reports ambiguous multiline expressions that could be misinterpreted.	stylistic
`namespaceKeywords`Reports using `module` keyword instead of `namespace` for TypeScript namespaces.	stylistic
`nestedStandaloneIfs`Reports `if` statements that are the only statement inside an `else` block or inside another `if` without an `else`.	stylistic
`nonNullableTypeAssertions`Reports type assertions that can be replaced with non-null assertions.	stylistic
`nullishCoalescingOperators`Prefer nullish coalescing operator (??) over logical OR (\|\|) for nullish values.	stylistic
`numericLiteralParsing`Reports parseInt calls with binary, hexadecimal, or octal strings that can be replaced with numeric literals.	stylistic
`objectAssignSpreads`Prefer object spread syntax over `Object.assign()` when the first argument is an object literal.	stylistic
`objectHasOwns`Prefer Object.hasOwn() over Object.prototype.hasOwnProperty.call() for checking own properties.	stylistic
`objectShorthand`Object property and method definitions can use shorthand syntax when the key matches the value identifier or when a function expression is assigned.	stylistic
`objectTypeDefinitions`Prefer interface declarations over type aliases for object types.	stylistic
`operatorAssignmentShorthand`Prefer assignment operator shorthand where possible.	stylistic
`optionalChainOperators`	stylistic
`overloadSignaturesAdjacent`Require that function overload signatures be consecutive.	stylistic
`promiseFunctionAsync`	stylistic
`propertyAccessNotation`Reports bracket notation property access when dot notation can be used.	stylistic
`regexCharacterClassRanges`Reports character class elements that can be simplified to ranges.	stylistic
`regexCharacterClassSetOperations`Reports lookarounds that can be replaced with character class set operations.	stylistic
`regexConciseCharacterClassNegations`Reports negated character classes that can use shorthand escapes.	stylistic
`regexDollarEscapes`Reports replacement strings with unescaped `$` that should use `$$`.	stylistic
`regexEscapeBackspaces`Reports escape backspace (`[\b]`) in character classes.	stylistic
`regexPredefinedAssertions`	stylistic
`regexRepeatQuantifiers`Reports consecutive identical elements in regular expressions that should use quantifiers.	stylistic
`regexTestMethods`Reports match() and exec() calls that should use RegExp.prototype.test() for boolean checks.	stylistic
`regexUnicodeProperties`	stylistic
`regexUnnecessaryEscapes`	stylistic
`responseMethods`	stylistic
`returnAssignments`Reports using assignment expressions in return statements.	stylistic
`shadows`	stylistic
`stringStartsEndsWith`	stylistic
`symbolDescriptions`Reports Symbol() calls without description arguments.	stylistic
`tslintComments`	stylistic
`typeAssertions`	stylistic
`typeExports`	stylistic
`typeImports`	stylistic
`undefinedInitialValues`	stylistic
`unicodeBOMs`Reports files with Unicode Byte Order Marks (BOMs).	stylistic
`unnecessaryBlocks`Reports standalone block statements that don't create a meaningful scope.	stylistic
`unnecessaryBooleanCasts`	stylistic
`unnecessaryComputedKeys`	stylistic
`unnecessaryConcatenation`Reports string concatenation using the + operator when both operands are string literals.	stylistic
`unnecessaryConstructors`	stylistic
`unnecessaryEscapes`	stylistic
`unnecessaryQualifiers`	stylistic
`unnecessaryRenames`	stylistic
`unnecessaryReturns`	stylistic
`unnecessaryTypeAnnotations`	stylistic
`unusedLabels`	stylistic
`varDeclarations`	stylistic
`voidOperator`Reports using the void operator.	stylistic
`arrayFilteredFinds`Reports using `.filter()` when only the first or last matching element is needed.	stylistic (strict)
`arrayFlatMapMethods`Reports using `.map().flat()` when `.flatMap()` can be used.	stylistic (strict)
`arrayFlatMethods`Reports legacy techniques to flatten arrays instead of using `.flat()`.	stylistic (strict)
`arrayIncludesMethods`Reports using `Array#some()` with simple equality checks that can be replaced with `.includes()`.	stylistic (strict)
`arrayIndexOfMethods`Reports using `.findIndex()` or `.findLastIndex()` with simple equality checks that can be replaced with `.indexOf()` or `.lastIndexOf()`.	stylistic (strict)
`arraySomeMethods`Reports patterns that can be replaced with `.some()` for checking array element existence.	stylistic (strict)
`atAccesses`Prefer using .at() for accessing elements at negative indices.	stylistic (strict)
`builtinCoercions`Reports functions that wrap native coercion functions like `String`, `Number`, `BigInt`, `Boolean`, or `Symbol`.	stylistic (strict)
`caughtVariableNames`Enforces a consistent naming convention for catch clause error variables.	stylistic (strict)
`classMethodsThis`Reports class methods that do not use `this`.	stylistic (strict)
`combinedPushes`Reports consecutive array.push() calls that could be combined into a single call.	stylistic (strict)
`destructuringConsistency`Use destructured variables over properties for consistency.	stylistic (strict)
`directiveRequireDescriptions`	stylistic (strict)
`elseReturns`Reports unnecessary `else` blocks following `if` statements that always return or throw.	stylistic (strict)
`emptyFiles`Reports files that contain no meaningful code.	stylistic (strict)
`emptyFunctions`Reports empty functions that should contain code or a comment.	stylistic (strict)
`escapeSequenceCasing`Reports escape sequences with lowercase hexadecimal characters.	stylistic (strict)
`functionDefinitionScopeConsistency`	stylistic (strict)
`globalThisAliases`Reports using window, self, or global instead of globalThis.	stylistic (strict)
`jsdocAsterisks`	stylistic (strict)
`jsdocInformativeDocs`	stylistic (strict)
`jsdocMisleadingBlocks`	stylistic (strict)
`jsdocMultilineBlocks`	stylistic (strict)
`jsdocParameterDescriptionHyphens`	stylistic (strict)
`jsdocTagNames`	stylistic (strict)
`mathMethods`Prefer modern Math methods over legacy patterns.	stylistic (strict)
`namedDefaultExports`Reports anonymous functions and classes as the default export.	stylistic (strict)
`namespaceImplicitAmbientImports`Reports declared namespaces that implicitly export all members.	stylistic (strict)
`negativeIndexLengthMethods`Prefer negative index over `.length - index` for `at`, `slice`, `splice`, and similar methods.	stylistic (strict)
`nonNullAssertionPlacement`Reports confusing placement of non-null assertions next to comparison or assignment operators.	stylistic (strict)
`numericSeparatorGroups`Reports numeric literals with inconsistent separator grouping.	stylistic (strict)
`objectEntriesMethods`Prefer Object.fromEntries() over reduce patterns that build objects from key-value pairs.	stylistic (strict)
`regexCharacterClasses`Reports regex alternations that can be simplified to character classes.	stylistic (strict)
`regexDigitMatchers`Reports character classes with multiple adjacent characters that could use a range instead.	stylistic (strict)
`regexExecutors`Reports String.prototype.match calls that can be replaced with RegExp.prototype.exec.	stylistic (strict)
`regexGraphemeStringLiterals`Reports string literals inside character classes with the `v` flag that contain multiple graphemes.	stylistic (strict)
`regexHexadecimalEscapes`Reports regex character escapes that can be expressed more consistently using hexadecimal escapes.	stylistic (strict)
`regexLetterCasing`Reports inconsistent letter casing in regex sequences.	stylistic (strict)
`regexLookaroundAssertions`Reports capturing groups at pattern boundaries that can be replaced with lookaround assertions.	stylistic (strict)
`regexMatchNotation`Reports inconsistent notations for matching any character in regular expressions.	stylistic (strict)
`regexNamedBackreferences`Reports backreferences that do not use the name of their referenced capturing group.	stylistic (strict)
`regexNamedReplacements`Reports indexed references in replacement strings that should use named references.	stylistic (strict)
`regexPlusQuantifiers`Reports quantifiers `{1,}` in regular expressions that should use `+` instead.	stylistic (strict)
`regexQuestionQuantifiers`Reports quantifiers `{0,1}` in regular expressions that should use `?` instead.	stylistic (strict)
`regexResultArrayGroups`Reports indexed access on regex result arrays when named capturing groups should be used.	stylistic (strict)
`regexStarQuantifiers`Reports quantifiers `{0,}` in regular expressions that should use `*` instead.	stylistic (strict)
`regexUnicodeCodepointEscapes`Reports surrogate pair escapes in regular expressions that can be replaced with Unicode codepoint escapes.	stylistic (strict)
`regexUnnecessaryNonCapturingGroups`	stylistic (strict)
`regexWordMatchers`	stylistic (strict)
`setHasExistenceChecks`	stylistic (strict)
`setSizeLengthChecks`	stylistic (strict)
`sizeComparisonOperators`	stylistic (strict)
`staticMemberOnlyClasses`	stylistic (strict)
`stringSliceMethods`	stylistic (strict)
`stringTrimMethods`	stylistic (strict)
`structuredCloneMethods`	stylistic (strict)
`topLevelAwaits`	stylistic (strict)
`undefinedTypeofChecks`	stylistic (strict)
`unnecessaryTernaries`	stylistic (strict)
`arrayCallbackReturns`Reports missing return statements in callbacks of array methods.	untyped
`caseDeclarations`Reports lexical declarations in case clauses without wrapping them in blocks.	untyped
`classAssignments`Reports reassigning class declarations.	untyped
`classFieldDeclarations`Reports assigning literal values to `this` in constructors instead of using class field declarations.	untyped
`classMemberDuplicates`Reports duplicate class member names that will be overwritten.	untyped
`constantAssignments`Reports attempting to reassign variables declared with const.	untyped
`constructorReturns`Reports returning values from constructor functions.	untyped
`constructorSupers`Reports constructors of derived classes that do not call `super()`, and constructors of non-derived classes that call `super()`.	untyped
`defaultParameterLast`Enforce default parameters to be last.	untyped
`duplicateArguments`Reports functions with duplicate parameter names in their signatures.	untyped
`exportUniqueNames`Reports duplicate export names in a module.	untyped
`functionAssignments`Reports reassigning variables declared with function declarations.	untyped
`getterReturns`Reports getter functions that do not return values.	untyped
`globalAssignments`Reports attempting to assign to read-only global variables such as undefined, NaN, Infinity, Object, etc.	untyped
`globalObjectCalls`Reports calling global objects like Math, JSON, or Reflect as functions.	untyped
`importAssignments`	untyped
`invalidThis`	untyped
`nativeObjectExtensions`Reports extending the prototype of native JavaScript objects.	untyped
`newNativeNonConstructors`Disallows using `new` with global non-constructor functions like Symbol and BigInt.	untyped
`objectKeyDuplicates`Reports unnecessary duplicate keys that override previous values.	untyped
`objectProto`Reports using the deprecated proto property to access or modify an object's prototype.	untyped
`octalEscapes`Reports using octal escape sequences in string literals.	untyped
`octalNumbers`Reports using legacy octal numeric literals.	untyped
`sequences`Reports using the comma operator in expressions.	untyped
`setterReturns`	untyped
`shadowedRestrictedNames`Reports variable declarations that shadow JavaScript's restricted names.	untyped
`thisBeforeSuper`	untyped
`typeofComparisons`Reports typeof expressions that compare impossible string literals.	untyped
`unassignedVariables`Reports variables that are declared but never assigned a value.	untyped
`undefinedVariables`Reports using variables that are not defined.	untyped
`unreachableStatements`	untyped
`unsafeNegations`Reports negating the left operand of `in` or `instanceof` relations.	untyped
`unsafeOptionalChains`	untyped
`usageBeforeDefinition`	untyped
`useStrictDirectives`	untyped
`variableBlockScopeUsage`	untyped
`variableDeletions`Reports attempting to delete variables with the delete operator.	untyped
`variableRedeclarations`	untyped
`withStatements`Reports using with statements	untyped
`consoleCalls`Reports calls to console methods.	(none)
`enumInitializers`Reports enum members without explicit initial values.	(none)
`equalityOperatorNegations`Reports negated expressions on the left side of equality checks.	(none)
`forInGuards`Reports for-in loops without an if statement to filter inherited properties.	(none)
`functionDeclarationStyles`Reports functions that don't match the configured style (declaration vs expression).	(none)
`functionNameMatches`Reports function names that don't match the variable or property they're assigned to.	(none)
`regexNamedCaptureGroups`Reports capturing groups in regular expressions that do not have a name.	(none)
`regexUnicodeEscapes`Enforces consistent Unicode escape style in regex patterns by preferring codepoint escapes.	(none)
`regexUnicodeFlag`Require regex patterns to have the unicode ('u') or unicodeSets ('v') flag for proper Unicode character handling.	(none)
`restrictedGlobals`	(none)
`restrictedIdentifiers`	(none)
`restrictedImports`	(none)
`restrictedProperties`	(none)
`restrictedSyntax`	(none)
`restrictedTypes`	(none)
`evolvingVariableTypes`Reports variables declared without type annotation or initializer.	(none)

Selectors

Flint’s TypeScript plugin provides the following file selector:

all: **/*.{cjs,js,jsx,mjs,ts,tsx}

Made with ❤️‍🔥 in Boston by Josh Goldberg and contributors.