✅ 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.

Warning

The information in this discussion may be out of date.
Please have a look at the automatically generated page on our website.

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.
useImportExtensions	⚠️	Enforce file extensions for relative imports.
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.
useTopLevelRegex		Require regex literals to be declared at the top level.
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
camelcase		useNamingConvention		Enforce camelcase naming convention
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		useDefaultSwitchClause		Require default cases in switch statements
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.
func-style				Enforce the consistent use of either function declarations or expressions assigned to variables
getter-return		useGetterReturn	✅	Enforce that getter have a return statement on all exit paths.
grouped-accessor-pairs				Require grouped accessor pairs in object literals and classes
guard-for-in				Require for-in loops to include an if statement
no-array-constructor	⚠️	useArrayLiterals	⚠️	Disallow Array constructors in favor of array literal
no-async-promise-executor		noAsyncPromiseExecutor	✅	Disallow async functions as Promise executors.
no-await-in-loop				Disallow await inside of loops
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		noConsole		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-duplicate-imports				Disallow duplicate module imports
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	✅⚠️	noEmptyBlockStatements		Disallow empty blocks.
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-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-invalid-regexp	✅			Disallow invalid regular expression strings in RegExp constructors
no-irregular-whitespace	✅	noIrregularWhitespace	🍼	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-nested-ternary		noNestedTernary	🍼	Disallow nested ternary expressions
no-new-native-nonconstructor	✅	noInvalidBuiltinInstantiation	✅⚠️	Disallow new operators with global non-constructor functions. Should replace no-new-symbol?
no-new-symbol	✅⚠️	noInvalidBuiltinInstantiation	✅⚠️	Disallows calling the Symbol function as a constructor.
no-new-wrappers		useConsistentBuiltinInstantiation	⚠️	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-octal-escape		noOctalEscape	🍼	Disallow octal escape sequences in string literals
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-restricted-syntax				Disallow specified syntax
no-return-assign		noAssignInExpressions	✅	Disallow assignment operators in return statements
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-template-curly-in-string		noTemplateCurlyInString	🍼⚠️	Disallow template literal placeholder syntax in regular strings
no-this-before-super	✅	noUnreachableSuper	✅	Disallow using this before calling super in a derived class.
no-throw-literal		useThrowOnlyError		Disallow throwing literals as exceptions
no-undef	✅	noUndeclaredVariables		Disallow the use of undeclared variables.
no-undef-init	🔧	noUselessUndefinedInitialization	🔧	Disallow useless undefined initialization.
no-underscore-dangle		useNamingConvention		Disallow dangling underscores in identifiers
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 and noUnusedFunctionParameters	⚠️	Disallow unused variables.
no-use-before-define		noInvalidUseBeforeDeclaration	✅	Disallow the use of variables and function parameters before their declaration
no-useless-assignment				Disallow variable assignments when the value is not used
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-concat		noUselessStringConcat	⚠️	Disallow unnecessary concatenation of literals or template literals
no-useless-constructor		noUselessConstructor	✅⚠️	Disallow unnecessary constructors.
no-useless-escape	✅⚠️	noUselessEscapeInRegex	🍼🔧	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	🔧	noPrototypeBuiltins	✅	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.
radix				Enforce the consistent use of the radix argument when using parseInt()
require-atomic-updates				Disallow assignments that can lead to race conditions due to usage of await or yield
require-await		useAwait		Require async function to contain await.
require-unicode-regexp	⚠️			Require u or v regex flag when needed.
require-yield	✅	useYield	✅	Require generator functions to contain yield.
[strict]	🔧	useStrictMode	🔧	Require or disallow strict mode directives
use-isnan	✅	useIsNan	✅⚠️	Requires calling isNaN when comparing to NaN.
valid-typeof	✅⚠️	useValidTypeof	✅⚠️	Enforces comparing typeof expressions against valid strings.
yoda	🔧	noYodaExpression	🔧	Enforce literals are in the right hand side of comparisons.

TypeScript ESLint

Eslint		Biome		Description and notes
adjacent-overload-signatures	🎨	useAdjacentOverloadSignatures	🍼	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-throw-literal	💭	useThrowOnlyError		Disallow throwing literals as exceptions.
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-template-expression	💭			Disallow template literals if interpolation and special-character handling are not needed.
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.
only-throw-error	🔒💭	useThrowOnlyError		Disallow throwing non-Error values as exceptions.
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	✅	useValidAutocomplete	🍼	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	✅	useFocusableInteractive	✅	Enforce that elements with interactive handlers like onClick must be focusable.
label-has-associated-control	✅	noLabelWithoutControl	✅	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	✅	noStaticElementInteractions	🍼	Enforce that non-interactive, visible elements (such as <div>) that have click handlers use the role attribute.
prefer-tag-over-role	✅	useSemanticElements	✅	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	✅	useAriaPropsSupportedByRole	🍼	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	✅	useErrorMessage		Enforce passing a message value when creating a built-in error.
explicit-length-check	✅🔧	useExplicitLengthCheck	⚠️	Enforce explicitly comparing the length or size property of a value.
filename-case	✅	useFilenamingConvention		Enforce a case style for filenames.
new-for-builtins	✅🔧	noInvalidBuiltinInstantiation, useConsistentBuiltinInstantiation	✅⚠️	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	✅🔧	useDateNow	⚠️	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	✅🔧	noSubstr	🍼⚠️	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	✅🔧	useTrimStartEnd	🔧	Prefer String#startsWith() String#endsWith() over RegExp#test().
prefer-string-trim-start-end	✅🔧	useTrimStartEnd	🍼🔧	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	✅🔧	useNumberToFixedDigitsArgument	⚠️	Enforce using the digits argument with Number#toFixed().
switch-case-braces	✅🔧			Enforce consistent brace style for case clauses.
throw-new-error		useThrowNewError	⚠️	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]

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.

[jellydn]

hi @ematipico

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

Could you please open the issue? I guess that's NOT on the plan yet but it would be good so someone like me could subscribe the issue itself. What do you think? Thanks.

[ematipico]

That's not how we work and manage the project:

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

We don't want to create issue that stay stuck for months with comments like "any update?", which is not what you're looking for, I bet. We create issues when we have a plan, and they are on our radar.

Please be patient.

[niedzielski]

very excited for this! I just tried the project out today and was set to migrate to it when I realized it didn't have the only linter rule I need and the one that causes OOMs in eslint due to requiring typing analysis. a couple references I stumbled upon:

• related TypeScript compiler issue.
• also mentioned here.

thanks for making this great project!

[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.

[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';

[JcPires]

On other exemple is to disallow import from external lib component like Mui. When you build a design system, you want to enforce devs to use it and not import Mui component when there are an overide. An other exemple is to enforce user to use custom instances instead of library instance like axios.

Exemple:

    'no-restricted-imports': [
      'warn',
      {
        paths: [
          {
            name: '@mui/material',
            importNames: ['Button', 'IconButton', ...],
            message: `Please use components from @ui Design system.`,
          },
          {
            name: 'axios',
            importNames: ['default'],
            message: 'Please use axios from @core instead of default.',
          },
       ]
    ]

[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.

[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]

Alphabetical sorting of keys, properties, attributes, types, etc... I want alphabetical sorting of the following things:

// Object keys
const obj = {
  a: true,
  b: true,
  c: true
}

// Import keys
import {a, b, c} from './foo';

// JSX and HTML attributes
<button
  aria-label="Click me" 
  className="btn"
  data-testid="cta-button" />

// TypeScript types and interfaces
type Zoo {
  a: 'alligator';
  b: 'bear';
  c: 'crocodile';
}

// Typescript string literal unions
type Cars = 'Acura' | 'Bugatti' | 'Chrysler';

/* CSS attributes */
.btn {
  background: red;
  color: blue;
  width: 500px;
}

This rule would be a combination of:

• sort-keys (https://eslint.org/docs/latest/rules/sort-keys)
• eslint-plugin-typescript-sort-keys (https://github.com/infctr/eslint-plugin-typescript-sort-keys)
• eslint-plugin-perfectionist (https://perfectionist.dev/rules/sort-objects)
• stylelint-order (https://github.com/hudochenkov/stylelint-order)

[EvHaus]

Updated my original comment with detail, examples, and links to existing tooling. Please upvote this one so we could get the Biome team to prioritize it. 🙏

[Geczy]

You can do most of this in 1.9.2 using this config:

  "assists": {
    "actions": {
      "source": {
        "sortJsxProps": "on"
      }
    }
  },

Thanks to #2652

[birkkensen]

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

[seedydocloop]

I'm missing this eslint plugin a lot since I moved 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

[muuvmuuv]

unicorn/numeric-separators-style would be a wonderful rule. Is this already tracked somewhere?

[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

[codingedgar]

@Conaclos can this be added to the list?

[Conaclos]

I think this is a case for an assist rule, not a lint rule.

[k-utsumi]

This thread is probably related.
#3 (comment)

[nerixim]

implemented here: #2652
no documentation though 🙃

[Geczy]

You can do this in 1.9.2 using this config:

  "assists": {
    "actions": {
      "source": {
        "sortJsxProps": "on"
      }
    }
  },

Thanks to #2652

[SaadBazaz]

Can we convert Firebase Cloud Function eslint.rc to biome in a stable way?

We get this eslint config when generating a function. I really don't prefer using eslint now because it'll mess up my existing biome configs and just add noise.

module.exports = {
  root: true,
  env: {
    es6: true,
    node: true,
  },
  extends: [
    "eslint:recommended",
    "plugin:import/errors",
    "plugin:import/warnings",
    "plugin:import/typescript",
    "google",
    "plugin:@typescript-eslint/recommended",
  ],
  parser: "@typescript-eslint/parser",
  parserOptions: {
    project: ["tsconfig.json", "tsconfig.dev.json"],
    sourceType: "module",
  },
  ignorePatterns: [
    "/lib/**/*", // Ignore built files.
    "/generated/**/*", // Ignore generated files.
  ],
  plugins: [
    "@typescript-eslint",
    "import",
  ],
  rules: {
    "quotes": ["error", "double"],
    "import/no-unresolved": 0,
    "indent": ["error", 2],
    "max-len": ["error", {code: 120}],
  },
};

[Conaclos]

Have you tried biome migrate eslint?

[charliewilco]

are there any guides on how to add and propose new rules? there's some specific regex rules from this package my project was depending on https://github.com/gmullerb/eslint-plugin-regex

[Conaclos]

Which rule are you referring to? Have you examples of usages?

[charliewilco]

sorry i meant this plugin
https://github.com/ota-meshi/eslint-plugin-regexp

a guy on my team did a side-by-side comparison, he indicated none of those rules were supported.

Rules	Parity
no-super-linear-backtracking	❌
no-super-linear-move	❌
no-useless-assertions	❌
no-useless-backreference	❌
no-useless-dollar-replacements	❌
strict	❌
confusing-quantifier	❌
control-character-escape	❌
negation	❌
no-dupe-characters-character-class	❌
no-empty-string-literal	❌
no-extra-lookaround-assertions	❌
no-invisible-character	❌
no-legacy-features	❌
no-non-standard-flag	❌
no-obscure-range	❌
no-trivially-nested-assertion	❌
no-trivially-nested-quantifier	❌
no-unused-capturing-group	❌
no-useless-character-class	❌
no-useless-flag	❌
no-useless-lazy	❌
no-useless-quantifier	❌
no-useless-range	❌
no-useless-set-operand	❌
no-useless-string-literal	❌
no-useless-two-nums-quantifier	❌
no-zero-quantifier	❌
optimal-lookaround-quantifier	❌
optimal-quantifier-concatenation	❌
prefer-predefined-assertion	❌

[Conaclos]

I already opened a task for eslint/no-useless-backreference #275, it could be worth mentioning that this plugin covers more cases.
Most of these could be a great addition to Biome. Do you want to implement some of them?

[charliewilco]

sure! are there any guides to writing rules in biome's codebase?

[Conaclos]

We have a general contributing guide and one dedicated to writing linter rules . You can also ask questions using our Discord. Please first discuss here the rule you would like to implement. Once we decided to implement a given rule, we will open a task and assign it to you :)

I could also suggest taking a look at existing rules that acts on Regexes. Also, I could only check regex literals (forgetting about Regex() that adds a lot of complexity). At the moment we don't use a regex parser, thus we have to handle regex in a string-way. We should avoid too complex rule that could be too hard to implement. For the complex rules we should evaluate the possibility of using a parser. I can take a look when I got some time.

[prescottprue]

Would be awesome to see support for rules for Cypress and/or Playwright.

Some examples of Cypress rules offered by https://github.com/cypress-io/eslint-plugin-cypress#readme - more details on Cypress best practices enforced are available in the docs: https://github.com/cypress-io/eslint-plugin-cypress?tab=readme-ov-file#rules

For Playwright here are the rules descriptions offered by eslint-plugin-playwright: https://github.com/playwright-community/eslint-plugin-playwright?tab=readme-ov-file#rules

[kbkn3]

Add noObjectAssign Rule to Biome

Summary

In light of Biome's plan to support linter rules from other sources (as mentioned in issue #3 "Linter rules from other sources"), I propose including a noObjectAssign rule in the planned ESLint compatibility feature. This rule would discourage the use of Object.assign() in favor of object spread syntax, promoting more modern and readable code.

Motivation

Object.assign() has been widely used for merging objects, but with the introduction of the object spread operator (...) in ECMAScript 2018, we now have a more concise and readable alternative. Encouraging the use of object spread can lead to:

1. More readable and maintainable code
2. Consistency with modern JavaScript best practices
3. Potential performance improvements in some JavaScript engines

Proposal

Add a new lint rule noObjectAssign with the following behavior:

• When enabled, it flags uses of Object.assign() as warnings or errors (configurable)
• It suggests using object spread syntax as an alternative
• Provides an auto-fix option to convert Object.assign() to object spread where possible

Example

// Before (would trigger a warning/error)
const mergedObj = Object.assign({}, obj1, obj2);

// After (suggested fix)
const mergedObj = { ...obj1, ...obj2 };

Configuration

The rule could be configured in the Biome configuration file as follows:

{
  "linter": {
    "rules": {
      "style": {
        "noObjectAssign": "error"
      }
    }
  }
}

[kbkn3]

Implementation

The implementation would involve:

1. Adding the rule to Biome's linter
2. Implementing the logic to detect Object.assign() usage
3. Creating helpful error messages and suggestions
4. Developing an auto-fix functionality

Potential Challenges

• Handling cases where Object.assign() is used with more than two arguments
• Ensuring that the rule doesn't flag legitimate uses of Object.assign() that can't be easily replaced with object spread

Questions for Discussion

1. Should this rule be part of a broader "prefer modern syntax" ruleset?
2. Are there any edge cases we should consider before implementing this rule?
3. Should we provide an option to ignore certain patterns or usages of Object.assign()?

[Conaclos]

Is the rule identical to eslint/prefer-object-spread?

3. Potential performance improvements in some JavaScript engines

Have you some references for this claim?
Unfortunately, in my experience both, Object.assign and spreading can have a perf impact because they don't necessarily preserve the object shape. Notably { x, y } and { ...{ x, y } } have not the same object shape in V8. The second one is equivalent to const a = {}; a.x = x; a.y = y;.

1. Should this rule be part of a broader "prefer modern syntax" ruleset?

I don't think so. We now prefer individual rules to ease migration from ESLint.

3. Should we provide an option to ignore certain patterns or usages of Object.assign()?

I don't think so because we try to avoid options. This adds cognitive load to users.

Are you interested in implementing this rule?

[kbkn3]

Have you some references for this claim?

In the eslint/prefer-object-spread documentation it is stated that “Introduced in ES2018, object spread is a declarative alternative which may perform better than the more dynamic, imperative Object.assign".
No credible source has been found. Sorry.

However, the reason I want this rule most is “no destructive changes to arguments”, so it may not actually contribute to performance.

Thanks for answering my question.

Are you interested in implementing this rule?

Yes. I am interested in implementing this rule as it is the rule I want.

[Conaclos]

I created a task #4319

[fellipeutaka]

Any plans to support eslint/no-magic-numbers / typescript-eslint/no-magic-numbers?

[fellipeutaka]

Thanks for the follow-up, Conaclos! You raise a valid concern about potential false positives, especially in larger projects.

In my experience, the no-magic-numbers rule has indeed triggered a significant number of false positives, but I've found it to be manageable through proper configuration—particularly with allowed exceptions like 0, 1, and common constants. While it can be noisy, its main benefit is in improving code clarity and encouraging maintainability, which tends to pay off in bigger teams and long-term projects.

As for the idea of restricting the rule to float numbers, I think it’s an interesting compromise. However, I believe the value of the rule comes from enforcing clarity for both integers and floats. Floats can indeed introduce more issues, but magic numbers in general often obscure intent, regardless of the type. Maybe an option to enable stricter enforcement only for floats could be useful as part of a customizable rule?

What do you think of offering both approaches (a fully configurable rule for magic numbers, and an option for targeting only floats)?

[Conaclos]

It seems that ESLint users are frequently setting ignore to common values (notably -1, 0, 1, and 2) and turning on ignoreArrayIndexes.

Here are the exceptions I could bake in:

• ignore assignment to constant-like variables, i.e. const, var, and static class properties

  const A = 0.25;
  const B = 0.25;
  class Foo {
    static C = 0.5;
  }

• Ignore common numbers
  We should always ignore 0/0n/0., and maybe 2/2n, 1/1n, and -1/-1n.

  -1; 0; 1; -1n; 0n; 1n;

  Should we ignore more integers?

• Ignore integer indexing (corresponds setting ESLints' ignoreArrayIndexes and ignoreTypeIndexes to true)

  arr[10];
  type Foo = Bar[10];
  type Baz = Parameters<Foo>[10];

• Ignore integer Enum values (corresponds setting ESLint's ignoreEnums to true)

  enum E {
    A = 3;
    B = 4;
  }

• ignore numeric types (corresponds setting ESLint's ignoreNumericLiteralTypes to true)

  type SmallPrimes = 2 | 3 | 5 | 7 | 11;
  function f(x: 100): 100 { return x }

• Ignore integer binary operations

  const x = 1 << 4;
  const x = a & 0xff;
  const x = a | 0x0f;

• Others?

We could introduce an ignoreIntegers option (turned off by default).

What do you think?

[fellipeutaka]

Thanks for the detailed breakdown! I think you've covered a lot of important cases.

1. Ignoring assignment to constant-like variables: This makes perfect sense. Constants are inherently self-descriptive, and enforcing the rule here would add unnecessary noise.

2. Ignoring common numbers (-1, 0, 1, 2, etc.): I agree with ignoring 0, 1, and -1, as they often serve clear semantic purposes. I’d lean towards including 2 as well since it's commonly used in loops and shifts, but I’m unsure about going beyond that without making it too permissive. Keeping it minimal sounds best to avoid losing the purpose of the rule.

3. Ignoring integer indexing: This is crucial. Array and type indexing with numbers is common practice, and enforcing the rule here would definitely introduce unnecessary noise. Enabling this by default seems like a good idea.

4. Ignoring Enum values: Completely agree with this as well. Enum values, by design, usually require integers, and enforcing the rule here would just result in more false positives.

5. Ignoring numeric types: This is another good candidate for an exception, particularly in TypeScript projects where type definitions often rely on literal values. Numeric types tend to serve as documentation for expected values rather than magic numbers in need of explanation.

6. Ignoring integer binary operations: Bitwise operations and similar expressions are common use cases where integers are part of the algorithm, so ignoring these would help reduce noise without losing clarity.

As for introducing an ignoreIntegers option, I think it’s a great idea to make it configurable, with the defaults you're suggesting. It gives teams flexibility based on their coding style and project needs, and making it off by default ensures that users can still benefit from stricter enforcement if they choose to.

If we move forward with these ideas, I'd be happy to help however I can

[Conaclos]

I created the task #4333. If you want to contribute, let me know in the task and I will assign it to you :)

[fellipeutaka]

Thanks for creating the task! I'd love to contribute to this feature. Please feel free to assign it to me, and I'll start looking into how to implement it.

[freiondrej-lokalise]

Hello! Would be awesome if you could support https://typescript-eslint.io/rules/prefer-readonly/ 🙏 (and possibly other rules from typescript-eslint for that matter 🥰). I can try contributing if there's consensus those rules would be valuable in Biome :)

[Conaclos]

This could be a great addition to Biome. We could name the rule useReadonlyPrivateClassProperties. I wonder if we should check for all properties (including public and protected ones) because it is an antipattern of mutating directly a property of an instance and inheritance is pretty rare nowadays. However, this could be a controversial choice. We could either add an option to extend the rule to its cases or create a separate rule.

[freiondrej-lokalise]

Good point, I think offering this as optional, default-off config would be best :)

[Conaclos]

Thanks for the input. I created #4356

[eugenenelou]

Hello, it would be really cool to support https://github.com/javierbrea/eslint-plugin-boundaries to help with enforcing folder structure.

[buisihung11]

Waiting for this

[arendjr]

Note we have some discussion surrounding this going on here: #3216

The noRestrictedImports rule currently doesn’t have enough flexibility to configure it so that you could configure it to respect architecture boundaries, but I think it’s the right place to discuss your use cases so that we can extend it appropriately.

Note we also have useImportRestrictions (yes, the naming is confusing. both rules are in nursury), which was intended to enforce related architecture boundaries in imports, although it uses a different approach.

[buisihung11]

We're implementing an monorepo with an clean architecture pattern, in our project we will import other packages by using alias. Here is an example of eslint config that we want to have in biome, do you know which rule we can use for that case in biome? Looks like the useImportRestrictions only support for relative import.

https://github.com/nikolovlazar/nextjs-clean-architecture/blob/main/.eslintrc.json

[dohomi]

I would like to suggest to implement

https://eslint-react.xyz/docs/rules/no-leaked-conditional-rendering

This is especially useful for all React Native devs. This would prevent errors like

Unexpected text node ...

[Netail]

Some nice plugins, some rules are worth adding :)

https://github.com/testing-library/eslint-plugin-testing-library
https://github.com/import-js/eslint-plugin-import
https://github.com/amilajack/eslint-plugin-compat

[theblondealex]

Please can we implement lines-around-comment from here

would be really useful and to specify before/after too

[dyc3]

We generally don't implement stylistic rules that would be in the realm of biome's formatter.

[theblondealex]

We generally don't implement stylistic rules that would be in the realm of biome's formatter.

Is there a way to implement this with the formatter?

[notramo]

I couldn't find a rule for this, but it's a simple rule: one of the most annoying things is encountering a variable named data. Everything is data in the variables, so this does not say anything.
So, basically disallow variables named data.

[Conaclos]

Use the conventions (match) option of the lint rule useNamingConvention. You could use the match [^d][^a][^t][^a].*

[noahlt]

It appears there are no plans to support eslint's no-unescaped-entities rule. I'd like that feature and am open to taking a crack at it if it's something the maintainers would like to support.

[dyc3]

Yeah that would be a great fit for Biome. Open a task issue for it first to discuss further.

[noahlt]

Great! Issue here: #4491

[marcusnygren]

Is there a way to show lint warnings when there's UI text that is hardcoded into a component, versus residing in a i18n json file?I.e. something like https://github.com/edvardchen/eslint-plugin-i18next/blob/main/docs/rules/no-literal-string.md?