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

[meded90]

I really hope this rule helps to eliminate stupid mistakes, especially in the code generated by AI.

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

[sika-uma]

CSS sorting seems risky.
ref: prettier/prettier#2502 (comment)

[simon-paris]

Css property sorting already has an open PR. And it correctly handles properties that override eachother.

[sika-uma]

Thanks for sharing. Maybe #4476 #4063 is it.

[ghost]

How do you actually get this to work? I've added this configuration and am on 1.9.4 - do I need to do something to "run an assist" or?

[malyzeli]

@Geczy how is this feature meant to be used? Not sure how to trigger the assist action...

[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

[malyzeli]

I'm wondering about possibility of import/no-cycle.

This imo quite useful rule is computationally expensive, so it could benefit from running in Biome instead of ESLint. :-)

[dyc3]

This would definitely require #3307 first. But other than that, yeah that would be a great fit for biome.

[osdiab]

I'd personally like https://typescript-eslint.io/rules/consistent-type-assertions/ , in particular the ability to just disallow type assertions entirely (don't actually care about the other ones).

[osdiab]

I also would be interested in @typescript-eslint/no-unsafe-assignment to avoid assigning any types to things.

[samhh]

Something to monitor the codebase against using syntax or other features not yet widely or newly available as per Baseline would be great.

Tooling to transpile and polyfill is increasingly irrelevant however it's easy to mistakenly use something without adequate browser support (and this applies even with transpilation and polyfills as not everything can be backported e.g. proxies).

It looks like eslint/css is going to add something similar: eslint/css#26

[vorant94]

hi, there

is there an option to add allowList option to noNamespaceImport rule like in the ESLint version? some libraries like valibot simply don't have convenient way of importing without namespaces...

[florianmatz]

Is there any plan to add "prefer-immediate-return" (as used in eslint-plugin-sonarjs? Or am I missing an already existing rule?

[dyc3]

Sounds like a great addition. I've opened #4748 for this.

[mojavelinux]

Would you consider supporting the no-restricted-properties rule from ESLint? See https://eslint.org/docs/latest/rules/no-restricted-properties

The motivation for using this rule is to prevent programmers from using deprecated methods such as String#substr. See https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/substr (preferring String#slice instead).

I'd be equally happy with a no deprecated methods rule in JavaScript in general since I'd rather not have to itemize each deprecation. I'm just using no-restricted-properties in ESLint to express this rule.

[Conaclos]

We have a dedicated rule to ban substr: noSubstr.

I'd be equally happy with a no deprecated methods rule in JavaScript in general since I'd rather not have to itemize each deprecation

I don't understand what you mean here.

[kibertoad]

substr is a deprecated method, so would fit generic noDeprecatedJs rule, rather than having noDeprecatedMethodX rule per method

[yuriyward]

Hi, are there any plans to implement a rule for padding-line-between-statements ?
It feels like a common stylistic choice, could you please consider adding this functionality?

[dyc3]

We generally stick to prettier formatting when it comes to code style, so this is not a good fit for biome.

[yuriyward]

We generally stick to prettier formatting when it comes to code style, so this is not a good fit for biome.

Thank you for the clarification.

In that case, what would you recommend for enforcing padding lines? From my perspective, this limitation means we might need to revert to using ESLint.

Prettier's reasoning for not handling padding lines is:
"It turns out that empty lines are very hard to automatically generate. The approach that Prettier takes is to preserve empty lines the way they were in the original source code."

Does Biome follow a similar approach? Or are there any workarounds or plugins you’d recommend for this use case?

[dyc3]

Biome (and also pretter) preserves up to one blank line between statements. Playground. So as long as your extra padding is limited to 1 blank line, you could have biome do formatting, and have eslint enforce this rule and they will probably not conflict.

[yuriyward]

I see, I will paste there a code that is valid acorrding to prettier, doesnt it feel as wall of text?

import type { FC } from 'react';
import clsx from 'clsx';
import type { CSSProperties } from 'react';
interface ProgressIndicatorProps {
  displayText: string;
  completionPercentage?: number;
  totalBytes?: number;
  isExtendedView?: boolean;
  transferSpeed?: number; // bytes per second
  bytesProcessed?: number;
}
function convertBytesToHumanReadable(byteSize: number): string {
  const unitIndex =
    byteSize === 0 ? 0 : Math.floor(Math.log(byteSize) / Math.log(1024));
  const units = ['B', 'kB', 'MB', 'GB', 'TB'];
  return +(byteSize / 1024 ** unitIndex).toFixed(2) * 1 + units[unitIndex];
}
function formatTransferSpeed(bytesPerSecond: number): string {
  return `${convertBytesToHumanReadable(bytesPerSecond)}/s`;
}
function calculateTimeRemaining(
  totalBytes: number,
  processedBytes: number,
  bytesPerSecond: number,
): string {
  if (!bytesPerSecond) return 'calculating...';
  const remainingBytes = totalBytes - processedBytes;
  const remainingSeconds = remainingBytes / bytesPerSecond;
  return `${Math.ceil(remainingSeconds)}s remaining`;
}
export default function ProgressIndicator({
  displayText,
  completionPercentage = 0,
  totalBytes,
  isExtendedView,
  transferSpeed = 0,
  bytesProcessed = 0,
}: ProgressIndicatorProps) {
  const progressBarWidth = isExtendedView ? 100 : 0;
  completionPercentage ??= 0;
  const progressDetails =
    totalBytes && transferSpeed
      ? `${displayText} (${completionPercentage.toFixed(2)}% of ${convertBytesToHumanReadable(totalBytes)} | ` +
        `${formatTransferSpeed(transferSpeed)} | ` +
        `${calculateTimeRemaining(totalBytes, bytesProcessed, transferSpeed)} | ` +
        `Processed: ${convertBytesToHumanReadable(bytesProcessed)})`
      : `${displayText} (${completionPercentage.toFixed(2)}%${
          totalBytes ? ` of ${convertBytesToHumanReadable(totalBytes)}` : ''
        })`;
  return (
    <div className="w-full bg-gray-100 dark:bg-gray-700 text-left rounded-lg overflow-hidden mb-0.5">
      <div>
        {progressBarWidth === 0 ? null : (
          <div className="bg-gray-300 h-1 w-full" />
        )}
      </div>
      <div
        className="bg-blue-400 whitespace-nowrap px-1 text-sm"
        style={{ width: `${completionPercentage}%` }}
      >
        {progressDetails}
      </div>
    </div>
  );
}

Automatic padding between functions, imports and return statements will make the code much more readable, at least for me.

Related rules: lines-between-class-members
and import/newline-after-import

[rujorgensen]

Hi! Any plans to support comma-dangle?

[dyc3]

That is correct. We've adopted the same philosophy as prettier with regards to code formatting. This significantly reduces the complexity we deal with.

"style" lint rules are for things outside of code formatting. Though not really formally defined, we make a distinction between style and formatting. Formatting purely refers to appearance (tabs vs spaces, indentation, brackets on the same line, etc.), but don't affect the underlying semantics. Style rules deal with things that do change the semantics, usually related to trivial patterns (useForOf, useNumericLiterals, etc.). A pretty good rule of thumb is: When parsed, does the changed code produce a different AST from the original? If yes, it's style, otherwise it's formatting.

comma-dangle simply adds commas -- the same code with and without commas means the same thing, so its formatting.

[rujorgensen]

Thanks for the explanation, it makes sense now 🙏. But damn, this is a dealbreaker at work, I had so high hopes for Biome though 😞.

[dandv]

Formatting purely refers to appearance (tabs vs spaces, indentation, brackets on the same line, etc.), but don't affect the underlying semantics.

@dyc3 How does biome handle cases when appearance (spaces) does affect the underlying semantics?

For example, consider the code below,

const x = Math.random();

if (x < 0.5)
  if (x < 0.1)
    console.log('x is really small', x);
else
  console.log('x > 0.5', x);

Neither biome, nor oxlint, nor deno lint caught the issue. I don't want to opt into the formatting; I just want a linter to warn me about that else for those times when real-world code makes this kind of error (or others) harder to spot.

[dyc3]

The problem with that code is that it is inherently ambiguous to readers. (IMO, it's poor syntax that shouldn't be part of the language, and why people usually just ban usage of that syntax, see our rule useBlockStatements) Of course, it's not ambiguous to js parsers (ours included). At a quick glance, we parse this correctly, where the else actually belongs to the inner if statement. There's nothing I can see in the spec about whitespace changing the semantics of how this is parsed.

[dandv]

There's nothing I can see in the spec about whitespace changing the semantics

You're right, of course. I meant that the incorrect whitespace indentation before the else and the second console.log can mislead a developer's casual look.

I was trying out biome for the first time and had run it with npx @biomejs/biome lint. It output Checked 1 file in 2ms. No fixes applied., which must mean that useBlockStatements was default off without a biome.json config file.

[scarf005]

would be nice to have object-shorthand, i'm interested in opening a PR.

[arendjr]

Cool! I’ll create an issue for it.

[arendjr]

Here you go: #4816

I couldn’t assign you yet, but if you comment there it should work.

[dyc3]

This has already been discussed: #3 (comment)

[kaytwo]

Is there any interest in a new rule that provides a hint about this footgun? https://stackoverflow.com/a/51114250/12887845 TLDR: using a top level import in a .d.ts file breaks the entire file because of how TypeScript handles ambient vs. normal modules, and tsc is no help debugging it, it just loses access to the defined types. I'd imagine "warn on top level import in filename matching /\.d\.ts$/" would be pretty easy to write up as a new nursery rule, but don't want to contribute to rule creep.

[dyc3]

Seems like a nice rule to have. Feel free to open a task issue for it.

[austin43]

With react-compiler likely exiting beta this year, would it be feasible to add a plugin that mimics the eslint compiler plugin? https://github.com/facebook/react/blob/main/compiler/packages/eslint-plugin-react-compiler

Someone made an issue but was redirected here, and I don't think it made it to this discussion.

[dyc3]

This has already been discussed: #3 (comment)

[danielbayley]

eslint-plugin-unicorn/no-array-callback-reference would be nice, unless there is already an alternative I have missed? This one also seems to be missing from the above eslint-plugin-unicorn list @Conaclos

[silvenon]

An equivalent of react/no-unknown-property would be incredibly useful. Currently Biome doesn't warn against class in favor of className or fill-rule in favor of fillRule in JSX (it has a reverse rule, though 😄).

Thankfully React is looking out for us and produces console errors if we do this, but lint errors would obviously be much more efficient.