All Rules

This is a full table of all rules that will be implemented in the main Flint project. It includes rules from all three provided categories of plugins: Core, Focused, and Incubator. Each rule is equivalent to at least one existing rule in another linter.

Implemented: 251 of 849 (29.5%)

Flint Rule	Plugin	Preset
`accessKeys`Disallow the use of the `accessKey` / `accesskey` attribute on JSX elements.	JSX	logical
`accessorThisRecursion`Reports recursive access to this within getters and setters.	TypeScript	logical (strict)
`afterAllPaddingLines`	Vitest	stylistic (strict)
`afterEachPaddingLines`	Vitest	stylistic (strict)
`alerts`Reports uses of the global alert/confirm/prompt dialog APIs.	Browser	logical
`aliasMethods`	Vitest	stylistic
`allPaddingLines`	Vitest	stylistic (strict)
`altTexts`Reports elements that require alt text but are missing it.	JSX	logical
`anchorAmbiguousText`Reports anchor elements with ambiguous text that doesn't describe the link destination.	JSX	logical (strict)
`anchorContent`Reports anchor elements without accessible content.	JSX	logical
`anchorNatives`	Next.js	logical
`anchorValidity`Reports invalid usage of anchor elements.	JSX	logical
`anyArguments`Reports calling a function with a value typed as `any` as an argument.	TypeScript	logical
`anyAssignments`Reports assigning a value with type `any` to variables and properties.	TypeScript	logical
`anyCalls`Reports calling a value with type `any`.	TypeScript	logical
`anyMemberAccess`Reports member access on a value with type `any`.	TypeScript	logical
`anyReturns`Reports returning a value with type `any` from a function.	TypeScript	logical
`arguments`Reports using the arguments object instead of rest parameters.	TypeScript	logical
`ariaActiveDescendantTabIndex`Reports elements with aria-activedescendant without tabIndex.	JSX	logical
`ariaHiddenFocusables`Reports elements with aria-hidden='true' that are focusable.	JSX	logical (strict)
`ariaProps`Reports invalid ARIA properties.	JSX	logical
`ariaPropTypes`Reports ARIA properties with invalid value types.	JSX	logical
`ariaRoleValidity`Reports invalid or abstract ARIA roles.	JSX	logical
`ariaUnsupportedElements`Reports ARIA attributes on elements that don't support them.	JSX	logical
`arrayCallbackReturns`Reports missing return statements in callbacks of array methods.	TypeScript	untyped
`arrayConstructors`Reports using the `Array` constructor to create arrays instead of array literal syntax.	TypeScript	logical
`arrayDeleteUnnecessaryCounts`Reports using `.length` or `Infinity` as the `deleteCount` or `skipCount` argument of `Array#splice()` or `Array#toSpliced()`.	TypeScript	stylistic
`arrayElementDeletions`Reports using the `delete` operator on array values.	TypeScript	logical
`arrayEmptyCallbackSlots`Reports array methods with callbacks that will never be invoked on arrays with empty slots.	TypeScript	logical
`arrayExistenceChecksConsistency`Reports inconsistent styles for checking element existence using index methods.	TypeScript	stylistic
`arrayFilteredFinds`Reports using `.filter()` when only the first or last matching element is needed.	TypeScript	stylistic (strict)
`arrayFinds`Reports using `.filter()[0]` instead of `.find()` when looking for a single element.	TypeScript	stylistic
`arrayFlatMapMethods`Reports using `.map().flat()` when `.flatMap()` can be used.	TypeScript	stylistic (strict)
`arrayFlatMethods`Reports legacy techniques to flatten arrays instead of using `.flat()`.	TypeScript	stylistic (strict)
`arrayFlatUnnecessaryDepths`Reports using `1` as the depth argument of `.flat()` since it is the default.	TypeScript	stylistic
`arrayHandlers`	SolidJS	(none)
`arrayIncludes`Reports using `.indexOf()` comparisons that can be replaced with `.includes()`.	TypeScript	stylistic
`arrayIncludesMethods`Reports using `Array#some()` with simple equality checks that can be replaced with `.includes()`.	TypeScript	stylistic (strict)
`arrayIndexKeyes`	React	logical
`arrayIndexOfMethods`Reports using `.findIndex()` or `.findLastIndex()` with simple equality checks that can be replaced with `.indexOf()` or `.lastIndexOf()`.	TypeScript	stylistic (strict)
`arrayLoops`Reports using `.forEach()` when a for-of loop can be used.	TypeScript	stylistic
`arrayMapIdentities`Reports using `.flatMap()` with an identity function that returns its argument unchanged.	TypeScript	logical
`arrayMutableReverses`Reports `.reverse()` calls on arrays that mutate the original array.	TypeScript	stylistic
`arrayMutableSorts`Reports `.sort()` calls on arrays that mutate the original array.	TypeScript	stylistic
`arraySliceUnnecessaryEnd`Reports unnecessary `end` argument in `.slice()` calls when it equals the length or is `Infinity`.	TypeScript	stylistic
`arraySomeMethods`Reports patterns that can be replaced with `.some()` for checking array element existence.	TypeScript	stylistic (strict)
`arrayTernarySpreadingConsistency`Reports inconsistent types when spreading a ternary in an array literal.	TypeScript	stylistic
`arrayTypes`Reports array type syntax that doesn't match the configured style.	TypeScript	stylistic
`arrayUnnecessaryLengthChecks`Reports unnecessary array length checks before `.some()` or `.every()` calls.	TypeScript	logical
`asConstAssertions`Reports using explicit literal types when `as const` can be used.	TypeScript	stylistic
`assertStrict`Prefer strict assertion mode from Node.js for better error messages and behavior.	Node.js	logical
`assertStyles`Prefer `assert.ok()` over `assert()` for explicit intent and better readability.	Node.js	stylistic
`assignmentOperatorShorthands`Prefer logical assignment operator shorthand expressions.	TypeScript	stylistic
`asyncFunctionAwaits`	TypeScript	logical
`asyncPromiseExecutors`Reports using async functions as Promise executor functions.	TypeScript	logical
`asyncUnnecessaryPromiseWrappers`Reports unnecessary `Promise.resolve()` or `Promise.reject()` in async contexts.	TypeScript	logical
`atAccesses`Prefer using .at() for accessing elements at negative indices.	TypeScript	stylistic (strict)
`attributeNameCasing`	Vue	stylistic
`attributeOrders`	Vue	stylistic (strict)
`attributesSorting`	Astro	stylistic
`attributeValidity`	JSX	logical
`authorPresence`	PackageJSON	(none)
`authorValidity`	PackageJSON	logical
`autocomplete`Ensure the autocomplete attribute is correct and suitable for the form field.	JSX	logical
`autoFocusProps`Reports autoFocus props that are not set to false.	JSX	logical
`awaitInsidePromiseMethods`	TypeScript	logical (strict)
`awaitThenable`	TypeScript	logical
`bareUrls`Reports bare URLs that should be formatted as autolinks or links.	Markdown	stylistic (strict)
`beforeAllPaddingLines`	Vitest	stylistic (strict)
`beforeEachPaddingLines`	Vitest	stylistic (strict)
`bindDirectiveValidity`	Vue	logical
`bindStyles`	Vue	stylistic
`binValidity`	PackageJSON	logical
`blobReadingMethods`Prefer direct Blob reading methods over wrapping in Response for simpler code.	Node.js	stylistic
`blockMappings`Prefer block-style mappings over flow-style mappings.	YAML	stylistic
`blockOrders`	Vue	sorting
`blockquoteBlankLineMultiples`	Markdown	stylistic (strict)
`blockSequences`Prefer block style sequences over flow style sequences.	YAML	stylistic
`booleanPropNames`	JSX	stylistic (strict)
`booleanValues`Prefer shorthand boolean attributes over explicit {true} values in JSX.	JSX	stylistic
`bracedStatements`Disallow unnecessary JSX curly braces around literals and JSX elements.	JSX	stylistic
`bufferAllocators`Prefer modern Buffer allocation methods over the deprecated Buffer constructor.	Node.js	logical
`bugsPresence`	PackageJSON	(none)
`builtinCoercions`Reports functions that wrap native coercion functions like `String`, `Number`, `BigInt`, `Boolean`, or `Symbol`.	TypeScript	stylistic (strict)
`builtinConstructorNews`Enforces using new for constructors that require it, and disallows new for primitive coercion functions.	TypeScript	stylistic
`bundleDependenciesPresence`	PackageJSON	(none)
`bundleDependenciesValidity`	PackageJSON	logical
`buttonTypes`Reports button elements without an explicit type attribute.	JSX	logical
`calledOnceWithAssertions`	Vitest	stylistic (strict)
`calledTimesAssertions`	Vitest	stylistic (strict)
`calledWithAssertions`	Vitest	stylistic (strict)
`caseDeclarations`Reports lexical declarations in case clauses without wrapping them in blocks.	TypeScript	untyped
`caseDuplicates`Reports switch statements with duplicate case clause test expressions.	TypeScript	logical
`caseFallthroughs`Reports switch case clauses that fall through unexpectedly.	TypeScript	logical
`catchCallbackTypes`Reports `Promise` catch callback parameters that are not typed as unknown.	TypeScript	logical
`caughtErrorCauses`	TypeScript	logical (strict)
`caughtVariableNames`Enforces a consistent naming convention for catch clause error variables.	TypeScript	stylistic (strict)
`chainedAssignments`Reports using chained assignment expressions (e.g., a = b = c).	TypeScript	stylistic
`charAtComparisons`Reports comparing charAt() results with strings longer than one character.	TypeScript	logical
`childContentOverrides`	Vue	logical
`childrenProps`Reports usage of the children prop.	JSX	stylistic
`childrenWhitespace`	JSX	logical (strict)
`classAssignments`Reports reassigning class declarations.	TypeScript	untyped
`classComponentStateDefinitions`	React	stylistic (strict)
`classComponentStateInitialization`	React	stylistic (strict)
`classes`	Sorting	stylistic
`classFieldDeclarations`Reports assigning literal values to `this` in constructors instead of using class field declarations.	TypeScript	untyped
`classListDirectiveObjects`	Astro	stylistic
`classListDirectives`	Astro	stylistic
`classListDirectiveSplits`	Astro	stylistic
`classListToggles`Prefer using classList.toggle() over conditional classList.add() and classList.remove().	Browser	stylistic
`classLiteralProperties`Reports getters that return literal values instead of using readonly class fields.	TypeScript	stylistic
`classMemberDuplicates`Reports duplicate class member names that will be overwritten.	TypeScript	untyped
`classMethodsThis`Reports class methods that do not use `this`.	TypeScript	stylistic (strict)
`clickEventKeyEvents`Reports onClick without keyboard event handlers.	JSX	logical
`clientComponentAsyncDefinitions`	Next.js	logical
`clientOnlyDirectiveValues`	Astro	logical
`cloakDirectiveValidity`	Vue	logical
`codeSpaces`	Markdown	stylistic
`combinedPushes`Reports consecutive array.push() calls that could be combined into a single call.	TypeScript	stylistic (strict)
`commentedOutTests`	Vitest	logical (strict)
`commentTextNodes`Reports JSX text nodes that contain comment syntax but are rendered as text.	JSX	logical
`comparisonMatcherAssertions`	Vitest	stylistic
`compilerOptions`	React	config
`componentConditionalReturns`	SolidJS	logical
`componentDataSharing`	Vue	logical
`componentDefinitions`	React	stylistic
`componentDidMountSetStates`	React	logical (strict)
`componentDidUpdateSetStates`	React	logical (strict)
`componentDisplayNames`	React	logical (strict)
`componentFileExports`	Astro	logical
`componentHookFactories`	React	logical
`componentHtmlTextProps`	Vue	logical
`componentNameCasing`	Vue	stylistic
`componentNames`	Vue	stylistic
`componentNameValidity`	Vue	logical
`componentNesting`	React	logical
`componentPropertyOrder`	Vue	sorting
`componentPropMutations`	Vue	logical
`componentVIsBinds`	Vue	logical
`componentWillUpdateSetStates`	React	logical (strict)
`computedAsyncProperties`	Vue	logical
`computedPropertyLikeMethods`	Vue	logical
`computedPropertyReturns`	Vue	logical
`computedPropertySideEffects`	Vue	logical
`conditionalExpects`	Vitest	stylistic (strict)
`configValidity`	PackageJSON	logical
`consecutiveNonNullAssertions`Reports unnecessary extra non-null assertions.	TypeScript	stylistic
`consoleCalls`Reports calls to console methods.	TypeScript	(none)
`consoleSpaces`Disallow leading or trailing spaces in console method string arguments.	Node.js	stylistic (strict)
`constantAssignments`Reports attempting to reassign variables declared with const.	TypeScript	untyped
`constructorReturns`Reports returning values from constructor functions.	TypeScript	untyped
`constructorSupers`Reports constructors of derived classes that do not call `super()`, and constructors of non-derived classes that call `super()`.	TypeScript	untyped
`constVariables`	TypeScript	logical
`contextValueReferences`	React	logical (strict)
`cpuValidity`	PackageJSON	logical
`cspell`Runs the CSpell spell checker on any source code file.	Spelling	logical
`cssManualStylesheets`	Next.js	logical
`customFontsInPages`	Next.js	logical
`dangerouslySetInnerHTMLWithChildren`	React	logical
`dangerousProps`	React	logical (strict)
`dataComputedProperties`	Vue	logical
`dateConstructorClones`Prefer passing a `Date` directly to the `Date` constructor when cloning, rather than calling `getTime()`.	TypeScript	logical
`dateNowTimestamps`Prefer the shorter `Date.now()` to get the number of milliseconds since the Unix Epoch.	TypeScript	logical (strict)
`debuggerStatements`Reports using debugger statements.	TypeScript	logical
`decorators`	Sorting	stylistic
`defaultCaseLast`Reports switch statements where the default clause is not last.	TypeScript	logical
`defaultParameterLast`Enforce default parameters to be last.	TypeScript	untyped
`defaultPropsMatchingPropTypes`	React	logical
`defaultPropTypes`	Vue	logical
`defineEmitsValidity`	Vue	logical
`defineOptionsValidity`	Vue	logical
`definePropsValidity`	Vue	logical
`definitionContents`Reports definitions with empty URLs or only empty fragments.	Markdown	logical
`definitionDuplicates`Reports duplicate definition identifiers (case-insensitive).	Markdown	logical
`definitionUses`Reports unused reference definitions.	Markdown	logical
`deletes`Reports using the delete operator.	Performance	logical
`dependenciesPresence`	PackageJSON	(none)
`dependenciesValidity`	PackageJSON	logical
`dependencyRanges`	PackageJSON	(none)
`dependencyUniqueness`	PackageJSON	logical
`deprecated`Disallow using code marked as @deprecated.	TypeScript	logical
`deprecatedDataObjectDeclarations`	Vue	logical
`deprecatedDestroyedLifecycleHooks`	Vue	logical
`deprecatedFilters`	Vue	logical
`deprecatedFunctionalTemplates`	Vue	logical
`deprecatedThisDefaultProps`	Vue	logical
`describeCallbackValidity`	Vitest	logical
`describePaddingLines`	Vitest	stylistic (strict)
`describeTitleReferences`	Vitest	stylistic
`descriptionPresence`	PackageJSON	logical
`descriptionValidity`	PackageJSON	logical
`destructuring`	React	stylistic
`destructuringConsistency`Use destructured variables over properties for consistency.	TypeScript	stylistic (strict)
`devDependenciesPresence`	PackageJSON	(none)
`devDependenciesValidity`	PackageJSON	logical
`directivePairs`	TypeScript	logical (strict)
`directiveRequireDescriptions`	TypeScript	stylistic (strict)
`directoriesValidity`	PackageJSON	logical
`distractingElements`Reports distracting elements like <marquee> and <blink>.	JSX	logical
`documentCookies`Reports uses of `document.cookie` which can be error-prone and has security implications.	Browser	logical (strict)
`duplicateArguments`Reports functions with duplicate parameter names in their signatures.	TypeScript	untyped
`duplicateAttributes`	Vue	logical
`duplicateVElseIfConditions`	Vue	logical
`dynamicDeletes`Disallow using the delete operator on computed key expressions.	TypeScript	logical
`eachLoops`	Vitest	stylistic
`effectSetStates`	React	logical
`elementChildrenValidity`Reports void DOM elements that have children, which is invalid HTML.	JSX	logical (strict)
`elseDirectiveValidity`	Vue	logical
`elseIfDirectiveValidity`	Vue	logical
`elseIfDuplicates`Reports duplicate conditions in if-else-if chains that make code unreachable.	TypeScript	logical
`elseReturns`Reports unnecessary `else` blocks following `if` statements that always return or throw.	TypeScript	stylistic (strict)
`emitsValidatorReturns`	Vue	logical
`emptyBlocks`Reports empty block statements that should contain code.	TypeScript	stylistic
`emptyDestructures`Reports using empty destructuring patterns that destructure no values.	TypeScript	logical
`emptyDocuments`Reports empty YAML documents that contain only document markers.	YAML	logical
`emptyEnums`Reports empty enum declarations with no members.	TypeScript	logical
`emptyExports`Reports empty export statements that don't make a file a module.	TypeScript	logical
`emptyFields`	PackageJSON	logical
`emptyFiles`Reports files that contain no meaningful code.	TypeScript	stylistic (strict)
`emptyFunctions`Reports empty functions that should contain code or a comment.	TypeScript	stylistic (strict)
`emptyMappingKeys`Reports empty mapping keys.	YAML	logical
`emptyMappingValues`Reports empty mapping values.	YAML	logical
`emptyModuleAttributes`Reports empty import/export attributes that serve no purpose.	TypeScript	stylistic
`emptyObjectTypes`Reports empty object type literals and empty interfaces that are often used incorrectly.	TypeScript	logical
`emptySequenceEntries`Reports empty sequence entries.	YAML	logical
`emptyStaticBlocks`Reports empty static initialization blocks within class declarations.	TypeScript	stylistic
`emptyTypeParameterLists`Reports empty type parameter lists in type aliases and interfaces.	TypeScript	stylistic
`endTagPresence`	Vue	logical
`enginesPresence`	PackageJSON	(none)
`enumInitializers`Reports enum members without explicit initial values.	TypeScript	(none)
`enumMemberLiterals`Requires all enum members to be literal values.	TypeScript	logical (strict)
`enumMixedValues`	TypeScript	logical
`enumValueConsistency`Reports enums that contain both string and number members.	TypeScript	logical
`enumValueDuplicates`Reports enum members with duplicate values.	TypeScript	logical
`equalityMatchers`	Vitest	stylistic
`equalityOperatorNegations`Reports negated expressions on the left side of equality checks.	TypeScript	(none)
`equalityOperators`	TypeScript	logical
`errorBoundaries`	React	logical
`errorMessages`Requires a message value when creating a built-in error.	TypeScript	logical (strict)
`errorSubclassProperties`Reports incorrect Error subclass definitions that don't follow best practices.	TypeScript	logical (strict)
`errorUnnecessaryCaptureStackTraces`Reports unnecessary Error.captureStackTrace() calls in Error subclass constructors.	TypeScript	logical
`escapeSequenceCasing`	TypeScript	stylistic (strict)
`evals`Reports uses of the eval function.	TypeScript	logical
`eventClasses`Prefer EventTarget over EventEmitter for cross-platform compatibility.	Node.js	logical (strict)
`eventHandlerCasing`	SolidJS	logical
`eventListenerSubscriptions`Prefer addEventListener over assigning to on* event handler properties.	Browser	logical (strict)
`eventTriggerExplicitEmits`	Vue	logical
`evolvingVariableTypes`Reports variables declared without type annotation or initializer.	TypeScript	(none)
`exceptionAssignments`Reports reassigning exception parameters in catch clauses.	TypeScript	logical
`exhaustiveDeps`	React	logical
`expectGroupPaddingLines`	Vitest	stylistic (strict)
`expectResolves`	Vitest	stylistic
`expectsOutsideTests`	Vitest	logical (strict)
`expectTypeOfs`	Vitest	stylistic
`expectValidity`	Vitest	logical
`explicitAnys`	TypeScript	logical
`exponentiationOperators`	TypeScript	stylistic
`exportFromImports`	TypeScript	stylistic
`exportMutables`Reports exporting mutable bindings (let or var).	TypeScript	logical
`exports`	Sorting	stylistic
`exportsAssignments`Prevent assignment to the `exports` variable in CommonJS modules.	Node.js	logical
`exportsValidity`	PackageJSON	logical
`exportUniqueNames`Reports duplicate export names in a module.	TypeScript	untyped
`exposeAfterAwaits`	Vue	logical
`extraneousClasses`	TypeScript	logical (strict)
`fencedCodeLanguages`Reports fenced code blocks without a language specified.	Markdown	stylistic (strict)
`fetchMethodBodies`Disallow providing a body with GET or HEAD fetch requests.	TypeScript	logical
`fileExtensions`	YAML	stylistic (strict)
`filenames`	Vitest	(none)
`filePathsFromImportMeta`Prefer `import.meta.dirname` and `import.meta.filename` over legacy file path techniques.	Node.js	stylistic (strict)
`fileReadJSONBuffers`Prefer reading JSON files as buffers when using JSON.parse for better performance.	Node.js	stylistic (strict)
`filesPresence`	PackageJSON	(none)
`filesRedundancy`	PackageJSON	logical
`filesValidity`	PackageJSON	logical
`finallyStatementSafety`Reports control flow statements in `finally` blocks that can override control flow in `try`/`catch` blocks.	TypeScript	logical
`floatingPromises`	TypeScript	logical
`forBindKeys`	Vue	logical
`forDirections`Reports for loops with counter variables that move in the wrong direction.	TypeScript	stylistic
`forDirectiveValidity`	Vue	logical
`forInArrays`Reports iterating over an array with a for-in loop.	TypeScript	logical
`forInGuards`Reports for-in loops without an if statement to filter inherited properties.	TypeScript	(none)
`forMaps`	SolidJS	logical
`fragmentElements`	JSX	stylistic
`functionApplySpreads`Prefer the spread operator over `.apply()` calls.	TypeScript	stylistic
`functionAssignments`Reports reassigning variables declared with function declarations.	TypeScript	untyped
`functionComponentDefinitions`	React	stylistic
`functionComponentThisReferences`	React	untyped
`functionCurryingRedundancy`Reports using `.apply()` or `.call()` or when the context (`this` value) provides no benefit.	TypeScript	logical
`functionDeclarationStyles`Reports functions that don't match the configured style (declaration vs expression).	TypeScript	(none)
`functionDefinitionScopeConsistency`	TypeScript	stylistic (strict)
`functionNameMatches`Reports function names that don't match the variable or property they're assigned to.	TypeScript	(none)
`functionNewCalls`Reports using the Function constructor to create functions from strings.	TypeScript	logical
`functionTypeDeclarations`	TypeScript	stylistic
`gating`	React	config
`generatorFunctionYields`Reports generator functions that do not yield values.	TypeScript	logical
`genericConstructorCalls`	TypeScript	stylistic
`getterReturns`	TypeScript	untyped
`getterSetterPairedTypes`	TypeScript	logical
`globalAssignments`Reports attempting to assign to read-only global variables such as undefined, NaN, Infinity, Object, etc.	TypeScript	untyped
`globalMutations`	React	logical
`globalObjectCalls`Reports calling global objects like Math, JSON, or Reflect as functions.	TypeScript	untyped
`globalThisAliases`	TypeScript	stylistic (strict)
`googleAnalyticsInlineScript`	Next.js	logical
`googleFontDisplay`	Next.js	logical
`googleFontPreconnect`	Next.js	logical
`groupedAccessorPairs`	TypeScript	stylistic
`hashbangs`	Node.js	logical
`headDuplicates`	Next.js	logical
`headImportsInDocuments`	Next.js	logical
`headingContents`Reports heading elements without accessible content.	JSX	logical
`headingDuplicates`	Markdown	stylistic (strict)
`headingEmphasisEquivalents`	Markdown	stylistic (strict)
`headingIncrements`Reports heading levels incrementing by more than one.	Markdown	logical
`headingRootDuplicates`Reports multiple H1 headings in the same document.	Markdown	logical (strict)
`headingRootPresence`	Markdown	logical (strict)
`headingTrailingPunctuation`	Markdown	stylistic (strict)
`headNatives`	Next.js	logical
`heritageClauses`	Sorting	stylistic
`hoistedApiPositions`	Vitest	logical (strict)
`homepageValidity`	PackageJSON	logical
`hookDuplicates`	Vitest	logical (strict)
`hookOrders`	Vitest	stylistic (strict)
`hooksBeforeTestCases`	Vitest	stylistic (strict)
`htmlDirectiveValidity`	Vue	logical
`htmlLangs`Reports <html> elements without a lang prop.	JSX	logical
`ifDirectiveValidity`	Vue	logical
`iframeSandboxes`	JSX	logical (strict)
`iframeTitles`Reports <iframe> elements without a title prop.	JSX	logical
`imageAltTexts`Reports images without alternative text.	Markdown	logical
`imageContents`Reports images with empty URLs or only empty fragments.	Markdown	logical
`imgNatives`	Next.js	logical
`immutability`	React	logical
`implicitGlobals`Prevents implicit global variable declarations in browser scripts.	Browser	logical
`impliedEvals`Reports using string arguments in setTimeout, setInterval, setImmediate, execScript, or the Function constructor.	TypeScript	logical
`importAssignments`	TypeScript	untyped
`importCycles`	TypeScript	stylistic
`importDuplicates`	TypeScript	stylistic
`importedNamespaceDynamicAccesses`Disallow computed member access on imported namespace identifiers.	Performance	logical
`importEmptyBlocks`Reports empty named import blocks.	TypeScript	logical
`importExtraneousDependencies`	TypeScript	none
`importFileExtensions`	Node.js	(none)
`importMetaProperties`	Nuxt	stylistic
`importSelf`	TypeScript	stylistic
`importsInMocks`	Vitest	(none)
`importTypeSideEffects`Reports imports that use inline type qualifiers on all specifiers when a top-level type qualifier should be used instead.	TypeScript	logical
`importUnnecessaryPathSegments`	TypeScript	stylistic
`incompatibleLibraries`	React	logical
`indexedObjectTypes`	TypeScript	stylistic
`inlineScriptId`	Next.js	logical
`innerHTMLProps`	SolidJS	logical (strict)
`inputCheckedMutability`	JSX	logical
`instanceOfArrays`Reports using `instanceof Array` instead of `Array.isArray()`.	TypeScript	logical
`interactiveElementRoles`Reports interactive elements with non-interactive ARIA roles.	JSX	logical
`interactiveElementsFocusable`Reports interactive elements that are not focusable via keyboard.	JSX	logical
`interfaces`	Sorting	stylistic
`intersectionTypes`	Sorting	stylistic
`invalidCodeLines`Reports cases for invalid code that isn't formatted across lines.	Flint	logical
`invalidThis`	TypeScript	untyped
`invalidVoidTypes`	TypeScript	logical (strict)
`irregularWhitespace`	YAML	stylistic
`irregularWhitespaces`	TypeScript	logical
`isDirectiveValidity`	Vue	logical
`isNaNComparisons`Reports comparisons with NaN, which should use Number.isNaN() instead.	TypeScript	logical
`iterableKeys`	React	logical (strict)
`jsdocAccessTags`	TypeScript	stylistic
`jsdocAsterisks`	TypeScript	stylistic (strict)
`jsdocEmptyBlocks`	TypeScript	stylistic
`jsdocEmptyTags`	TypeScript	stylistic
`jsdocImplementsTags`	TypeScript	stylistic
`jsdocInformativeDocs`	TypeScript	stylistic (strict)
`jsdocMisleadingBlocks`	TypeScript	stylistic (strict)
`jsdocMultilineBlocks`	TypeScript	stylistic (strict)
`jsdocParameterDescriptionHyphens`	TypeScript	stylistic (strict)
`jsdocParameterNames`	TypeScript	stylistic
`jsdocPropertyNames`	TypeScript	stylistic
`jsdocRedundantTypes`	TypeScript	stylistic
`jsdocTagNames`	TypeScript	stylistic (strict)
`jsdocTags`	Sorting	stylistic
`jsdocTemplateNames`	TypeScript	stylistic
`jsdocTypesSyntax`	TypeScript	stylistic
`jsdocUnnecessaryReturns`	TypeScript	stylistic
`jsdocUnnecessaryYields`	TypeScript	stylistic
`jsdocValidTypes`	TypeScript	stylistic
`jsdocValues`	TypeScript	stylistic
`jsdocYields`	TypeScript	stylistic
`jsonKeys`	Sorting	stylistic
`jsxProps`	Sorting	stylistic
`keyboardEventKeys`Prefer KeyboardEvent.key over deprecated properties like keyCode, charCode, and which.	Browser	logical
`keyDuplicates`Reports unnecessary duplicate keys that override previous values.	JSON	logical
`keyDuplicates`	Vue	logical
`keyNormalization`Reports object keys that are not normalized using Unicode normalization forms.	JSON	logical
`keyValidity`	Vue	logical
`keywordsPresence`	PackageJSON	(none)
`keywordsValidity`	PackageJSON	logical
`labelAssociatedControls`Reports <label> elements without an associated control element.	JSX	logical
`labelReferences`Reports missing label references.	Markdown	logical
`labelReferenceValidity`Reports invalid label references with whitespace.	Markdown	logical
`langValidity`Reports invalid lang attribute values.	JSX	logical (strict)
`licenseRequired`	PackageJSON	logical
`licenseValidity`	PackageJSON	logical
`lifecyclesAfterAwaits`	Vue	logical
`linkContents`Reports links with empty URLs or only empty fragments.	Markdown	logical
`linkDescriptions`	Markdown	logical (strict)
`linkFragments`Reports link fragments that don't exist in the document.	Markdown	logical
`literalConstructorWrappers`	TypeScript	stylistic
`loneTemplates`	Vue	logical (strict)
`loopAwaits`Reports using await expressions inside loops.	Performance	logical
`loopFunctions`Reports function declarations and expressions inside loops that reference variables modified by the loop.	Performance	logical
`mainValidity`	PackageJSON	logical
`manualMemoizationPreservations`	React	logical
`manValidity`	PackageJSON	logical
`maps`	Sorting	stylistic
`mathMethods`Prefer modern Math methods over legacy patterns.	TypeScript	stylistic (strict)
`meaninglessVoidOperators`Reports using the void operator on expressions that are already void or undefined.	TypeScript	logical
`mediaCaptions`Reports media elements without captions.	JSX	logical
`mediaSyntaxReversals`Reports reversed link and image syntax in Markdown.	Markdown	stylistic
`memoDirectiveValidity`	Vue	logical
`messagePhrases`	Flint	logical (strict)
`methodSignatureStyles`	TypeScript	stylistic
`misleadingVoidExpressions`Require expressions of type void to appear in statement position.	TypeScript	logical
`missingPlaceholders`	Flint	logical
`misusedPromises`	TypeScript	logical
`mockedFunctionInstances`	Vitest	stylistic (strict)
`mockTypeParameters`	Vitest	stylistic (strict)
`modelDirectiveValidity`	Vue	logical
`moduleAssignments`	Next.js	untyped
`modules`	Sorting	stylistic
`moduleSpecifierLists`Require non-empty specifier lists in import and export statements.	TypeScript	logical
`mouseEventKeyEvents`Reports mouse events without corresponding keyboard events.	JSX	logical
`multilineAmbiguities`Reports ambiguous multiline expressions that could be misinterpreted.	TypeScript	stylistic
`namedDefaultExports`	TypeScript	stylistic (strict)
`namePresence`	PackageJSON	logical
`namespaceDeclarations`Reports using legacy `namespace` declarations.	TypeScript	logical
`namespaceImplicitAmbientImports`	TypeScript	stylistic (strict)
`namespaceKeywords`	TypeScript	stylistic
`namespaceValidity`	SolidJS	untyped
`nameValidity`	PackageJSON	logical
`nativeObjectExtensions`	TypeScript	untyped
`negativeIndexLengthMethods`	TypeScript	stylistic (strict)
`negativeZeroComparisons`Reports comparisons with -0 that may not behave as expected.	TypeScript	logical
`nestedStandaloneIfs`	TypeScript	stylistic
`newDefinitions`	TypeScript	logical
`newExpressions`Reports standalone new expressions that don't use the constructed object.	TypeScript	logical
`newNativeNonConstructors`Disallows using `new` with global non-constructor functions like Symbol and BigInt.	TypeScript	untyped
`nextDocumentOutsidePage`	Next.js	logical
`nextScriptInHeads`	Next.js	logical
`nextScriptInteractiveOutsideDocument`	Next.js	logical
`nextTickValidity`	Vue	logical
`nodeAppendMethods`Prefer modern DOM append/prepend methods over appendChild/insertBefore.	Browser	logical (strict)
`nodeDatasetAttributes`Prefer using element.dataset over getAttribute/setAttribute for data-* attributes.	Browser	logical (strict)
`nodeModificationMethods`Prefer modern DOM APIs like .replaceWith() and .before() over legacy methods like .replaceChild() and .insertBefore().	Browser	logical (strict)
`nodePropertyInChecks`	Flint	logical
`nodeProtocols`Prefer the `node:` protocol prefix for Node.js built-in modules for clarity and consistency.	Node.js	logical
`nodeQueryMethods`Prefer modern `querySelector` and `querySelectorAll` over legacy DOM query methods.	Browser	stylistic (strict)
`nodeRemoveMethods`Prefer the modern `node.remove()` method over the legacy `parentNode.removeChild(node)` API.	Browser	logical (strict)
`nodeTestImports`	Vitest	logical
`nodeTextContents`Prefer `textContent` over `innerText` for DOM nodes.	Browser	logical (strict)
`nonInteractiveElementInteractions`Reports non-interactive elements with interactive event handlers.	JSX	logical
`nonInteractiveElementRoles`Reports non-interactive elements with interactive ARIA roles.	JSX	logical
`nonInteractiveElementTabIndexes`Reports non-interactive elements with positive or zero tabIndex values.	JSX	logical
`nonNullableTypeAssertions`	TypeScript	stylistic
`nonNullAssertedNullishCoalesces`	TypeScript	logical (strict)
`nonNullAssertedOptionalChains`	TypeScript	logical
`nonNullAssertionPlacement`	TypeScript	stylistic (strict)
`nonNullAssertions`	TypeScript	logical (strict)
`nonOctalDecimalEscapes`Reports non-octal decimal escape sequences (\8 and \9) in string literals.	TypeScript	logical
`nullishCoalescingOperators`	TypeScript	stylistic
`numberMethodRanges`	TypeScript	logical
`numberStaticMethods`	TypeScript	stylistic (strict)
`numericErasingOperations`	TypeScript	logical
`numericLiteralCasing`	TypeScript	stylistic (strict)
`numericLiteralParsing`Reports parseInt calls with binary, hexadecimal, or octal strings that can be replaced with numeric literals.	TypeScript	stylistic
`numericPrecision`	TypeScript	logical
`numericSeparatorGroups`	TypeScript	stylistic (strict)
`numericTrailingZeros`Reports trailing zeros in numeric values.	YAML	stylistic (strict)
`objectAssignSpreads`	TypeScript	stylistic
`objectCalls`Prefer `{}` object literal notation or `Object.create` instead of calling or constructing `Object`.	TypeScript	logical
`objectEntriesMethods`	TypeScript	stylistic (strict)
`objectHasOwns`Prefer Object.hasOwn() over Object.prototype.hasOwnProperty.call() for checking own properties.	TypeScript	stylistic
`objectKeyDuplicates`Reports unnecessary duplicate keys that override previous values.	TypeScript	untyped
`objectProto`Reports using the deprecated proto property to access or modify an object's prototype.	TypeScript	untyped
`objectPrototypeBuiltIns`Reports direct calls to Object.prototype methods on object instances.	TypeScript	logical
`objects`	Sorting	stylistic
`objectShorthand`	TypeScript	stylistic
`objectSpreadUnnecessaryFallbacks`	TypeScript	logical
`objectTypeDefinitions`	TypeScript	stylistic
`objectTypes`	Sorting	stylistic
`octalEscapes`Reports using octal escape sequences in string literals.	TypeScript	untyped
`octalNumbers`Reports using legacy octal numeric literals.	TypeScript	untyped
`olPrefixes`	Markdown	stylistic (strict)
`onceDirectiveValidity`	Vue	logical
`onDirectiveValidity`	Vue	logical
`onEventHyphens`	Vue	stylistic
`onEventStyles`	Vue	stylistic
`onExactModifiers`	Vue	logical
`operatorAssignmentShorthand`	TypeScript	stylistic
`optionalChainOperators`	TypeScript	stylistic
`optionalDependenciesPresence`	PackageJSON	(none)
`optionalDependenciesValidity`	PackageJSON	logical
`optionalPropDefaults`	Vue	logical
`osValidity`	PackageJSON	logical
`overloadSignaturesAdjacent`	TypeScript	stylistic
`packageCollections`	Sorting	stylistic
`parameterPropertyAssignment`	TypeScript	logical
`parameterReassignments`	TypeScript	stylistic (strict)
`parseIntRadixes`	TypeScript	logical
`peerDependenciesPresence`	PackageJSON	(none)
`peerDependenciesValidity`	PackageJSON	logical
`plainScalars`Prefer plain style scalars over quoted scalars.	YAML	stylistic (strict)
`plusOperands`	TypeScript	logical
`polyfillDuplicates`	Next.js	logical
`preDirectiveValidity`	Vue	logical
`privateValidity`	PackageJSON	logical
`processExits`Prevent direct use of `process.exit()` for better error handling and testing.	Node.js	logical
`promiseExecutorReturns`	TypeScript	logical
`promiseFinallyReturns`	TypeScript	logical
`promiseFunctionAsync`	TypeScript	stylistic
`promiseMethodSingleArrayArguments`	TypeScript	logical
`promiseRejectErrors`	TypeScript	logical
`promiseSettleAssertions`	Vitest	stylistic
`propDestructures`	SolidJS	logical
`propDuplicates`Disallow duplicate props in JSX elements.	JSX	logical
`propertyAccessNotation`	TypeScript	stylistic
`propertyOrdering`	PackageJSON	logical
`propertyValidity`	React	untyped
`propNameCasing`	Vue	stylistic
`propNameValidity`	Vue	logical
`propRequiredAndDefaults`	Vue	logical (strict)
`propTypeConstructors`	Vue	logical
`propTypes`	React	untyped
`propTypes`	Vue	logical
`publishConfigValidity`	PackageJSON	logical
`pureComponentShouldUpdateDefinitions`	JSX	logical (strict)
`purity`	React	logical
`reactivity`	SolidJS	logical
`reactLikeDeps`	SolidJS	untyped
`reactLikeProps`	SolidJS	untyped
`recursionOnlyArguments`	TypeScript	logical
`reduceTypeParameters`	TypeScript	logical (strict)
`redundantTypeConstituents`	TypeScript	logical
`referenceLikeUrls`Reports resource links/images with URLs that match definition identifiers.	Markdown	logical
`refOperands`	Vue	logical
`refs`	React	logical
`refStrings`	React	logical
`regexAllGlobalFlags`	TypeScript	logical
`regexAmbiguousInvalidity`	TypeScript	logical
`regexCharacterClasses`	TypeScript	stylistic (strict)
`regexCharacterClassRanges`	TypeScript	stylistic
`regexCharacterClassSetOperations`	TypeScript	stylistic
`regexConciseCharacterClassNegations`	TypeScript	stylistic
`regexContradictoryAssertions`	TypeScript	logical
`regexControlCharacterEscapes`	TypeScript	logical
`regexControlCharacters`	TypeScript	logical
`regexDigitMatchers`	TypeScript	stylistic (strict)
`regexDollarEscapes`	TypeScript	stylistic
`regexDuplicateCharacterClassCharacters`	TypeScript	logical
`regexDuplicateDisjunctions`	TypeScript	logical
`regexEmptyAlternatives`	TypeScript	logical
`regexEmptyCapturingGroups`	TypeScript	logical
`regexEmptyCharacterClasses`	TypeScript	logical
`regexEmptyGroups`	TypeScript	logical
`regexEmptyLazyQuantifiers`	TypeScript	logical
`regexEmptyLookaroundsAssertions`	TypeScript	logical
`regexEmptyStringLiterals`	TypeScript	logical
`regexEscapeBackspaces`	TypeScript	logical
`regexExecutors`	TypeScript	stylistic (strict)
`regexFlags`	Sorting	stylistic
`regexGraphemeStringLiterals`	TypeScript	logical (strict)
`regexHexadecimalEscapes`	TypeScript	stylistic (strict)
`regexIgnoreCaseFlags`	TypeScript	logical
`regexInvisibleCharacters`	TypeScript	logical
`regexLegacyFeatures`	TypeScript	logical
`regexLetterCasing`	TypeScript	stylistic (strict)
`regexLists`	Sorting	stylistic
`regexLiterals`	TypeScript	logical
`regexLookaroundAssertions`	TypeScript	stylistic (strict)
`regexLookaroundQuantifierOptimizations`	TypeScript	logical
`regexMatchNotation`	TypeScript	stylistic (strict)
`regexMisleadingCapturingGroups`	TypeScript	logical
`regexMisleadingQuantifiers`	TypeScript	logical
`regexMisleadingUnicodeCharacters`	TypeScript	logical
`regexNamedBackreferences`	TypeScript	stylistic (strict)
`regexNamedCaptureGroups`	TypeScript	logical
`regexNamedReplacements`	TypeScript	stylistic (strict)
`regexNonStandardFlags`	TypeScript	logical
`regexObscureRanges`	TypeScript	logical
`regexOctalEscapes`	TypeScript	logical
`regexPlusQuantifiers`	TypeScript	stylistic (strict)
`regexPredefinedAssertions`	TypeScript	stylistic
`regexQuantifierOptimizations`	TypeScript	logical
`regexQuestionQuantifiers`	TypeScript	stylistic (strict)
`regexRepeatQuantifiers`	TypeScript	stylistic
`regexResultArrayGroups`	TypeScript	stylistic (strict)
`regexSetOperationOptimizations`	TypeScript	logical
`regexStandaloneBackslashes`	TypeScript	logical
`regexStarQuantifiers`	TypeScript	stylistic (strict)
`regexSuperLinearBacktracking`	TypeScript	logical
`regexSuperLinearMoves`	TypeScript	logical
`regexTestMethods`	TypeScript	stylistic
`regexUnicodeCodepointEscapes`	TypeScript	stylistic (strict)
`regexUnicodeEscapes`	TypeScript	stylistic
`regexUnicodeFlag`	TypeScript	(none)
`regexUnicodeProperties`	TypeScript	stylistic
`regexUnnecessaryAssertions`	TypeScript	logical
`regexUnnecessaryBackreferences`	TypeScript	logical
`regexUnnecessaryCharacterClasses`	TypeScript	logical
`regexUnnecessaryCharacterRanges`	TypeScript	logical
`regexUnnecessaryDisjunctions`	TypeScript	logical
`regexUnnecessaryDollarReplacements`	TypeScript	logical
`regexUnnecessaryEscapes`	TypeScript	stylistic
`regexUnnecessaryLookaroundAssertions`	TypeScript	logical
`regexUnnecessaryNestedAssertions`	TypeScript	logical
`regexUnnecessaryNestedQuantifiers`	TypeScript	logical
`regexUnnecessaryNonCapturingGroups`	TypeScript	stylistic (strict)
`regexUnnecessaryNumericQuantifiers`	TypeScript	logical
`regexUnnecessaryOptionalAssertions`	TypeScript	logical
`regexUnnecessaryReferentialBackreferences`	TypeScript	logical
`regexUnnecessarySetOperands`	TypeScript	logical
`regexUnusedCapturingGroups`	TypeScript	logical
`regexUnusedFlags`	TypeScript	logical
`regexUnusedLazyQuantifiers`	TypeScript	logical
`regexUnusedQuantifiers`	TypeScript	logical
`regexValidity`	TypeScript	logical
`regexWordMatchers`	TypeScript	stylistic (strict)
`regexZeroQuantifiers`	TypeScript	logical
`removeEventListenerExpressions`Disallow inline function expressions in removeEventListener calls.	Browser	logical
`renderedLiteralLeaks`	JSX	logical (strict)
`renderReturns`	Vue	logical
`renderSetStates`	React	logical
`repositoryDirectoryValidity`	PackageJSON	logical
`repositoryShorthand`	PackageJSON	logical
`repositoryValidity`	PackageJSON	logical
`requireImports`	TypeScript	logical
`responseMethods`	TypeScript	stylistic
`restrictedComponentProps`	React	(none)
`restrictedDomProps`	React	(none)
`restrictedElements`	React	(none)
`restrictedGlobals`	TypeScript	(none)
`restrictedIdentifiers`	TypeScript	(none)
`restrictedImports`	TypeScript	(none)
`restrictedMatchers`	Vitest	(none)
`restrictedProperties`	TypeScript	(none)
`restrictedPropTypes`	React	(none)
`restrictedSyntax`	TypeScript	(none)
`restrictedTypes`	TypeScript	(none)
`restrictedViMethods`	Vitest	(none)
`returnAssignments`Reports using assignment expressions in return statements.	TypeScript	stylistic
`returnAwaitPromises`	TypeScript	logical
`returnThisTypes`	TypeScript	logical (strict)
`roleRedundancies`Reports redundant ARIA roles on elements with implicit roles.	JSX	logical
`roleRequiredAriaProps`Reports ARIA roles missing their required ARIA properties.	JSX	logical
`roleSupportedAriaProps`Reports ARIA properties that are not supported by an element's role.	JSX	logical
`roleTags`Reports ARIA roles that have semantic HTML element equivalents.	JSX	logical (strict)
`ruleDescriptions`	Flint	logical
`rulePresets`	Flint	logical
`rulesOfHooks`	React	logical
`ruleURLs`	Flint	logical
`scopeProps`Reports scope props on non-th elements.	JSX	logical
`scriptSetupExports`	Vue	logical
`scriptsValidity`	PackageJSON	logical
`scriptSyncs`	Next.js	logical
`scriptUrls`Reports `javascript:` URLs that can act as a form of eval.	Browser	logical
`scriptUrls`	JSX	logical
`selfAssignments`Reports self-assignments which have no effect and are likely errors.	TypeScript	logical
`selfClosingTags`	JSX	stylistic
`selfComparisons`Reports comparing a value to itself.	TypeScript	logical (strict)
`sequences`Reports using the comma operator in expressions.	TypeScript	untyped
`setDirectiveChildContentConflicts`	Astro	logical
`setHasExistenceChecks`	TypeScript	stylistic (strict)
`setHtmlDirectives`	Astro	security
`sets`	Sorting	stylistic
`setSizeLengthChecks`	TypeScript	stylistic (strict)
`setterReturns`	TypeScript	untyped
`setTextDirectives`	Astro	logical
`shadowedRestrictedNames`Reports variable declarations that shadow JavaScript's restricted names.	TypeScript	untyped
`shadows`	TypeScript	stylistic
`showDirectiveValidity`	Vue	logical
`showWhens`	SolidJS	stylistic
`singleVariableDeclarations`	TypeScript	logical
`sizeComparisonOperators`	TypeScript	stylistic (strict)
`slotArguments`	Vue	logical (strict)
`slotDirectiveValidity`	Vue	logical
`slotsAsFunctions`	Vue	logical
`slotStyles`	Vue	stylistic
`snapshotLocalTextContexts`	Vitest	logical
`solidImports`	SolidJS	logical
`sparseArrays`Reports array literals with holes (sparse arrays).	TypeScript	logical
`spreadAccumulators`Reports spread operations that accumulate values in loops, causing quadratic time complexity.	Performance	logical
`stateMutations`	React	logical
`staticComponents`	React	logical
`staticElementInteractions`Reports static elements with event handlers that lack ARIA roles.	JSX	logical
`staticMemberOnlyClasses`	TypeScript	stylistic (strict)
`strictBooleanExpressions`	TypeScript	logical
`stringCaseMismatches`	TypeScript	logical
`stringCodePoints`	TypeScript	logical (strict)
`stringMappingKeys`Enforces mapping keys to be strings.	YAML	logical (strict)
`stringSliceMethods`	TypeScript	stylistic (strict)
`stringStartsEndsWith`	TypeScript	stylistic
`stringTrimMethods`	TypeScript	stylistic (strict)
`structuredCloneMethods`	TypeScript	stylistic (strict)
`styledJsxInDocuments`	Next.js	logical
`stylePropObjects`	React	logical (strict)
`stylePropValidity`	SolidJS	untyped
`svgTitles`Reports <svg> elements without a <title> child element.	JSX	logical
`switchCases`	Sorting	stylistic
`symbolDescriptions`Reports Symbol() calls without description arguments.	TypeScript	stylistic
`tabIndexPositiveValues`Reports positive tabIndex values.	JSX	logical
`tableColumnCounts`Reports table rows with column counts that don't match the header.	Markdown	logical
`templateExpressionValues`	TypeScript	logical
`templateKeys`	Vue	logical
`templateRootValidity`	Vue	logical
`templateShadows`	Vue	logical (strict)
`templateVForOnChildren`	Vue	logical
`testBodyExpectations`	Vitest	logical
`testCaseAssertions`	Vitest	stylistic
`testCaseDuplicates`Reports test cases that are identical to previous test cases.	Flint	logical
`testCaseOnlies`	Flint	logical
`testCasePaddingLines`	Vitest	stylistic (strict)
`testCasesWithinDescribes`	Vitest	stylistic (strict)
`testConditionals`	Vitest	logical (strict)
`testDefinitionFunctions`	Vitest	(none)
`testPrefixes`	Vitest	stylistic
`testShorthands`	Flint	stylistic
`textareaMustacheChildren`	Vue	logical
`textDirectiveValidity`	Vue	logical
`thisAliases`	TypeScript	logical
`thisBeforeSuper`	TypeScript	untyped
`thisInTemplates`	Vue	logical (strict)
`throwErrors`	TypeScript	logical
`titleInDocumentHeads`	Next.js	logical
`titleRepeats`	Vitest	logical
`titleValidity`	Vitest	logical
`toContainMatchers`	Vitest	stylistic
`toHaveLengthMatchers`	Vitest	stylistic
`topLevelAwaits`	TypeScript	stylistic (strict)
`transitionToggles`	Vue	logical
`tripleSlashReferences`	TypeScript	logical
`tripleSlashReferenceValidity`	TypeScript	logical
`tsComments`	TypeScript	logical
`tslintComments`	TypeScript	stylistic
`typeAssertions`	TypeScript	stylistic
`typeConstituentDuplicates`	TypeScript	logical
`typeConstituents`	Sorting	stylistic
`typeExports`	TypeScript	stylistic
`typeImports`	TypeScript	stylistic
`typeofComparisons`Reports typeof expressions that compare impossible string literals.	TypeScript	untyped
`typePresence`	PackageJSON	logical
`typeRequired`	PackageJSON	logical
`typesPresence`	PackageJSON	(none)
`typeValidity`	PackageJSON	logical
`typos`	Next.js	logical
`typos`	React	logical
`unassignedVariables`Reports variables that are declared but never assigned a value.	TypeScript	untyped
`unboundMethods`	TypeScript	logical
`undefinedInitialValues`	TypeScript	stylistic
`undefinedTypeofChecks`	TypeScript	stylistic (strict)
`undefinedVariables`Reports using variables that are not defined.	TypeScript	untyped
`unescapedEntities`Disallow unescaped HTML entities in JSX text that may cause rendering issues.	JSX	stylistic
`unicodeBOMs`Reports files with Unicode Byte Order Marks (BOMs).	TypeScript	stylistic
`unifiedSignatures`	TypeScript	logical (strict)
`unionTypes`	Sorting	stylistic
`unnecessaryBind`	TypeScript	logical
`unnecessaryBlocks`Reports standalone block statements that don't create a meaningful scope.	TypeScript	stylistic
`unnecessaryBooleanCasts`	TypeScript	stylistic
`unnecessaryCatches`Reports catch clauses that only rethrow the caught error without modification.	TypeScript	logical
`unnecessaryComparisons`	TypeScript	logical
`unnecessaryComputedKeys`	TypeScript	stylistic
`unnecessaryConcatenation`Reports string concatenation using the + operator when both operands are string literals.	TypeScript	stylistic
`unnecessaryConditions`	TypeScript	logical
`unnecessaryConstructors`	TypeScript	stylistic
`unnecessaryContinues`	TypeScript	logical
`unnecessaryEscapes`	TypeScript	stylistic
`unnecessaryFragments`Disallow unnecessary JSX fragments that wrap a single child or have no children.	JSX	stylistic
`unnecessaryLogicalComparisons`	TypeScript	logical
`unnecessaryMathClamps`	TypeScript	logical
`unnecessaryNumericFractions`	TypeScript	logical
`unnecessaryQualifiers`	TypeScript	stylistic
`unnecessaryRenames`	TypeScript	stylistic
`unnecessaryReturns`	TypeScript	stylistic
`unnecessarySpreads`	TypeScript	logical
`unnecessaryTemplateAttributes`	Vue	logical
`unnecessaryTemplateExpressions`	TypeScript	logical
`unnecessaryTernaries`	TypeScript	stylistic (strict)
`unnecessaryTypeAnnotations`	TypeScript	stylistic
`unnecessaryTypeArguments`	TypeScript	logical
`unnecessaryTypeAssertions`	TypeScript	logical
`unnecessaryTypeConstraints`	TypeScript	logical
`unnecessaryTypeConversions`	TypeScript	logical
`unnecessaryTypeParameters`	TypeScript	logical
`unnecessaryUndefinedDefaults`	TypeScript	logical
`unnecessaryUseStricts`	TypeScript	logical
`unpublishedBins`	Node.js	logical
`unpublishedImports`	Node.js	logical
`unreachableStatements`	TypeScript	untyped
`unsafeDeclarationmerging`	TypeScript	logical
`unsafeEnumComparisons`	TypeScript	logical
`unsafeFunctionTypes`	TypeScript	logical
`unsafeInlineScripts`	Astro	security
`unsafeNegations`Reports negating the left operand of `in` or `instanceof` relations.	TypeScript	untyped
`unsafeOptionalChains`	TypeScript	untyped
`unsafeToString`	TypeScript	logical
`unsafeTypeAssertions`	TypeScript	logical
`unsafeUnaryNegations`	TypeScript	logical
`unsupportedNodeAPIs`	Node.js	logical
`unsupportedSyntax`	React	logical
`unusedClassComponentMethods`	React	logical
`unusedComponents`	Vue	logical
`unusedCssSelectors`	Astro	logical
`unusedExpressions`	TypeScript	logical
`unusedLabels`	TypeScript	stylistic
`unusedMessageIds`	Flint	logical
`unusedPlaceholders`	Flint	logical
`unusedPrivateClassMembers`	TypeScript	logical
`unusedPropTypes`	React	logical
`unusedState`	React	logical
`unusedStyleDefineVars`	Astro	logical
`unusedSwitchStatements`	TypeScript	logical
`unusedValues`	TypeScript	logical
`unusedVariables`	TypeScript	logical
`unusedVariables`	Vue	logical
`usageBeforeDefinition`	TypeScript	untyped
`uselessDefaultAssignments`	TypeScript	logical
`useMemoReturns`	React	logical
`useStateDestructures`	React	stylistic
`useStrictDirectives`	TypeScript	untyped
`valueSafety`Reports JSON values that are unsafe for data interchange.	JSON	logical
`varDeclarations`	TypeScript	stylistic
`variableBlockScopeUsage`	TypeScript	untyped
`variableDeclarations`	Sorting	stylistic
`variableDeletions`Reports attempting to delete variables with the delete operator.	TypeScript	untyped
`variableRedeclarations`	TypeScript	untyped
`versionPresence`	PackageJSON	logical
`versionValidity`	PackageJSON	logical
`vHtmlDirectives`	Vue	logical (strict)
`vIfsWithVFors`	Vue	logical
`viNamespaceNames`	Vitest	(none)
`vitestGlobalImports`	Vitest	stylistic
`voidOperator`Reports using the void operator.	TypeScript	stylistic
`vuePackageImports`	Vue	logical
`watchAfterAwaits`	Vue	logical
`watchArrowFunctions`	Vue	logical
`windowMessagingTargetOrigin`Requires specifying the targetOrigin argument when calling window.postMessage().	Browser	logical
`withStatements`Reports using with statements	TypeScript	untyped
`workspacesValidity`	PackageJSON	logical
`wrapperObjects`	TypeScript	logical
`wrapperObjectTypes`	TypeScript	logical
`yamlKeys`	Sorting	stylistic
`yamlSequenceValues`	Sorting	stylistic

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