✅ Linter rules from other sources

[Conaclos]

This post lists the rules from other linters and indicates the equivalent Biome rules. Some rules related to styles are not listed here because Biome handle them in its formatter. If any rules or details are missing, please let's us know!

Want to contribute? 😃 Check out the opened linter Issues. If you want to work on one of them, ask in the issue, we will assign it to you; This prevents several people to work on the same issue. Don't worry, we can unassign you later if you are no longer interested in the issue! If you'd rather work on a rule that's not in an issue, open an issue first, or talk about it in the present discussion. You can also reach out on our Discord server. Also, read our contributing guide and our analyzer contributing guide.

Legend:

• ✅ recommended rule
• 🍼 nursery rules (unstable Biome rule)
• 🔒 strict rule (ESLint-specific)
• 🎨 stylistic rule (ESLint-specific)
• 💭 require type information (TypeScript ESLint-specific)
• 🔧 safe fixes
• ⚠️ unsafe fixes

Summary:

• Biome's exclusive rules
• ESLint
• TypeScript ESLint
• ESLint Plugin Barrel Files
• ESLint Plugin Jest
• ESLint Plugin JSX A11y
• ESLint Plugin React
• ESLint Plugin React Hooks
• ESLint Plugin Unicorn
• Rust Clippy

Biome's exclusive rules

Biome		Description and notes
noAccumulatingSpread	✅	Disallow the use of spread … syntax on accumulators.
noAssignInExpressions	✅	Disallow assignments in expressions.
noEmptyTypeParameters	✅	Disallow empty type parameters in type aliases and interfaces.
noConstEnum	✅🔧	Disallow TypeScript const enum.
noGlobalIsFinite	✅⚠️	Use Number.isFinite instead of global isFinite.
noGlobalIsNan	✅⚠️	Use Number.isNan instead of global isNan.
noImplicitAnyLet	✅	Disallow use of implicit any type on variable declarations.
noRedundantUseStrict	✅🔧	Prevents from having redundant "use strict".
noSuspiciousSemicolonInJsx		Detect possible “wrong” semicolons inside JSX elements.
noUnusedImports	🔧	Disallow unused imports.
noUndeclaredDependencies	🍼	Disallow the use of dependencies that aren’t specified in the package.json.
noUselessThisAlias	✅🔧	Disallow useless this aliasing.
noVoidTypeReturn	✅	Disallow returning a value from a function with the return type void.
useNodeAssertStrict	🔧	Promotes the usage of node:assert/strict over node:assert.
useSimpleNumberKeys	✅🔧	Disallow number literal object member names which are not base10 or uses underscore as separator.
useSimplifiedLogicExpression	⚠️	Discard redundant terms from logical expressions.
useSortedClasses	🍼	Enforce the sorting of CSS utility classes.
useWhile	✅🔧	Enforce the use of while loops instead of for loops when the initializer and update expressions are not needed.

ESLint

Eslint		Biome		Description and notes
array-callback-return	⚠️			Enforce return statements in callbacks of array methods
complexity		noExcessiveCognitiveComplexity		Disallow functions that exceed a given complexity score. Biome relies on cognitive complexity.
constructor-super	✅	noInvalidConstructorSuper	✅	Verify super() is called only in constructors of derived classes.
curly	🔧	useBlockStatements	⚠️	Require block statement for if and loops
default-case-last		useDefaultSwitchClauseLast	✅	Enforce default switch clause to be last.
default-param-last		useDefaultParameterLast	✅	Enforce default and optional function parameters to be last.
dot-notation	🔧	useLiteralKeys	✅⚠️	Enforces .prop notation instead of computed ["prop"] notation
eqeqeq	🔧	noDoubleEquals	✅⚠️	Require the use of === and !==. Biome allows == and != against null.
for-direction	✅	useValidForDirection	✅	Check the condition and update of `for`` loops to detect infinite loops.
getter-return		useGetterReturn	✅	Enforce that getter have a return statement on all exit paths.
no-array-constructor	⚠️			Disallow Array constructors in favor of array literal
no-async-promise-executor		noAsyncPromiseExecutor	✅	Disallow async functions as Promise executors.
no-case-declarations	✅	noSwitchDeclarations	✅🔧	Disallow lexical declarations in switch clauses.
no-class-assign	✅	noClassAssign	✅	Disallow assigning to a variable bound to a class declaration.
no-compare-neg-zero	✅	noCompareNegZero	✅🔧	Disallow comparing against -0.
no-cond-assign	✅	noAssignInExpressions	✅	Disallow assignment expression in conditions. Biome extends the rule to all expressions.
no-console		noConsoleLog		Disallow the use of console. Biome relaxes the rule by only disallowing console.log.
no-const-assign	✅	noConstAssign	✅	Disallow assigning to constant bindings.
no-constant-binary-expression				Disallow expressions where the operation doesn't affect the value
no-constant-condition	✅	noConstantCondition	✅	Disallow constant expressions in conditions. Biome allows while(true) {}.
no-constructor-return		noConstructorReturn	✅	Disallow returning a value from a constructor.
no-control-regex		noControlCharactersInRegex	✅	Disallow control characters in regex.
no-debugger	✅	noDebugger	✅⚠️	Disallow the use of debugger.
no-delete-var	✅	noDelete	✅	Disallow the use of the delete operator on variables. Biome extends the rule by disallowing all delete operations.
no-dupe-args	✅	noDuplicateParameters	✅	Disallow multiple parameters of a function from having the same name.
no-dupe-class-members	✅	noDuplicateClassMembers	✅	Disallow multiple members of a class from having the same name.
no-dupe-else-if	✅	noDuplicateElesIf	🍼	Disallow multiple if in the same chain from having the same condition.
no-dupe-keys	✅	noDuplicateObjectKeys	✅	Disallow multiple members in an object from having the same name.
no-duplicate-case	✅	noDuplicateCase	✅	Disallow multiple case in a switch from having the same condition.
no-else-return	🔧	noUselessElse	✅⚠️	Disallow else blocks ending with a return. Biome handles more cases where a else is useless because its if branches break.
no-empty-character-class	✅	noEmptyCharacterClassInRegex	✅	Disallow empty character classes in regex.
no-empty-pattern	✅	noEmptyPattern	✅	Disallow empty destructuring patterns
no-empty-static-block		noEmptyBlockStatements		Disallow empty static class blocks.
no-empty	✅⚠️	noEmptyBlockStatements		Disallow empty blocks.
no-eval		noGlobalEval	✅	Disallow the use of eval.
no-ex-assign	✅	noCatchAssign	✅	Disallow assigning to the exception binding in a catch clause.
no-extra-boolean-cast	✅🔧	noExtraBooleanCast	✅⚠️	Disallow unnecessary boolean casts.
no-extra-label	✅🔧	noUselessLabel	✅🔧	Disallow using single-level deep labelled breaks.
no-fallthrough	✅	noFallthroughSwitchClause	✅	Disallow fallthrough between case clauses in switch statements.
no-func-assign	✅	noFunctionAssign	✅	Disallow assigning to a variable bound to a function declaration.
no-global-assign		noGlobalAssign	✅	Disallow assignment to native objects or readonly global variables.
no-implicit-coercion				Disallow shorthand type conversions.
no-import-assign	✅	noImportAssign	✅	Disallow assigning to the binding created by an import.
no-inner-declarations	✅	noInnerDeclarations	✅	Disallow function declarations in nested statements
no-irregular-whitespace	✅			Disallow all whitespace characters that are not spaces or tabulations.
no-label-var		noLabelVar	✅	Disallow labels that share a name with a variable
no-labels		noConfusingLabels	✅	Disallow labels. Biome allows labels on loops.
no-lone-blocks		noUselessLoneBlockStatements	✅🔧	Disallow useless block statements.
no-lonely-if	🔧	useCollapsedElseIf	🔧	Disallow if as the only statement in an else block.
no-loss-of-precision	✅	noPrecisionLoss	✅	Disallow numeric literals whose value cannot be accurately represented by a float.
no-misleading-character-class		noMisleadingCharacterClass	✅	Disallows characters which are made with multiple code points in regex character class syntax.
no-negated-condition		noNegationElse	⚠️	Disallow negation in the condition of an if statement if it has an else clause.
no-new-native-nonconstructor		noInvalidNewBuiltin	✅⚠️	Disallow new operators with global non-constructor functions. Should replace no-new-symbol?
no-new-symbol	✅⚠️	noNewSymbol	✅⚠️	Disallows calling the Symbol function as a constructor.
no-new-wrappers				Disallow new on Boolean, String, and Number.
no-nonoctal-decimal-escape	✅⚠️	noNonoctalDecimalEscape	✅⚠️	Disallow \8 and \9 escape sequences in string literals.
no-obj-calls	✅	noGlobalObjectCalls	✅	Disallows calling global builtin objects as functions Better suited for a typechecker?
no-param-reassign		noParameterAssign	✅	Disallow reassigning function parameters.
no-prototype-builtins	✅	noPrototypeBuiltins	✅	Disallow calling methods from Object.prototype directly on object instances.
no-redeclare	✅	noRedeclare	✅	Disallow variable, function, class, and type redeclarations in the same scope.
no-regex-spaces	✅🔧	noMultipleSpacesInRegularExpressionLiterals	✅🔧	Disallow unclear usage of multiple space characters in regex.
no-return-assign		noAssignInExpressions	✅	Disallow assignment operators in return statements. Biome extends the rule to all expressions.
no-restricted-globals		noRestrictedGlobals		Specify global variable names that you don’t want to use in your application.
no-restricted-imports				Disallow some imports.
no-self-assign	✅	noSelfAssign	✅	Disallow assigning a variable to itself.
no-self-compare		noSelfCompare	✅	Disallow comparisons where both sides are exactly the same.
no-sequences		noCommaOperator	✅	Disallow comma operator.
no-setter-return	✅	noSetterReturn	✅	Disallow returning a value in a setter.
no-shadow				Disallow variable declarations from shadowing variables declared in the outer scope
no-shadow-restricted-names	✅	noShadowRestrictedNames	✅	Disallow identifiers from shadowing restricted names.
no-sparse-array	✅	noSparseArray	✅	Disallow sparse arrays.
no-this-before-super	✅	noUnreachableSuper	✅	Disallow using this before calling super in a derived class.
no-undef-init	🔧			Disallow useless undefined initialization. Suggested name: noUselessUndefinedIntializion.
no-undef	✅	noUndeclaredVariables		Disallow the use of undeclared variables.
no-unneeded-ternary	🔧	noUselessTernary	✅⚠️	Disallow ternary expressions when a simpler alternative exists.
no-unreachable	✅	noUnreachable	✅	Disallow code that is statically known to be never reached.
no-unsafe-finally	✅	noUnsafeFinally	✅	Disallow control flow statement in finally blocks.
no-unsafe-negation	✅⚠️	noUnsafeNegation	✅⚠️	Disallow using unsafe negation.
no-unsafe-optional-chaining	✅	noUnsafeOptionalChaining	✅	Disallows optional chaining in contexts where undefined is not allowed. Better suited for a typechecker?
no-unused-labels	✅🔧	noUnusedLabels	✅⚠️	Enforce labeled statements are referenced by a labelled break.
no-unused-private-class-members		noUnusedPrivateClassMembers	⚠️	Disallow unused #private class members
no-unused-vars	✅	noUnusedVariables	⚠️	Disallow unused variables.
no-use-before-define		noInvalidUseBeforeDeclaration	✅	Disallow the use of variables and function parameters before their declaration
no-useless-backreference	✅			Disallow useless backreference in regex.
no-useless-call				Disallow useless call to Function#call and Function#apply
no-useless-catch	✅	noUselessCatch	✅	Disallow unnecessary catch clauses.
no-useless-computed-key	🔧	useLiteralKeys	✅	Disallow computed keys with literals in object expressions.
no-useless-constructor		noUselessConstructor	✅⚠️	Disallow unnecessary constructors.
no-useless-escape	✅⚠️			Disallow useless character escape.
no-useless-rename	🔧	noUselessRename	✅🔧	Disallow renaming import, export, and destructured assignments to the same name.
no-useless-return	🔧			Disallow returning undefined as the terminating statement of a function. Conflicts should be avoided with noGetterReturn.
no-var	🔧	noVar	✅⚠️	Disallow the use of var.
no-void		noVoid		Disallow the use of void operators, which is not a familiar operator.
no-with	✅	noWith	✅	Disallow with statements in non-strict contexts.
object-shorthand	🔧			Enforce shorthand syntax in object expressions.
one-var	🔧	useSingleVarDeclarator	✅⚠️	Disallow multiple variable declarations in the same variable statement.
operator-assignment	🔧	useShorthandAssign	⚠️	Enforce the use of shorthand operator assignment += and others.
prefer-arrow-callback	🔧	useArrowFunction	✅🔧	Prefer arrow functions to function expressions. Biome extends the rule to all function expressions without this
prefer-const	🔧	useConst	✅🔧	Require const declarations for variables that are never reassigned after declared.
prefer-destructuring				Prefer destructuring patterns for array and objects.
prefer-exponentiation-operator	🔧	useExponentiationOperator	✅⚠️	Prefer using ** instead of Math.pow.
prefer-named-capture-group	⚠️			Enforce using named capture group in regular expression
prefer-numeric-literals	🔧	useNumericLiterals	✅⚠️	Disallow calling parseInt with string literals
prefer-object-has-own	🔧			Prefer Object.hasOwn() over Object.prototype.hasOwnProperty.call()
prefer-object-spread	🔧			Prefer object spread members to calling Object.assign.
prefer-regex-literals	⚠️	useRegexLiterals	✅⚠️	Disallow calling the RegExp constructor with string literals
prefer-rest-params		noArguments	✅	Disallow the use of arguments.
prefer-template	🔧	useTemplate	✅⚠️	Template literals are preferred over string concatenation.
require-unicode-regexp	⚠️			Require u or v regex flag when needed.
require-await		useAwait		Require async function to contain await.
require-yield	✅	useYield	✅	Require generator functions to contain yield.
use-isnan	✅	useIsNan	✅⚠️	Requires calling isNaN when comparing to NaN.
valid-typeof	✅⚠️	useValidTypeof	✅⚠️	Enforces comparing typeof expressions against valid strings.
yoda	🔧			Enforce literals are in the right hand side of comparisons.

TypeScript ESLint

Eslint		Biome		Description and notes
adjacent-overload-signatures	🎨			Require that function overload signatures be consecutive
array-type	🎨🔧	useConsistentArrayType	⚠️	Enforce T[]. ESLint has a configuration to enforce Array<T> instead.
await-thenable	✅💭			Disallow awaiting a value that is not a Thenable
ban-ts-comment	✅			Disallow @ts-<directive> comments or require descriptions after directives
ban-types	✅🔧⚠️	noBannedTypes	✅🔧
consistent-generic-constructors	🎨🔧			Enforce specifying generic type arguments on constructor name. EsLint provides an option to enforce specifying generic type arguments with type annotation instead.
consistent-indexed-object-style	🎨🔧			Require or disallow the Record type.
consistent-type-exports	🔧💭	useExportType	✅🔧	Enforce the usage of export type in a consistent way.
consistent-type-imports	🔧	useImportType	✅🔧	Enforce the usage of import type in a consistent way.
method-signature-style	🔧			Enforce using a particular method signature syntax. The Biome rule could choose one form: Maybe the strictest one (property signature).
naming-convention	💭	useNamingConvention	🔧	Enforce naming conventions for everything across a codebase.
no-confusing-non-null-assertion	🎨🔧⚠️			Disallow non-null assertion in locations that may be confusing.
no-duplicate-enum-values	✅			Disallow duplicate enum member values.
no-dynamic-delete	🔒🔧			Disallow using the delete operator on computed key expressions
no-empty-interface	🎨🔧⚠️	noEmptyInterface	✅🔧	Disallow the declaration of empty interfaces.
no-explicit-any	✅🔧⚠️	noExplicitAny	✅	Disallow the any type.
no-extra-non-null-assertion	✅🔧	noExtraNonNullAssertion	✅🔧
no-extraneous-class	🔒	noStaticOnlyClass	✅	Disallow classes used as namespaces.
no-floating-promises	✅⚠️💭			Require Promise-like statements to be handled appropriately.
no-for-in-array	✅💭			Disallow iterating over an array with a for-in loop.
no-import-type-side-effects	✅	useImportType	✅🔧	Enforce the use of top-level import type qualifier when an import only has specifiers with inline type qualifiers.
no-inferrable-types	🎨🔧	noInferrableTypes	✅🔧
no-invalid-void-type	🔒	noConfusingVoidType	✅⚠️	Disallow void type outside of generic or return types.
no-misused-new	✅	noMisleadingInstantiator	✅	Enforce valid definition of new and constructor.
no-misused-promises	✅💭			Disallow Promises in places not designed to handle them.
no-mixed-enums	🔒💭			Disallow enums from having both number and string members.
no-namespace	✅	noNamespace		Disallow TypeScript namespaces.
no-non-null-asserted-nullish-coalescing	🔒⚠️			Disallow non-null assertions in the left operand of a nullish coalescing operator.
no-non-null-asserted-optional-chain	✅⚠️			Disallow non-null assertions after an optional chain expression
no-non-null-assertion	✅⚠️	noNonNullAssertion	✅⚠️	Disallow non-null assertions using the ! postfix operator.
no-redundant-type-constituents	✅💭			Disallow members of unions and intersections that do nothing or override type information
no-this-alias	✅	noUselessThisAlias	✅🔧	Disallow aliasing this. Biome disallows only useless this aliasing.
no-unnecessary-boolean-literal-compare	🔒🔧💭			Disallow unnecessary equality comparisons against boolean literals.
no-unnecessary-condition	🔒🔧💭			Disallow conditionals where the type is always truthy or always falsy. Should replace noCOnstantCondition?
no-unnecessary-type-arguments	✅⚠️	noUselessTypeConstraint	✅🔧	Disallow unnecessary constraints on generic types. Biome also handles useless unknown constraint.
no-unsafe-arguments	✅💭			Disallow calling a function with a value with type any.
no-unsafe-assignment	✅💭			Disallow assigning a value with type any to variables and properties.
no-unsafe-call	✅💭			Disallow calling a value with type any.
no-unsafe-declaration-merging	✅	noUnsafeDeclarationMerging	✅	Disallow unsafe declaration merging.
no-unsafe-enum-comparison	✅💭			Disallow comparing an enum value with a non-enum value.
no-unsafe-member-access	✅💭			Disallow member access on a value with type any.
no-unsafe-return	✅💭			Disallow returning a value with type any from a function.
no-use-before-define		noInvalidUseBeforeDeclaration	✅	Disallow the use of variables and function parameters before their declaration
no-useless-empty-export	🔧	noUselessEmptyExport	✅🔧	Disallow empty exports that don't change anything in a module file.
no-useless-template-literals	💭	noUnusedTemplateLiteral	✅⚠️	Disallow template literals if interpolation and special-character handling are not needed.
parameter-properties		noParameterProperties		Disallow parameter properties. EsLint provides an option to enforce their use.
prefer-as-const	✅🔧⚠️	useAsConstAssertion	✅🔧	Enforce the use of as const over literal type
prefer-enum-initializers	⚠️	useEnumInitializers	✅🔧	Require each enum member value to be explicitly initialized.
prefer-function-type	🎨🔧	useShorthandFunctionType	✅🔧	Enforces using function types instead of interfaces with call signatures
prefer-for-of	🎨	useForOf		Enforce the use of for of loop over the standard for loop where possible.
prefer-includes	🔒🔧💭			Enforce includes method over indexOf method.
prefer-literal-enum-member	🔒	useLiteralEnumMembers	✅	Require all enum members to be literal values. Biome also supports arbitrary literal numeric expressions and enum flags.
prefer-namespace-keyword	🎨🔧	useNamespaceKeyword	✅🔧	Require using namespace keyword over module keyword to declare custom TypeScript modules.
prefer-nullish-coalescing	🎨⚠️💭			Enforce using the nullish coalescing operator instead of logical assignments or chaining.
prefer-optional-chain	🎨🔧⚠️💭	useOptionalChain	✅⚠️	Enforce using concise optional chain expressions instead of chained logical ands, negated logical ors, or empty objects.
prefer-regexp-exec	🔧💭			Enforce RegExp#exec over String#match if no global flag is provided.
prefer-return-this-type	🔒🔧💭			Enforce that this is used when only this type is returned.
prefer-string-starts-ends-with	🎨🔧💭			Enforce using String#startsWith and String#endsWith over other equivalent methods of checking substrings.
promise-function-async	🔧💭			Require any function or method that returns a Promise to be marked async.
restrict-plus-operands	✅💭			Require both operands of addition to be the same type and be bigint, number, or string
restrict-template-expressions	✅💭			Enforce template literal expressions to be of string type.
strict-boolean-expressions	🔧⚠️💭			Disallow certain types in boolean expressions.
switch-exhaustiveness-check	⚠️💭			Require switch-case statements to be exhaustive with union type.
unified-signatures	🔒			Disallow two overloads that could be unified into one with a union or an optional/rest parameter.

ESLint Plugin Barrel Files

Eslint		Biome		Description and notes
avoid-barrel-files	✅	noBarrelFile		Disallow the use of barrel file.
avoid-namespace-import	✅	noNamespaceImport		Disallow the use of namespace imports import * as.
avoid-re-export-all	✅	noReExportAll		Avoid exxport * from.

ESLint Plugin Jest

Eslint		Biome		Description and notes
consistent-test-it	🔧			Enforce test and it usage conventions
expect-expect	✅			Enforce assertion to be made in a test body
max-nested-describe		noExcessiveNestedTestSuites	✅	Enforces a maximum depth to nested describe calls
no-alias-methods	✅🔧			Disallow alias
no-commented-out-tests				Disallow commented out tests
no-conditional-expect	✅			Disallow calling expect conditionally
no-conditional-in-test				Disallow conditional logic in tests
no-confusing-set-timeout				Disallow confusing usages of jest.setTimeout
no-deprecated-functions	✅🔧			Disallow use of deprecated functions
no-disabled-tests	⚠️	noSkippedTests		Disallow disabled tests
no-done-callback	✅	noDoneCallback	🍼	Disallow using a callback in asynchronous tests and hooks
no-duplicate-hooks		noDuplicateTestHooks	✅	Disallow duplicate setup and teardown hooks
no-export	✅	noExportsInTest	✅	Disallow using exports in files containing
no-focused-tests	✅⚠️	noFocusedTests	✅⚠️	Disallow focused tests
no-identical-title	✅			Disallow identical titles
no-interpolation-in-snapshots	✅			Disallow string interpolation inside snapshot
no-jasmine-globals	✅🔧			Disallow Jasmine globals
no-mocks-import	✅			Disallow manually importing from __mocks__
no-standalone-expect	✅	noMisplacedAssertion	🍼	Disallow using expect outside of it or test
no-test-prefixes	✅🔧			Require using .only and .skip over f and x
no-test-return-statement				Disallow explicitly returning from tests
no-untyped-mock-factory	🔧			Disallow using jest.mock() factories without an explicit type
prefer-called-with				Suggest using toBeCalledWith() or toHaveBeenCalledWith()
prefer-comparison-matcher	🔧			Suggest using the built-in comparison
prefer-each				Prefer using .each rather than manual loops
prefer-equality-matcher				Suggest using the built-in equality matchers
prefer-expect-resolves	🔧			Prefer await expect(...).resolves over expect(await ...)
prefer-lowercase-title	🔧			Enforce lowercase test names
prefer-mock-promise-shorthand	🔧			Prefer mock resolved/rejected shorthands for promises
prefer-spy-on	🔧			Suggest using jest.spyOn()
prefer-strict-equal				Suggest using toStrictEqual()
prefer-to-be	🎨🔧			Suggest using toBe() for primitive literals
prefer-to-contain	🎨🔧			Suggest using toContain()
prefer-to-have-length	🎨🔧			Suggest using toHaveLength()
prefer-todo	🔧			Suggest using test.todo
require-to-throw-message				Require a message for toThrow()
valid-describe-callback	✅			Enforce valid describe() callback
valid-expect	✅			Enforce valid expect() usage
valid-expect-in-promise	✅			Require promises that have expectations in their chain to be valid
valid-title	✅🔧			Enforce valid titles

ESLint Plugin JSX A11y

Eslint		Biome		Description and notes
alt-text	✅	useAltText	✅	Enforce that all elements that require alternative text have meaningful information to relay back to the end user.
anchor-ambiguous-text				Enforce <a> text to not exactly match "click here", "here", "link", or "a link".
anchor-has-content	✅	useAnchorContent	✅⚠️	Enforce that anchors have content and that the content is accessible to screen readers.
anchor-is-valid	✅	useValidAnchor	✅	Enforce all anchors are valid, navigable elements.
aria-activedescendant-has-tabindex	✅	useAriaActivedescendantWithTabindex	✅⚠️	Enforce elements with aria-activedescendant are tabbable.
aria-props	✅	useValidAriaProps	✅	Enforce all aria-* props are valid.
aria-proptypes	✅	useValidAriaValues	✅	Enforce ARIA state and property values are valid.
aria-role	✅	useValidAriaRole	✅⚠️	Enforce that elements with ARIA roles must use a valid, non-abstract ARIA role.
aria-unsupported-elements	✅	noAriaUnsupportedElements	✅⚠️	Enforce that elements that do not support ARIA roles, states, and properties do not have those attributes.
autocomplete-valid	✅			Enforce that autocomplete attributes are used correctly.
click-events-have-key-events	✅	useKeyWithClickEvents	✅	Enforce a clickable non-interactive element has at least one keyboard event listener.
control-has-associated-label				Enforce that a control (an interactive element) has a text label.
heading-has-content	✅	useHeadingContent	✅	Enforce heading contain accessible content.
html-has-lang	✅	useHtmlLang	✅	Enforce <html> element has lang prop.
iframe-has-title	✅	useIframeTitle	✅	Enforce iframe elements have a title attribute.
img-redundant-alt	✅	noRedundantAlt	✅	Enforce <img> alt prop does not contain the word "image", "picture", or "photo".
interactive-supports-focus	✅			Enforce that elements with interactive handlers like onClick must be focusable.
label-has-associated-control	✅			Enforce that a label tag has a text label and an associated control.
lang		useValidLang	✅	Enforce lang attribute has a valid value.
media-has-caption	✅	useMediaCaption	✅	Enforces that <audio> and <video> elements must have a <track> for captions.
mouse-events-have-key-events	✅	useKeyWithMouseEvents	✅	Enforce that onMouseOver/onMouseOut are accompanied by onFocus/onBlur for keyboard-only users.
no-access-key	✅	noAccessKey	✅⚠️	Enforce that the accessKey prop is not used on any element to avoid complications with keyboard commands used by a screenreader.
no-aria-hidden-on-focusable		noAriaHiddenOnFocusable	✅⚠️	Disallow aria-hidden="true" from being set on focusable elements.
no-autofocus	✅	noAutofocus	✅⚠️	Enforce autoFocus prop is not used.
no-distracting-elements	✅	noDistractingElements	✅⚠️	Enforce distracting elements are not used.
no-interactive-element-to-noninteractive-role	✅	noInteractiveElementToNoninteractiveRole	✅	Interactive elements should not be assigned non-interactive roles.
no-noninteractive-element-interactions	✅			Non-interactive elements should not be assigned mouse or keyboard event listeners.
no-noninteractive-element-to-interactive-role	✅	noNoninteractiveElementToInteractiveRole	✅	Non-interactive elements should not be assigned interactive roles.
no-noninteractive-tabindex	✅	noNoninteractiveTabindex	✅	tabIndex should only be declared on interactive elements.
no-redundant-roles	✅	noRedundantRoles	✅⚠️	Enforce explicit role property is not the same as implicit/default role property on element.
no-static-element-interactions	✅			Enforce that non-interactive, visible elements (such as <div>) that have click handlers use the role attribute.
prefer-tag-over-role	✅			Enforces using semantic DOM elements over the ARIA role.
role-has-required-aria-props	✅	useAriaPropsForRole	✅	Enforce that elements with ARIA roles must have all required attributes for that role.
role-supports-aria-props	✅			Enforce that elements with explicit or implicit roles defined contain only aria-* properties supported by that role.
scope	✅	noHeaderScope	✅⚠️	Enforce scope prop is only used on <th> elements.
tabindex-no-positive	✅	noPositiveTabindex	✅⚠️	Enforce tabIndex value is not greater than zero.

ESLint Plugin React

Eslint		Biome		Description and notes
button-has-type		useButtonType	✅	Disallow usage of button elements without an explicit type attribute
display-name	✅			Disallow missing displayName in a React component definition
jsx-boolean-value	🔧	noImplicitBoolean	🔧	Disallow implicit true values on JSX boolean attributes
jsx-curly-brace-presence	🔧			Disallow unnecessary JSX expressions when literals alone are sufficient or enforce JSX expressions on literals in JSX children or attributes
jsx-fragments	🔧	useFragmentSyntax		Enforce shorthand or standard form for React fragments
jsx-key	✅	useJsxKeyInIterable	✅	Disallow missing key props in iterators/collection literals
jsx-no-comment-textnodes	✅	noCommentText	✅	Disallow comments from being inserted as text nodes
jsx-no-duplicate-props	✅	noDuplicateJsxProps	✅	Disallow duplicate properties in JSX
jsx-no-target-blank	✅🔧	noBlankTarget	✅🔧	Disallow target="_blank" attribute without rel="noreferrer"
jsx-no-undef	✅	noUndeclaredVariables		Disallow undeclared variables in JSX
jsx-no-useless-fragment	🔧	noUselessFragments	✅⚠️	Disallow unnecessary fragments
jsx-pascal-case				Enforce PascalCase for user-defined JSX components
no-array-index-key		noArrayIndexKey	✅	Disallow usage of Array index in keys
no-children-prop	✅	noChildrenProp	✅	Disallow passing of children as props
no-danger		noDangerouslySetInnerHtml	✅	Disallow usage of dangerous JSX properties
no-danger-with-children	✅	noDangerouslySetInnerHtmlWithChildren	✅	Disallow when a DOM element is using both children and dangerouslySetInnerHTML
no-deprecated	✅			Disallow usage of deprecated methods
no-direct-mutation-state	✅			Disallow direct mutation of this.state
no-find-dom-node	✅			Disallow usage of findDOMNode
no-invalid-html-attribute	⚠️			Disallow usage of invalid attributes
no-is-mounted	✅			Disallow usage of isMounted
no-namespace				Enforce that namespaces are not used in React elements
no-render-return-value	✅			Disallow usage of the return value of ReactDOM.render
no-string-refs	✅			Disallow using string references
no-this-in-sfc				Disallow this from being used in stateless functional components
no-unescaped-entities	✅			Disallow unescaped HTML entities from appearing in markup
no-unknown-property	✅🔧			Disallow usage of unknown DOM property
no-unsafe	✅			Disallow usage of unsafe lifecycle methods
prop-types	✅			Disallow missing props validation in a React component definition
require-render-return	✅			Enforce ES5 or ES6 class for returning value in render function
void-dom-elements-no-children		noVoidElementsWithChildren	✅⚠️	Prevents self-closing elements from having children

ESLint Plugin React Hooks

Eslint		Biome		Description and notes
exhaustive-deps	✅	useExhaustiveDependencies	✅	Enforce all dependencies are correctly specified.
rules-of-hooks	✅	useHookAtTopLevel		Enforce that all React hooks are being called from the Top Level component functions. useHookAtTopLevel check only the first rule of hooks.

ESLint Plugin Unicorn

Eslint		Biome		Description and notes
better-regex	✅🔧			Improve regexes by making them shorter, consistent, and safer.
consistent-function-scoping	✅			Move function definitions to the highest possible scope.
custom-error-definition				Enforce correct Error subclassing.
error-message	✅			Enforce passing a message value when creating a built-in error.
explicit-length-check	✅🔧			Enforce explicitly comparing the length or size property of a value.
filename-case	✅	useFilenamingConvention		Enforce a case style for filenames.
new-for-builtins	✅🔧			Enforce the use of new for all builtins, except String, Number, Boolean, Symbol and BigInt.
no-array-for-each	✅🔧	noForEach	✅🔧	Prefer for…of over the forEach method.
no-console-spaces	✅🔧			Do not use leading/trailing space between console.log parameters.
no-document-cookie	✅			Do not use document.cookie directly.
no-for-loop	✅🔧	useForOf		Do not use a for loop that can be replaced with a for…of loop.
no-instanceof-array	✅🔧	useIsArray	✅⚠️	Use Array.isArray() instead of instanceof Array.
no-lonely-if	✅🔧			Disallow if statements as the only statement in if blocks without else.
no-negated-condition	✅🔧	noNegationElse	⚠️	Disallow negation in the condition of an if statement if it has an else clause.
no-new-array	✅🔧			Disallow new Array().
no-static-only-class	✅	noStaticOnlyClass	✅	Disallow classes that only have static members.
no-thenable	✅	noThenProperty	✅	Disallow then property.
no-typeof-undefined	✅🔧	useValidTypeof	✅⚠️	Disallow comparing undefined using typeof.
no-useless-fallback-in-spread	✅🔧			Disallow useless fallback when spreading in object literals.
no-useless-length-check	✅🔧			Disallow useless array length check. useConsistentArrayApis?
no-useless-promise-resolve-reject	✅🔧			Disallow returning/yielding Promise.resolve/Promise.reject() in async functions or promise callbacks
no-useless-spread	✅🔧			Disallow unnecessary spread.
no-useless-switch-case	✅⚠️	noUselessSwitchCase	✅⚠️	Disallow useless case in switch statements.
no-useless-undefined	✅🔧			Disallow useless undefined.
prefer-add-event-listener	✅🔧			Prefer .addEventListener() and .removeEventListener() over on-functions.
prefer-array-find	✅🔧			Prefer .find(…) and .findLast(…) over the first or last element from .filter(…). useConsistentArrayApis?
prefer-array-flat	✅🔧			Prefer Array#flat() over legacy techniques to flatten arrays. useConsistentArrayApis?
prefer-array-flat-map	✅🔧	useFlatMap	✅🔧	Prefer .flatMap(…) over .map(…).flat(). useConsistentArrayApis?
prefer-array-index-of	✅🔧			Prefer Array#{indexOf,lastIndexOf} over Array#{findIndex,findLastIndex} when looking for the index of an item. useConsistentArrayApis?
prefer-array-some	✅🔧			Prefer .some(…) over .filter(…).length check and .{find,findLast}(…). useConsistentArrayApis?
prefer-at	✅🔧			Prefer .at() method for index access and String#charAt(). useConsistentArrayApis?
prefer-blob-reading-methods	✅			Prefer Blob#arrayBuffer() over FileReader#readAsArrayBuffer(…) and Blob#text() over FileReader#readAsText(…).
prefer-code-point	✅⚠️			Prefer String#codePointAt(…) over String#charCodeAt(…) and String.fromCodePoint(…) over String.fromCharCode(…).
prefer-date-now	✅🔧			Prefer Date.now() to get the number of milliseconds since the Unix Epoch.
prefer-default-parameters	✅🔧			Prefer default parameters over reassignment.
prefer-dom-node-append	✅🔧			Prefer childNode.append() over parentNode.appendChild(childNode).
prefer-dom-node-dataset	✅🔧			Prefer using .dataset on DOM elements over calling attribute methods.
prefer-dom-node-remove	✅🔧			Prefer childNode.remove() over parentNode.removeChild(childNode). Should be merged with prefer-dom-node-append?
prefer-dom-node-text-content	✅🔧			Prefer .textContent over .innerText.
prefer-event-target	✅			Prefer EventTarget over EventEmitter.
prefer-export-from	✅🔧			Prefer export…from when re-exporting.
prefer-keyboard-event-key	✅🔧			Prefer KeyboardEvent#key over KeyboardEvent#keyCode.
prefer-logical-operator-over-ternary	✅			Prefer using a logical operator over a ternary.
prefer-math-trunc	✅🔧			Enforce the use of Math.trunc instead of bitwise operators.
prefer-modern-dom-apis	✅🔧			Prefer modern DOM APIs over legacy patterns.
prefer-modern-math-apis	✅🔧			Prefer modern Math APIs over legacy patterns.
prefer-negative-index	✅🔧			Prefer negative index over .length - index when possible.
prefer-node-protocol	✅🔧	useNodejsImportProtocol	✅⚠️	Prefer using the node: protocol when importing Node.js builtin modules.
prefer-number-properties	✅🔧	useNumberNamespace	✅🔧	Prefer Number static properties over global ones.
prefer-optional-catch-binding	✅🔧			Prefer omitting the catch binding parameter.
prefer-prototype-methods	✅🔧			Prefer borrowing methods from the prototype instead of the instance.
prefer-query-selector	✅🔧			Prefer querySelector() over getElementById(), querySelectorAll() over getElementsByClassName() and getElementsByTagName().
prefer-reflect-apply	✅🔧			Prefer Reflect.apply() over Function#apply().
prefer-regexp-test	✅🔧			Prefer RegExp#test() over String#match() and RegExp#exec().
prefer-spread	✅🔧			Prefer the spread operator over Array.from(…), Array#concat(…), Array#{slice,toSpliced}() and String#split('').
prefer-string-slice	✅🔧			Prefer String#slice() over String#substr() and String#substring(). The rule could be merged with prefer-string-trim-start-end into useConsistentStringFunctions?
prefer-string-replace-all	✅🔧			Prefer String#replaceAll() over regex searches with the global flag.
prefer-string-starts-ends-with	✅🔧			Prefer String#startsWith() String#endsWith() over RegExp#test().
prefer-string-trim-start-end	✅🔧			Prefer String#trimStart() / String#trimEnd() over String#trimLeft() / String#trimRight(). The rule could be merged with prefer-string-slice into useConsistentStringFunctions?
prefer-ternary	✅🔧			Prefer ternary expressions over simple if-else statements.
prefer-top-level-await	✅🔧			Prefer top-level await over top-level promises and async function calls.
prefer-type-error	✅🔧			Enforce throwing TypeError in type checking conditions.
relative-url-style	✅🔧			Enforce consistent relative URL style.
require-array-join-separator	✅🔧			Enforce using the separator argument with Array#join().
require-number-to-fixed-digits-argument	✅🔧			Enforce using the digits argument with Number#toFixed().
switch-case-braces	✅🔧			Enforce consistent brace style for case clauses.
throw-new-error				Require new when throwing an error.

Rust Clippy

Clippy		Biome		Description and notes
almost_swapped	✅⚠️			Checks for a = b; b = a sequences.
approx_constant	✅	noApproximativeNumericConstant	✅	Checks for floating point literals that approximate constants.
assign_op_pattern	✅	useShorthandAssign	✅⚠️	Use a op= b instead of a = a op b or a = b commutative_op a.
bad_bit_mask	✅			Checks for incompatible bit masks in comparisons. This could be part of noCOnstantCondition?
branches_sharing_code				Checks if the if and else block contain shared code that can be moved out of the blocks.
builtin_type_shadow	✅			Warns if a generic shadows a built-in type.
collapsible_else_if	✅🔧	useCollapsedElseIf	🔧	Checks for else { if ... } that can be collapsed to else if ...
collapsible_if	✅🔧			Checks for nested if that can be collapsed by combining their conditions.
decimal_literal_representation	🔧			Warns if there is a better representation for a numeric literal.
double_comparisons	✅🔧			Checks for double comparisons that could be simplified to a single comparison.
eq_op	✅	noSelfCompare	✅	Checks for equal operands to comparison.
extra_unused_type_parameters	✅🔧			Checks for type parameters that are never used.
flat_map_identity	✅🔧	noFlatMapIdentity	🍼⚠️	Checks for usage of flatMap((x) => x).
float_cmp				Checks for (in-)equality comparisons on floating-point value.
float_equality_without_abs	✅⚠️			Checks for statements of the form (a - b) < Number.EPSILON
fn_params_excessive_bools				Checks for excessive use of bools in function definitions.
if_not_else		noNegationElse	⚠️	Disallow negation in the condition of an if statement if it has an else clause.
ifs_same_cond	✅			Checks for consecutive ifs with the same condition.
impossible_comparisons	✅			Checks for double comparisons that can never succeed
ineffective_bit_mask	✅			Checks for bit masks in comparisons which can be removed without changing the outcome.
int_plus_one				Check for comparisons against plus-one or minus-one operations.
invisible_characters	✅			Checks for invisible Unicode characters in the code.
let_and_return	✅			Checks for let-bindings, which are subsequently returned.
lossy_float_literal		noPrecisionLoss	✅	Disallow numeric literals whose value cannot be accurately represented by a float.
map_flatten	✅🔧	useFlatMap	✅🔧	Check for calls to map followed by a call to flat
match_str_case_mismatch	✅🔧	noStringCaseMismatch	✅⚠️	Check for comparison operation against literals with mismatched case.
min_max	✅	noConstantMathMinMaxClamp	🍼⚠️	Check for erroneous composition of Math.min`` and Math.max.
misnamed_getters	✅⚠️			Checks for getter methods that return a field that doesn’t correspond to the name of the method.
misrefactored_assign_op	✅⚠️	noMisrefactoredShorthandAssign	✅⚠️	Checks for a op= a op b or a op= b op a patterns.
modulo_one	✅			Checks for getting the remainder of a division by one or minus one. Biome could extends the rule to check for useless operations such as multiplying by 1 or dividing by 1 and useless bitwise operations? Suggested name: noUselessNumericOperation.
needless_else	✅🔧			Checks for empty else branches.
needless_for_each	🔧	noForEach		Checks for usage of forEach that would be more simply written as a for loop.
needless_if	✅🔧			Checks for empty if branches with no else branch.
needless_late_init	✅			Checks for late initializations that can be replaced by a let statement with an initializer.
needless_raw_strings	🔧			Checks for String.raw literals where a string literal can be used instead.
neg_multiply	✅🔧			Checks for multiplication by -1 as a form of negation. The rule could be merged with noUselessNumericOperation?
never_loop	✅			Checks for loops that will always break, return or continue an outer loop.
no_effect	✅⚠️			Checks for statements which have no effect.
no_effect_replace	✅			Checks for replace statements which have no effect.
nonminimal_bool	✅🔧			Checks for boolean expressions that can be written more concisely.
out_of_bounds_indexing	✅			Checks for out of bounds array indexing with a constant index.
overly_complex_bool_expr	✅			Checks for boolean expressions that contain terminals that can be eliminated.
redundant_comparisons	✅			Checks for ineffective double comparisons against constants.
redundant_else		noUselessElse	✅⚠️	Checks for else blocks that can be removed without changing semantics.
same_functions_in_if_condition				Checks for consecutive ifs with the same function call.
search_is_some	✅🔧			Search for iterator or string search followed by a comparison to -1
self_assignment	✅	noSelfAssign	✅	Checks for explicit self-assignments.
short_circuit_statement	✅🔧			Checks for the use of short circuit boolean conditions as a statement.
similar_names				Checks for names that are very similar and thus confusing.
single_element_loop	✅🔧			Checks whether a for loop has a single element.
struct_excessive_bools				Checks for excessive use of bools in structs.
suboptimal_flops	🔧			Checks for floating-point operations that can be expressed using built-in functions.
too_many_arguments	✅			Checks for functions with too many parameters.
trivial_regex				Checks for trivial regex which can be avoided.
type_complexity				Check for complex type annotations
unicode_not_nfc	🔧			Checks for string literals that contain Unicode in a form that is not equal to its NFC-recomposition.
unnecessary_fold	✅🔧			Checks for usage of reduce when a more succinct alternative exists.
unnecessary_operation	✅🔧			Checks for expression statements that can be reduced to a sub-expression.
while_immutable_condition	✅			Check for loops that never mutate their condition.

[mcharles-square]

Any plans to support no-floating-promises? This was also raised with Rome rome/tools#4168

[ematipico]

Not yet, we're working on it. Please stay tuned

[bradleat]

Just curious, does biome not have any type information. How does it implement other rules that guard against certain type conditions (like no-explicit-any)?

[0x80]

@ematipico Any news on this? Is there a dedicated issue that I can subscribe to? I looked but couldn't find it.

The rule is important to me, and I think the moment it's implemented is when I migrate my projects to Biome :)

[ematipico]

I haven't had time to allocate time.

I'll create an issue when we have time, resources and a working plan

[benjamine]

this one is a huge time saver (no-misused-promises too) 🙏 , happy to help if possible.

[AbdealiLoKo]

Any plans to support angular eslint rules ?

https://github.com/angular-eslint/angular-eslint

[Conaclos]

This could be a great addition! I will update the list.

[ematipico]

Although we wouldn't be able to support the rules inside templates, does it make sense?

[rubiesonthesky]

There are two angular-eslint plugins, one is for templates, another one for typescript code

• https://github.com/angular-eslint/angular-eslint/tree/main/packages/eslint-plugin
• https://github.com/angular-eslint/angular-eslint/tree/main/packages/eslint-plugin-template

[kubijo]

Two things I consider very helpful with our current ESLint-based setup…

eslint-plugin-graphql

Although we do plan to get rid of the whole gql nonsense, we have to keep alive what cannot be rewritten and the time.
This touches on support for languages embedded in template strings – one of which is graphql, another would be s?css – both for linter and formatter.

import/no-restricted-paths

Our current setup uses a JavaScript config file to read FS and construct a configuration that disallows imports across workspaces.

This could be pretty simple to implement, since it shouldn't need anything else than the import path if we disregard subpath imports or other alias mechanisms.

On the configuration side, a fully static approach could be to either explicitly name the directories that represent individual domains, across which no imports are allowed. A fully implicit config might also be possible by just reading the value of package.json.workspaces

no-restricted-imports

A real-world configuration example would be as follows:

// Discourage imports of carbon-components that we've forked
{
    name: 'carbon-components-react',
    importNames: carbonWrappers,
    message: `Use our version of these carbon components:\n\t ${carbonWrappers.join(', ')}`,
}

…where we disallow importing components from design system library for which we have our patched versions.

[radahh-rest]

'no-restricted-imports' is also very important for code bases where deploy-time code is in JS/TS along side runtime code. For example, a standard pattern with AWS CDK is write the Typescript code to deploy in a lib folder alongside src. With our ESLint config we block accidental use of deploy-time code in our runtime. Same with accidentally importing devDependencies (although we can catch this elsewhere, ESLint is earlier)

[Conaclos]

Thinking about no-restricted-imports. I am not particularly fond of integrating a glob matcher in the configuration.
I could restrict to two types of matchers:

• exact matcher such as my-package, ., .., ./file.js, my-package/module
• submodules matchers (matchers ending with /) such as my-package/, ./, ../ (respectively equivalent to my-package/**/*, ./**/*, ../**/*`).

Could this restriction fulfills your needs?

[closesimple-wl]

Isn't this problem, solved with no-restricted-imports, better solved by: #3 (comment)

[JP250552]

Our issue is that people try import from the /src directory of packages in our monorepo which works fine when accessing within the context of the monorepo but fails otherwise.

// bad
import x from '@company/package/src/some/file';

// good
import x from '@company/package/lib/some/file';

[cameronbrill]

Here's another example of how restricting named imports is useful. For consistency, I like to enforce that we can only import one of test or it from vitest. So, with the following setting:

"no-restricted-imports": ["error", {
  "paths": [{
    "name": "vitest",
    "importNames": ["it"],
    "message": "Please use `test` from vitest instead of `it`."
  }]
}]

which would result in:

// bad
import { it } from 'vitest';

// good
import { test } from 'vitest';

[Conaclos]

@nissy-dev I added the ESLint JSX A11y plugin in the list.

[Infir3]

Hello,

I would like a rule that enforces an explicit function return type, like the one that TypeScript ESLint
provides: https://typescript-eslint.io/rules/explicit-function-return-type/

Reasoning is the same as for the TypeScript ESLint rule:

Functions in TypeScript often don't need to be given an explicit return type annotation. Leaving off the return type is less code to read or write and allows the compiler to infer it from the contents of the function.

However, explicit return types do make it visually more clear what type is returned by a function. They can also speed up TypeScript type checking performance in large codebases with many large functions.

[Conaclos]

I totally agree with your point.
I didn't add the rule to the list, because I think we can write a broader rule.
I am watching the progress of TypeScript's isolated declarations.

[Conaclos]

I propose adding a rule named useExplicitBoundaryTypes. The rule will enforce:

• TypeScript's isolated declarations constraints.
  Cover explicit-module-boundary-types
• explicit-function-return-type
• explicit types on all methods and properties.

The rule must not conflict with noInferrableTypes.

I am unsure about the name. Alternate names: useExplicitLocalTypes, useExplicitTypes.

[Infir3]

I personally like useExplicitTypes best. I am not a TypeScript expert and the words "boundary" and "local" would just confuse me as a user of biome.

[dreamorosi]

We would be really interested in seeing this rule being implemented in Biome, as of now it's one of the main dealbreakers for adoption for us. What's the process for proposing this new rule besides this discussion?

[Conaclos]

I have opened #2017. It has a low priority. Please consider funding it to raise its priority.

[emab]

no-exclusive-tests

This rule would look for usages where .only is used when defining a test. When .only is used, it's mostly for debugging purposes and isn't meant to be checked in. If you want to skip tests, they should be explicitly marked with .skip.

Example of invalid code:

describe.only("my test", () => {});
it.only("does something", () => {});

Example of valid code:

describe.skip("my test", () => {});
it.skip("does something", () => {});

An Eslint plugin exists for this rule: https://github.com/lo1tuma/eslint-plugin-mocha/blob/master/docs/rules/no-exclusive-tests.md

[jpike88]

+1 for no-shadow.

Just had a nasty bug arise because a refactor caused this scenario to happen:

let x;

// blah blah

if(y){
     const x = somethingUnrelated;
}

// crap... x was not set in outer scope!!!

Found the above rule that would prevent this kind of issue occurring again, I believe very valuable to not be reusing variable names like that inside inner scope.

[jpike88]

@Conaclos thoughts on usefulness of this one?

[Conaclos]

I used to think it was really important to avoid variable shadowing. However, I changed my mind when writing code generators: it is really hard to avoid shadowing. Now I think that restricting shadowing limits code composability.

I still think it is a good thing to avoid shadowing variables in handwritten code. So I am not against adding this rule. I think it should not be recommended.

[jpike88]

+1 for no-unsafe-return, https://typescript-eslint.io/rules/no-unsafe-return

Very useful, prevents lazy types from being coerced from functions, they are like time bombs.

[emab]

Unfortunately we can't implement it for the time being. That rule requires type information, which we don't have.

I think this might also apply to this rule? Although agree this would be very useful.

[Conaclos]

The rule is already in the list of the rules we want to implement. All rules that require type info cannot be implemented yet.

[Conaclos]

I propose adding the rule useFilenamingConvention which enforces filename conventions for JavaScript and TypeScript files.

Every filename could follow these restrictions:

1. A filename can start with one or several underscores. This is often used to denote an internal file or a test utility file.

2. A filename is either in camelCase, snake_case, kebabcase, or matches the name of an export name (named default export, named export).
   An option should be provided to enforce a subset of these cases.
   I think we could accept all these cases by default because they are widely used in the community.
   We could also provide the strictCase option with the same behavior as the option of useNamingConvention.

3. Every extension is in dot-seperated lowercase. For example file.TEST.js is invalid. Should we provide a way to restrict the allowed extensions?

To summarize, the default config is:

{
  "fileCases": ["camelCase", "snake_case", "kebab-case", "export"],
  "strictCase": true
}

Any thoughts?

EDIT: I replaced the matchExportName option by a specific case named export.

[emab]

For React projects, I often see files with a component in are PascalCase, and all other files that do not contain components are camelCase. I suppose with matchExportName plus camelCase you could achieve that?

[Conaclos]

@emab Yeah this is one of the use case. In general React components are default exports or regular named exports.

[Conaclos]

The rule is now implemented and will be part of the upcoming v1.5.0 release

[jpike88]

I know this needs type info, but just an idea:

ban-downgrade-to-primitive: I have no idea what the name would be.

Example would be if a property is of type MyInterface['blah'], which is a string.

But someone wrote a function called doSomethingWithBlah(blah: string) {}, which while technically correct as the types match, loses business logic context and impacts readability.

[jpike88]

I am totally guessing here... but instead of using the function itself as the point of reference, couldn't it notice at the points the function is being called instead?

interface MyInterface {
  x: string;
}


function test(_: string){
    // do stuff
}



function main(){
   const obj: MyInterface = {
       x: 'something'
   }
   
   // at this point compare function signature to inputs, surely at this point it should retain information 
   // that x = MyInterface['x']...
   // throw error saying that function matches primitive type, but should have more explicit type to match?
   test(x);

}
main();

[emab]

The problem is that MyInterface['x'] is type string so nothing is wrong here.

Maybe your function should accept a parameter called MyInterface and then just use x from the provided parameter?

Or, define a new type for x:

type MyX = string;

interface MyInterface {
  x: MyX;
}

const myFunction = (x: MyX) => {
  // ...
}

Although again, any type that satisfies MyX (and string) would be allowed.

Making x an enum could be your best option?

[jpike88]

I have interfaces that act as shapes for our API, using enums in such a situation would not work.

export interface BookingCheckin {
	plantID: Plant['id'];
	plantIdentifier: Plant['identifier'];
	supplierID: Business['id'];
	bookingBusinessID: Business['id'];
	operatorID: User['id'];
	operatorBusinessID: Business['id'];
}

Nor would it work for a class instance property.

Another angle of the problem I'm talking about can also be seen in the vscode intellisense, where knowing the primitive is usually less important that the context of the function itself.

[kubijo]

I think you are then talking about opaque types… anyway, it is essentially an escape from structural to identity style typing and I do believe there really is no sensible way here for automated linter... It's more of a policy thing for your codebase if you can't use any of the proposed solutions

[emab]

Yep - naming your types more verbosely might help you, specifically with your VSCode debugging example.

Perhaps somethinglike zod could help you also?

[EvHaus]

sort-keys is the one I'm missing the most in Biome right now: https://eslint.org/docs/latest/rules/sort-keys

[birkkensen]

https://github.com/francoismassart/eslint-plugin-tailwindcss is the only Eslint plugin keeping me from moving all of my projects to Biome

[rubiesonthesky]

Some rules that are related / equal to Biome's "unique" rules

Biome	Other
noAssignInExpressions	partly no-return-assign
noForEach	unicorn/no-array-for-each
noGlobalIsFinite	unicorn/prefer-number-properties
noGlobalIsNan	unicorn/prefer-number-properties
noImplicitAnyLet	(typescript compiler option)
noUselessElse	unicorn/no-lonely-if ?
noUselessThisAlias	related unicorn/no-this-assigment
noVoidTypeReturn	@typescript-eslint/no-confusing-void-expression
useBlockStatements	curly ?
useFlatMap	unicorn/prefer-array-flat-map
useSimpleNumberKeys	opposite? unicorn/numeric-separators-style

[Conaclos]

We didn't add unicorn rule yet. Indeed, some rules can be identical to unicrone's rules.

• no-return-assign covers only a subset of noAssignInExpressions
• noImplicitAnyLet is not cover by TypeScript options. See `noImplicitAnyLet` or some name, enforce type on implicit any `let` #381 for more details.
• noUselessElse: not sure if it is completely the same rule
• noUselessThisAlias is not the same as no-this-assignment because our rule doesn't trigger code that requires aliasing.
• noVoidTypeReturn is not the same as no-confusing-void-expression
• useSimpleNumberKeys concerns object keys not number literals

[jackTabsCode]

Looking for something akin to jsx-sort-props:
https://github.com/jsx-eslint/eslint-plugin-react/blob/master/docs/rules/jsx-sort-props.md

[gaving]

Really missing this one!

[kevinwolfcr]

Any plans to enable the @typescript-eslint/consistent-type-imports rule?

[Conaclos]

Yes it is one of the rule I would like to impelment.

For now, I opened a #29 for encouraging the use of export type and export { type }.

[kevinwolfcr]

Would love to see that one as well!

[Conaclos]

The rule has been added. It will be part of the 1.5.0 release.

[GunseiKPaseri]

I would like to implement import/no-anonymous-default-export as there appears to be no similar rule.

How about the rule called noAnonymousDefaultExport?

[arendjr]

Ah, even better :) It does beg the question whether we should add a noAnonymousDefaultExport as well, since they would be highly overlapping rules. I guess we could add an option to that rules instead?

I'm having slight trouble coming up with a good naming suggestion though. We could add an option allowNamedDefaultExport to noDefaultExport, but it feels like such a major exception that I wonder whether the name noDefaultExport would still apply. But maybe I'm overthinking it :)

[Conaclos]

Personally, I prefer a new rule to adding an option. Moreover this makes migration easier because we have a 1-1 correspondance. Of course, we can still wonder if it is a good idea to implement so many small rules...

[arendjr]

I would be fine with another small rule too. My only concern is that I think you may get duplicate diagnostics if you enable noDefaultExport while forgetting to disable noAnonymousDefaultExport (assuming the latter is in the recommended set).

[Conaclos]

I see your concern.
I think about 3 approaches:

1. Accept the conflict
2. Add the rules noNamedDefaultExport and noAnonymousDefaultExport, then deprecate noDefaultExport once they are stabilized.
3. Add a rule with an option (which name?) and deprecate noDefaultExport once it is stabilized.

I am hesitant about which approach to choose.
We should assess how many users use these rules.
This could help to decide.

[GunseiKPaseri]

I feel that noNamedDefaultExport is an unnatural rule, so I think it should be either 1 or 3.
Personally, I thought it would be more user-friendly and easier to recommend than the overly strict noDefaultExport, but having different rules enabled for the same purpose might be a source of confusion.
If the implementation of noAnonymousDefaultExport is allowed, I will create an issue and provide a prototype. However, if further discussion is needed, I will wait.

[michellocana]

I would like to implement img-redundant-alt, maybe calling it noRedundantImgAlt or just noRedundantAlt?

[ematipico]

Oh, I didn't notice we missed some other a11y rule! Totally on board with that!

[Conaclos]

I think the rule is already implemented under the name noRedundantAlt. I've just noticed that the rule source is wrong.

EDIT: I opened #2609 to fix the source.

[michellocana]

The no-useless-concat would be a nice addition, as it's a common mistake specially for beginner engineers. Let me know what you think, and if you agree I can implement it :D

[Conaclos]

Why not. Feel free to start working on that :)

[magnattic]

The noImplicitBoolean rule is supposed to allow migration from the react/jsx-boolean-value, but only covers the use case where you want explicit booleans. If you want to enforce implicit booleans instead, which is an option in the eslint rule, there is no corresponding biome rule.

eslint: { "react/jsx-boolean-value": "never" } -> biome: ??

Could this be added as a rule? Maybe noExplicitBoolean - or an option on the existing rule (the rule name is problematic for this though)?

[Conaclos]

If the community have interset for that, I think it is better to add an option and rename the rule (deprecating the old name).

[universalmind303]

the rules from eslint-plugin-jsdoc would all be great additions

[ugoa]

I wonder if we can implement consistent-type-definitions,
it would be a great help if it enforces a typescript project to choose either type or interface, which lead to more consistent codebase

[ugoa]

By enforcing this rule, I guess it also implies that the developer is willing to give up the use cases associated with type or interface and use a subset of features of Typescript, which IMHO might be a preferable thing, considering the huge maybe-too-rich feature set that Typescript provides.

[arendjr]

I would actually like a noInterfaceTypes rule myself :) After many years of exclusively using type, I don't think I've ever been in a situation where I missed, or even thought about, some of the features interface provides. But it is annoying to have to occasionally explain to (new) team members why we use type only.

That said, I would consider it merely a style rule, and not really a must-have.

[unional]

I also uses type most of the time, but when the types get complicated, sometimes using interface to break the chain can help with performance.

Agree that this is in the realm of style.

But it is annoying to have to occasionally explain to (new) team members why we use type only.

Record a show and tell or direct them to some YouTube videos. 🤣

[Conaclos]

I have long-term ideas for rules that could enforce consistent uses of type and interface. A rule like consistent-type-definition is too restrictive. Let me just give you an overview of these ideas:

• We could have a rule that requires a class to extends either a class or an interface. Extending any other kinds (including type aliases) could be prohibited.
• We could have a rule that enforces exact type for type aliases (which Flow enforces).
• ...

Unfortunately we have not the infra for implanting such rules.

I would actually like a noInterfaceTypes rule myself

If we decide to implement a rule, I would prefer a useConsistentTypeDefinitions, as users will certainly ask for support to enforce interface. Let us not make the same mistake as useShothandArrayType/useConsistentArrayType. We could default to type and explain why in the rule.

[ugoa]

Gold to see this draws some consideration, really appreciate all the hard work you've done.

[michellocana]

Hey, can I implement label-has-associated-control? If yes:

• Can we call it useLabelWithAssociatedControl or is there a better name?
• Should we support all of the options of the original rule or start with a minimal implementation?

[Conaclos]

Oh, I hadn't seen it, my bad, can I get yoda then?

All yours :) Please open an issue (task) to make it clear you work currently on that :)

[michellocana]

Just to confirm, the original rule have the option to enforce and forbid the use of yoda expressions, in Biome that's probably two different rules, noYodaExpression and useYodaExpression, right?

[ematipico]

Well, in this case, as I said before, it seems the option makes sense. It doesn't make sense to have two rules that negate each other. A user could enable both. What about useConsistentYoda with an option?

[Conaclos]

Considering the rule description, it seems that using yoda to avoid accidentally assigning a value to a variable in a condition is a legacy pattern made obsolete by linters (notably by lint rules that report assignment in conditionals).
By default, the ESLint rule is set to never (forbid).

Making a quick code search on GitHub, the rule is enabled 7.6k rimes and is set to always (enforce) less than 100 times.

Thus, I think we could just implement noYodaExpression.

We could allow yoda in range because exceptRange is set more than 1.5k times. onlyEquality is only set 500 times.

[michellocana]

Created here #2743 \o

[throrin19]

Hello, I think the add of rules for others front libraries than React (vue, svelte, ...) must be great. Same for other unit testing libraries like vitest :

• https://eslint.vuejs.org/
• https://www.npmjs.com/package/eslint-plugin-vitest
• https://sveltejs.github.io/eslint-plugin-svelte/

And other minor rules if possible like component libraries if they have one :

• https://www.npmjs.com/package/eslint-plugin-vuetify

[ematipico]

npmjs.com/package/eslint-plugin-vitest

Biome has already rules around testing: https://biomejs.dev/linter/rules-sources/#eslint-plugin-jest

Don't make the "source" fool you, all the rules are inspired to take into account the various testing suites.

[throrin19]

But some useful rules are not available in biome :

Name	Description
expect-expect	enforce having expectation in test body
no-commented-out-tests	disallow commented out tests
no-import-node-test	disallow identical titles
no-import-node-test	disallow importing node:test
require-local-test-context-for-concurrent-snapshots	require local Test Context for concurrent snapshot tests
valid-describe-callback	enforce valid describe callback
valid-expect	enforce valid expect() usage
valid-title	enforce valid titles

[joaopedrodcf]

Any reason why we named it eslint-plugin-jest as they do work with vitests as you said @ematipico really curious 👍

[e965]

Are there any plans to implement an import/order rule? To be honest, this is one of the few things that stops our team from switching to biome from eslint - we have strict rules regarding the order of imports in the file

[ematipico]

You should follow this discussion

#645

And by the way, Biome already sorts imports and it isn't part of the linter, even though it's not configurable.

[cody-ax]

Are there any plans for lines-between-class-members rule? Or I could not find corresponding rule in biomejs

[ematipico]

Stylistic rules are out of scope, so no plans.

We use our formatter for these cases

[cody-ax]

Does biome formatter has same rule?

[ematipico]

Biome's formatter follows Prettier's philosophy, formatting style and options.

[rocambille]

Are there any plans for react/prop-types rule?

Not having it would be a huge change for my colleagues and me, and I prefer to find out before starting a debate 😅

[ematipico]

We can accept a PR for implementing it

[k-utsumi]

(Not related to the topic)

It's hard to get to the comment,
How about surrounding it with the details tag?

like this...

Biome's exclusive rules

Biome		Description and notes
noAccumulatingSpread	✅	Disallow the use of spread … syntax on accumulators.
noAssignInExpressions	✅	Disallow assignments in expressions.

...

ESLint

Eslint		Biome		Description and notes
array-callback-return ⚠️ Enforce return statements in callbacks of array methods
complexity noExcessiveCognitiveComplexity Disallow functions that exceed a given complexity score. Biome relies on

...

TypeScript ESLint

Eslint		Biome		Description and notes
adjacent-overload-signatures	🎨		Require that function overload signatures be consecutive
array-type	🎨🔧	useConsistentArrayType	⚠️	Enforce T[]. ESLint has a configuration to enforce Array<T> instead.

...

...

...

---

Sample markdown (?)

<details>
<summary>Biome's exclusive rules</summary>

Biome | | Description and notes
-:|:-:|-
[noAccumulatingSpread](https://biomejs.dev/linter/rules/no-accumulating-spread/) | ✅ | Disallow the use of spread `…` syntax on accumulators.
[noAssignInExpressions](https://biomejs.dev/linter/rules/no-assign-in-expressions/) | ✅ | Disallow assignments in expressions.

...
</details>

<details>
<summary>ESLint</summary>

Eslint | | Biome | | Description and notes
-:|:-:|-|:-:|-
[array-callback-return](https://eslint.org/docs/latest/rules/array-callback-return/)	⚠️			Enforce `return` statements in callbacks of array methods
[complexity](https://eslint.org/docs/latest/rules/complexity/)		[noExcessiveCognitiveComplexity](https://biomejs.dev/linter/rules/no-excessive-cognitive-complexity/)		Disallow functions that exceed a given complexity score. Biome relies on 

...
</details>

<details>
<summary>TypeScript ESLint</summary>

Eslint | | Biome | | Description and notes
-:|:-:|-|:-:|-
[adjacent-overload-signatures](https://typescript-eslint.io/rules/adjacent-overload-signatures) | 🎨 | | Require that function overload signatures be consecutive
[array-type](https://typescript-eslint.io/rules/array-type) | 🎨🔧 | [useConsistentArrayType](https://biomejs.dev/linter/rules/use-consistent-array-type/) | ⚠️ | Enforce `T[]`. ESLint has a configuration to enforce `Array<T>` instead.

...
</details>


<details>
<summary>...</summary>

...
</details>

[Conaclos]

Done.

[AlejandroSuero]

I was trying out biome for the first time today, and I came across the lack of the rule:

• @typescript-eslint/triple-slash-reference

As you can see in the first command with eslint, it catches the rule.

After migrating to biome, using it, does't detect this rule.

.eslintrc.js

process.env.ESLINT_TSCONFIG = "tsconfig.json";

/** @type {import("eslint").Linter.Config} */
module.exports = {
  env: {
    browser: true,
    es2021: true,
    node: true,
  },
  plugins: ["prettier"],
  extends: ["standard-with-typescript", "plugin:prettier/recommended", "prettier"],
  overrides: [
    {
      env: {
        node: true,
      },
      files: [".eslintrc.{js,cjs}"],
      parserOptions: {
        sourceType: "script",
      },
    },
  ],
  parserOptions: {
    ecmaVersion: "latest",
    sourceType: "module",
  },
  rules: {},
};

.prettierrc.cjs

/** @type {import("prettier").Config} */
export default {
  printWidth: 120,
  semi: true,
  singleQuote: false,
  jsxSingleQuote: false,
  quoteProps: "consistent",
  tabWidth: 2,
  trailingComma: "es5",
  useTabs: false,
  endOfLine: "lf",
  arrowParens: "always",
  overrides: [
    {
      files: ["*.json", "*.md", "*.toml", "*.yml"],
      options: {
        useTabs: false,
      },
    },
  ],
};

biome.json (after migration)

{
  "$schema": "https://biomejs.dev/schemas/1.7.3/schema.json",
  "formatter": {
    "enabled": true,
    "formatWithErrors": false,
    "indentStyle": "space",
    "indentWidth": 2,
    "lineEnding": "lf",
    "lineWidth": 120,
    "attributePosition": "auto",
    "ignore": [
      "**/pnpm-lock.yaml",
      "**/package-lock.json",
      "**/yarn.lock",
      "**/node_modules/",
      "**/dist/",
      "**/public/",
      "./pnpm-lock.yaml",
      "./package-lock.json",
      "./yarn.lock",
      "./node_modules/",
      "./dist/",
      "./public/"
    ]
  },
  "organizeImports": { "enabled": true },
  "linter": {
    "enabled": true,
    "rules": {
      "recommended": false,
      "complexity": {
        "noBannedTypes": "error",
        "noExtraBooleanCast": "error",
        "noMultipleSpacesInRegularExpressionLiterals": "error",
        "noStaticOnlyClass": "error",
        "noUselessCatch": "error",
        "noUselessConstructor": "error",
        "noUselessLoneBlockStatements": "error",
        "noUselessRename": "error",
        "noUselessTernary": "error",
        "noUselessTypeConstraint": "error",
        "noVoid": "error",
        "noWith": "error",
        "useLiteralKeys": "error",
        "useOptionalChain": "error",
        "useRegexLiterals": "error"
      },
      "correctness": {
        "noConstAssign": "error",
        "noConstantCondition": "error",
        "noEmptyCharacterClassInRegex": "error",
        "noEmptyPattern": "error",
        "noGlobalObjectCalls": "error",
        "noInvalidConstructorSuper": "error",
        "noInvalidUseBeforeDeclaration": "error",
        "noNewSymbol": "error",
        "noPrecisionLoss": "error",
        "noSelfAssign": "error",
        "noSwitchDeclarations": "error",
        "noUndeclaredVariables": "off",
        "noUnreachable": "error",
        "noUnreachableSuper": "error",
        "noUnsafeFinally": "error",
        "noUnusedVariables": "error",
        "useIsNan": "error"
      },
      "security": { "noGlobalEval": "error" },
      "style": {
        "noCommaOperator": "error",
        "noNamespace": "error",
        "noNonNullAssertion": "error",
        "noVar": "warn",
        "useBlockStatements": "error",
        "useConsistentArrayType": {
          "level": "error",
          "options": { "syntax": "shorthand" }
        },
        "useConst": "error",
        "useShorthandFunctionType": "error",
        "useSingleVarDeclarator": "error"
      },
      "suspicious": {
        "noAsyncPromiseExecutor": "error",
        "noCatchAssign": "error",
        "noClassAssign": "error",
        "noCompareNegZero": "error",
        "noConfusingVoidType": "error",
        "noControlCharactersInRegex": "error",
        "noDebugger": "error",
        "noDoubleEquals": "error",
        "noDuplicateCase": "error",
        "noDuplicateClassMembers": "error",
        "noDuplicateObjectKeys": "error",
        "noDuplicateParameters": "error",
        "noEmptyBlockStatements": "error",
        "noExtraNonNullAssertion": "error",
        "noFallthroughSwitchClause": "error",
        "noFunctionAssign": "error",
        "noGlobalAssign": "error",
        "noImportAssign": "error",
        "noMisleadingCharacterClass": "error",
        "noMisleadingInstantiator": "error",
        "noPrototypeBuiltins": "error",
        "noRedeclare": "error",
        "noSelfCompare": "error",
        "noShadowRestrictedNames": "error",
        "noUnsafeNegation": "error",
        "useDefaultSwitchClauseLast": "error",
        "useValidTypeof": "error"
      }
    },
    "ignore": ["./node_modules/", "./dist", "./.vscode", "**/*.config.js", "./web/node_modules"]
  },
  "javascript": {
    "formatter": {
      "jsxQuoteStyle": "double",
      "quoteProperties": "asNeeded",
      "trailingComma": "es5",
      "semicolons": "always",
      "arrowParentheses": "always",
      "bracketSpacing": true,
      "bracketSameLine": false,
      "quoteStyle": "double",
      "attributePosition": "auto"
    },
    "globals": ["document", "navigator", "window"]
  },
  "overrides": [
    {
      "include": ["*.json", "*.md", "*.toml", "*.yml"],
      "formatter": { "indentStyle": "space" }
    }
  ]
}

[ematipico]

Can you provide a link to the rule?

[AlejandroSuero]

Here you have it https://typescript-eslint.io/rules/triple-slash-reference/ @ematipico

[pete-willard]

The only thing keeping me on Eslint is eslint-plugin-perfectionist and its features. There's no going back once you introduce prop, object keys and destructuring, types order autofix to the team. I've noticed votes for sort-keys and jsx-sort-props above and upvoted them. Will observe how you guys evolve!

[ematipico]

These aren't classic lint rules, but they are stylistic rules. The Biome linter won't support these kind of rules.

However, we plan to introduce them using our Analyzer infrastructure, with names like "assists" or "actions."

They will be closer to import sorting in terms of functionality.

[AlejandroSuero]

@ematipico is there a plan to make use of biome as eslint in the sense of extending it with plugin creation?

It could be a solution for eslint-plugin-perfectionist or other features not supported on the main project.

[arendjr]

@AlejandroSuero Plugin support is in progress, yes, but it will take a while to get there: #2463

[astoilkov]

With React 19 around the corner, the team has announced an Eslint plugin with compiler rules.
Any thoughts on this or plans to implement?

https://react.dev/learn/react-compiler#installing-eslint-plugin-react-compiler

---

I'm copying the contents of #2881.

[arendjr]

My thought is that we will not implement anything like this soon. The React Compiler currently relies on Babel, and the ESLint plugin depends on the React Compiler itself, so this puts quite some constraints on who is able to use this in the first place.

If we want to support this in Biome, we would first need to have an alternative implementation of the React Compiler itself, so I don't see this happening anytime soon.

[nikeee]

They are also working on a rust version of the react compiler: https://github.com/facebook/react/tree/main/compiler/crates