✅ Linter rules from other sources #3

Conaclos · 2023-08-11T15:52:52Z

Conaclos
Aug 11, 2023
Maintainer

Note

This thread was also used to request new rules. Please create a discussion for this going forward.

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

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	⚠️	useIterableCallbackReturn		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		useAdjacentGetterSetter	🍼	Require grouped accessor pairs in object literals and classes
guard-for-in		useGuardForIn		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		[noAwaitInLoop]	🍼	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	✅	noConstantBinaryExpression	🍼	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		noShadow	🍼	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	✅	noUselessBackrefInRegex	🍼	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	🔧	useConsistentObjectDefinition	🍼🔧	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	🔧	useObjectSpread	🍼🔧	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		[useParseIntRadix]	🍼	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	✅	noTsIgnore	🍼✅🔧	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	✅⚠️💭	noFloatingPromises	🍼⚠️	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	⚠️💭	useExhaustiveSwitchCases	🍼⚠️	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	✅	noDocumentCookie	🍼	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	🔧	noUselessStringRaw	🍼	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 · 2023-09-01T07:48:55Z

mcharles-square
Sep 1, 2023

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

12 replies

ematipico Mar 26, 2024
Maintainer

I haven't had time to allocate time.

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

benjamine May 7, 2024

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

jellydn May 21, 2024

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 May 21, 2024
Maintainer

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 May 26, 2024

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:

thanks for making this great project!

AbdealiLoKo · 2023-09-05T04:39:47Z

AbdealiLoKo
Sep 5, 2023

Any plans to support angular eslint rules ?

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

3 replies

Conaclos Sep 5, 2023
Maintainer Author

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

ematipico Sep 5, 2023
Maintainer

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

rubiesonthesky Nov 14, 2023

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

kubijo · 2023-09-23T16:45:53Z

kubijo
Sep 23, 2023

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.

7 replies

Conaclos Jan 6, 2024
Maintainer Author

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 Jan 9, 2024

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

JP250552 Feb 1, 2024

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 Feb 25, 2024

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 Aug 11, 2024

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 · 2023-10-17T10:11:44Z

Conaclos
Oct 17, 2023
Maintainer Author

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

0 replies

Infir3 · 2023-10-18T09:23:15Z

Infir3
Oct 18, 2023

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.

5 replies

Conaclos Oct 18, 2023
Maintainer Author

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 Oct 25, 2023
Maintainer Author

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 Nov 15, 2023

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 Mar 9, 2024

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 Mar 9, 2024
Maintainer Author

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

emab · 2023-10-18T12:38:50Z

emab
Oct 18, 2023

`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

0 replies

jpike88 · 2023-10-19T00:18:25Z

jpike88
Oct 19, 2023

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

5 replies

jpike88 Oct 25, 2023

@Conaclos thoughts on usefulness of this one?

Conaclos Oct 25, 2023
Maintainer Author

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 Jan 8, 2025

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

devuxer Feb 24, 2025

I really miss this one from eslint. Shadowing can cause nasty bugs if you don't realize you've done it, and it's honestly not easy to notice you've done it. This is the type of thing linters are meant for!

hanseltime Jun 21, 2025

Editing my comment here. I didn't realize that there is now a `"nursery": { "noShadow": "error" }" option. Leaving this here in case someone also ends up here via a google search. It's available in v2+.

jpike88 · 2023-10-23T10:41:52Z

jpike88
Oct 23, 2023

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

2 replies

emab Oct 23, 2023

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 Oct 23, 2023
Maintainer Author

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 · 2023-10-27T03:12:06Z

jpike88
Oct 27, 2023

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.

6 replies

jpike88 Oct 27, 2023

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 Oct 27, 2023

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 Oct 27, 2023

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 Oct 27, 2023

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 Oct 27, 2023

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

Perhaps somethinglike zod could help you also?

EvHaus · 2023-11-06T16:38:01Z

EvHaus
Nov 6, 2023

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)

7 replies

sika-uma Nov 27, 2024

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

simon-paris Nov 27, 2024

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

sika-uma Nov 27, 2024

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

ghost Nov 28, 2024

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 Jan 17, 2025

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

birkkensen · 2023-11-07T15:17:43Z

birkkensen
Nov 7, 2023

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

1 reply

seedydocloop Oct 30, 2024

I'm missing this eslint plugin a lot since I moved to biome 😢

rubiesonthesky · 2023-11-14T21:47:05Z

rubiesonthesky
Nov 14, 2023

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

2 replies

Conaclos Nov 14, 2023
Maintainer Author

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 Jul 17, 2024

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

jackTabsCode · 2023-11-26T00:08:06Z

jackTabsCode
Nov 26, 2023

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

6 replies

codingedgar Sep 11, 2024

@Conaclos can this be added to the list?

Conaclos Sep 11, 2024
Maintainer Author

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

k-utsumi Sep 12, 2024

This thread is probably related.
#3 (comment)

nerixim Sep 25, 2024

implemented here: #2652
no documentation though 🙃

Geczy Sep 25, 2024

You can do this in 1.9.2 using this config:

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

Thanks to #2652

daggmano · 2025-01-31T04:28:09Z

daggmano
Jan 31, 2025

Would love to see the following rules implemented:

react/jsx-no-literals (to encourage internationalization efforts)
regex/invalid (to prevent common text patterns that cause issues, such as importing ALL of lodash instead of individual features)

4 replies

Ant59 Feb 15, 2025

Biome's noRestrictedImports should cover your Lodash use case

gethari Mar 13, 2025

@daggmano did you get any solution for react/jsx-no-literals equivalent in biome , @dyc3 can you please suggest any workaround if any ?

thlmenezes Apr 18, 2025

I'm also interested in the react/jsx-no-literals rule, for now I've been manually enforcing it in code review T-T

~commenting to get notified about replies

arendjr Apr 18, 2025
Maintainer

This thread has been closed for rule suggestions, please use this thread instead: #4999

equinusocio · 2025-02-05T12:11:16Z

equinusocio
Feb 5, 2025

Missing important stylelint rule declaration-no-important.

This rule is a core stylelint rule to write and ship sane CSS by blocking the usage of the !important keyword in CSS, which is 99.9% not required by CSS authors, and used by people who really don't understand how specificity works in CSS. This keyword is also really dangerous (similar to the any typescript keyword) for shipped CSS in every context.

2 replies

dyc3 Feb 5, 2025
Maintainer

Surprised we don't have that yet. I've opened #5039 for this.

equinusocio Feb 5, 2025

Probably because there aren’t many CSS dev using biome out there 😅

marc-at-brightnight · 2025-02-06T20:20:57Z

marc-at-brightnight
Feb 6, 2025

Can we implement arrow-body-style, specifically the as-needed portion?

Basically, I want a rule to disallow:

const fn = () => {
  return 5;
};

in favor of

const fn = () => 5;

I'm tired of commenting on this in people's PRs.

6 replies

marc-at-brightnight Feb 6, 2025

I think using function notation is fine. actually, for tsx files, using function syntax is necessary if you have a generic type parameter.

but if you use an arrow function, there should be no immediate return.

Does that make sense?

dyc3 Feb 6, 2025
Maintainer

After playing with it a little bit, I've determined that useArrowFunction does not actually cover this, even though the fix for that rule makes it appear like it does. I've opened #5050 to track this.

sjc5 Apr 19, 2025

I would like the precise opposite of this rule. Perhaps it could be called requireExplicitReturnStatements or something along those lines. Which would appear to be the equivalentof "arrow-body-style": ["error", "always"] in that eslint rule.

This comment was marked as off-topic.

Sign in to view

sjc5 Apr 22, 2025

I would like the precise opposite of this rule. Perhaps it could be called requireExplicitReturnStatements or something along those lines. Which would appear to be the equivalentof "arrow-body-style": ["error", "always"] in that eslint rule.

that's... unusual. glad I'm not reviewing your PRs

I'll just say that presumably the rule exists in eslint for a reason and leave it at that.

gkiely · 2025-02-11T01:15:14Z

gkiely
Feb 11, 2025

For jsx-boolean-value it would be great to see the never option: https://github.com/jsx-eslint/eslint-plugin-react/blob/master/docs/rules/jsx-boolean-value.md

This enforces that <Component prop={true} /> would return an error but <Component prop /> does not.

3 replies

dyc3 Feb 11, 2025
Maintainer

What about when you want to pass false into a prop? Would that be accepted under the never option?

gkiely Feb 11, 2025

Yes

dyc3 Feb 11, 2025
Maintainer

I've created #5095 to track this.

tyilo · 2025-02-11T14:18:58Z

tyilo
Feb 11, 2025

Would be nice to have a lint "useless optional chaining".

Example code:

type Foo = { x: { y: number } };

function getY(foo: Foo | undefined): number | undefined {
  return foo?.x?.y;
}

According to the type Foo, x can not be undefined or null and thus the ?. operator doesn't make sense.

I think biome should suggest replacing the return statement with

return foo?.x.y;

2 replies

dyc3 Feb 11, 2025
Maintainer

This would certainly require type information. See also #3187

tyilo Feb 11, 2025

This would certainly require type information. See also #3187

I've proposed it for typescript-eslint instead: typescript-eslint/typescript-eslint#10824

MarcHbb · 2025-02-11T21:28:37Z

MarcHbb
Feb 11, 2025

Any plans for i18next/no-literal-string ?

1 reply

tomashauser Oct 18, 2025

I'm also looking for this. But specifically for lingui/no-unlocalized-strings without that, developers need to always ensure that they don't forget the formatting macro in user-visible input. So maybe there could be a general plugin that would cover both i18next and lingui cases.

ethanjdiamond · 2025-02-12T21:57:51Z

ethanjdiamond
Feb 12, 2025

Would it be possible to also allow for folder name checking in useFilenamingConvention? I'd also like to enforce that folders in my repo are skewer-cased.

0 replies

Ayut0 · 2025-02-13T00:31:19Z

Ayut0
Feb 13, 2025

Love this product and just switched it from esLint :)

Have you guys ever considered implementing reaxct/jsx-sort-props?

I would love to get back from you guys!!

2 replies

dyc3 Feb 13, 2025
Maintainer

useSortedAttributes will be in 2.0.

Ayut0 Feb 17, 2025

Thanks for the info!!
Look forward to it.

MikeRomaa · 2025-02-17T16:02:29Z

MikeRomaa
Feb 17, 2025

I recently opened a discussion proposing the rules noUselessOptionalChaining¹ and noUselessNonNullAssertion. I didn't know about this thread so I'll link the discussion here: #5145. Also I do realize this requires #3187 so no need to point that out :)

To summarize:

`noUselessOptionalChaining`

Disallow the use of the optional chaining operator (?.) on types that are not unions including undefined or null.

`noUselessNonNullAssertion`

Disallow the use of the non-null assertion operator (!) on types that may return undefined or null.

funnily enough it seems that @tyilo had a suggestion for the this very rule a few comments up ↩

0 replies

sandstrom · 2025-02-27T12:58:27Z

sandstrom
Feb 27, 2025

Trying to migrate from ESlint and stylelint to Biome.

Overall it's going pretty good! But here is a list of a few things we are missing:

JS

https://eslint.org/docs/latest/rules/func-names (to get better stacktraces)
https://eslint.org/docs/latest/rules/sort-imports (custom grouping not available in biome)
https://eslint.org/docs/latest/rules/no-alert (disable use of alert())
https://eslint.org/docs/latest/rules/symbol-description (good for debugging)
https://eslint.org/docs/latest/rules/no-bitwise (avoid this footgun)
https://eslint.org/docs/latest/rules/no-restricted-syntax (disabling e.g. for..in loops, since they iterate over the entire prototype chain, which is virtually never what you want)

CSS

https://stylelint.io/user-guide/rules/property-disallowed-list/ (to disallow e.g. float)
https://stylelint.io/user-guide/rules/unit-disallowed-list/ (few code bases want to mix all units, nice to disable pt, in, cm, etc)
https://stylelint.io/user-guide/rules/function-disallowed-list/ (great to enforce e.g. only hsl colors, to avoid mixing five different color-functions in a codebase)
https://stylelint.io/user-guide/rules/color-named/ (popular to disable)
https://stylelint.io/user-guide/rules/color-no-hex/ (popular to disable)

Also looking forward to plugin support, for things such as eslint-plugin-ember and eslint-plugin-jsdoc.

2 replies

chmmpagne Feb 27, 2025

+1 for func-names.
Our use case is in replacing eslint-plugin-react-refresh.
We get most of this with other rules, but are missing the requirement of names for components.

SirzBenjie Mar 2, 2025

Would very much want no-restricted-syntax, particularly because we actually want the opposite behavior of prefer-exponentiation-operator, as it is too easy to mistype ** and *

devuxer · 2025-03-03T03:06:05Z

devuxer
Mar 3, 2025

@Conaclos, Meta comment about this thread: I left a comment above about a specific rule, but now I am getting notifications about all the rules. I really only want to subscribe to one rule. I'm sure you have good reasons for going with this "mega thread' strategy, but not being able to filter by rule is a serious downside. I wonder if you might consider breaking this thread up into smaller threads, or even switch to having one thread per rule. Thank you.

4 replies

thibaudcolas Mar 4, 2025

💯 it’d be nice to have a CSS-only thread for example. I find Biome to work plenty well enough for JS but am waiting to see specific rules implemented before considering a switch from Stylelint.

devuxer Mar 4, 2025

Incidentally, the thing I'm specifically interested in is about something lacking in JS 😊, but even broad categories would help here!

arendjr Mar 6, 2025
Maintainer

You have been heard :) We've updated the discussion and issue configurations to request people to start new discussions for rule suggestions instead. This way, we can also add labels per language to the discussions.

devuxer Mar 6, 2025

@arendjr, Wow, sweet, thank you!

thibaudcolas · 2025-03-04T06:42:33Z

thibaudcolas
Mar 4, 2025

Here’s a family of CSS rules reliant on configuration that I’d find it hard to work without:

My use cases are to encourage:

Use of logical properties and values over physical ones, for right-to-left language support (margin-inline-start instead of margin-left; text-align: end instead of text-align: right; etc)
Font sizes in relative-length units (em, rem, etc) because pixel font sizes don’t support text resizing
Avoiding altogether of specific rules that are very unlikely to ever be desirable on the types of projects I work on (no forced-color-adjust, no text-transform: uppercase).
Consistent use of variables for things that are managed globally to guarantee consistency with designs (colors, font sizes)

Sample configuration using those rules

Source: stylelint-config-wagtail index.js

'declaration-property-value-allowed-list': {
  // Only allow logical values, and resets.
  'clear': ['both', 'none'],
  // Only allow logical values, and resets.
  'float': ['inline-start', 'inline-end', 'none', 'unset'],
  // Only allow logical values.
  'text-align': ['start', 'end', 'center'],
},
'property-disallowed-list': [
  // There are very few cases where it’s the correct approach.
  '/forced-color-adjust/',
  // Disallow positioning with physical properties. Use logical ones instead.
  '/left/',
  '/right/',
  // Disallow text-transform, as we never want text to be uppercased.
  'text-transform',
],
'scale-unlimited/declaration-strict-value': [
  [
    // Colors should always be defined from variables or functions.
    '/color/',
    'fill',
    'stroke',
    // Consistently using variables for z-index allows us to define the order of the values globally.
    'z-index',
  ],
  {
    ignoreValues: [
      'currentColor',
      'inherit',
      'initial',
      'none',
      'unset',
      'transparent',
      // System colors for forced-colors styling.
      // See https://drafts.csswg.org/css-color-4/#css-system-colors.
      'Canvas',
      'CanvasText',
      'LinkText',
      'VisitedText',
      'ActiveText',
      'ButtonFace',
      'ButtonText',
      'ButtonBorder',
      'Field',
      'FieldText',
      'Highlight',
      'HighlightText',
      'SelectedItem',
      'SelectedItemText',
      'Mark',
      'MarkText',
      'GrayText',
      'AccentColor',
      'AccentColorText',
    ],
  },
],
'selector-max-specificity': '0,3,3',

2 replies

Venefilyn Mar 4, 2025

Agreed on the logical properties. It's something we use a lot in Cockpit to better support ltr rtl. ESLint and Stylelint has this

thibaudcolas Mar 6, 2025

Per the update below, this is now here: CSS rules to restrict allowed declarations #5291

arendjr · 2025-03-06T18:40:26Z

arendjr
Mar 6, 2025
Maintainer

Please know we're closing this thread since it was becoming too unwieldy. This thread originally served three purposes:

To provide an overview of which ESLint rules and plugins were implemented. This information is nowadays available on the website: https://biomejs.dev/linter/rules-sources/
To provide a place where users can request new rules. We've now created a new discussion category for this: https://github.com/biomejs/biome/discussions/new?category=rule-suggestion
To quickly see which rules have already been requested. For this you can now browse the new category: https://github.com/biomejs/biome/discussions/categories/rule-suggestion

Most subthreads here have already had tasks or related discussions created, so discussion can move there. If a rule you are interested in doesn't have a discussion yet, feel free to create one using the link above. Thanks!

0 replies

DorianMaliszewski · 2025-07-09T09:19:57Z

DorianMaliszewski
Jul 9, 2025

1 reply

chmmpagne Jul 9, 2025

#3 (comment)

e965 · 2025-07-15T21:21:09Z

e965
Jul 15, 2025

About react/jsx-fragments - thanks for the useFragmentSyntax, but I really want a rule that enforces writing not a shorthand, but an element mode (<Fragment /> or <React.Fragment />.

The reason is that I want consistency, because a frequent case of using Fragments is iterating an array, and since it is necessary to use a key there, I have to write the full syntax, which will differ from what the existing rule requires.

2 replies

dyc3 Jul 15, 2025
Maintainer

I recommend you open a new discussion for this under rule suggesions -- your request will be lost in this thread.

e965 Jul 16, 2025

@dyc3 thank you #6905

This comment has been hidden.

Sign in to view

This comment has been hidden.

Sign in to view

This comment has been hidden.

Sign in to view

This comment has been hidden.

Sign in to view

This comment has been hidden.

Sign in to view

This comment has been hidden.

Sign in to view

This comment has been hidden.

Sign in to view

This comment has been hidden.

Sign in to view

This comment has been hidden.

Sign in to view

This comment has been hidden.

Sign in to view

This comment has been hidden.

Sign in to view

Uh oh!

✅ Linter rules from other sources #3

Uh oh!

Uh oh!

Conaclos Aug 11, 2023 Maintainer

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

Replies: 193 comments · 356 replies

Uh oh!

Uh oh!

ematipico Mar 26, 2024 Maintainer

Uh oh!

Uh oh!

Uh oh!

ematipico May 21, 2024 Maintainer

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Conaclos Sep 5, 2023 Maintainer Author

Uh oh!

ematipico Sep 5, 2023 Maintainer

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Conaclos Jan 6, 2024 Maintainer Author

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Conaclos Oct 17, 2023 Maintainer Author

Uh oh!

Uh oh!

Uh oh!

Conaclos Oct 18, 2023 Maintainer Author

Uh oh!

Uh oh!

Conaclos Oct 25, 2023 Maintainer Author

Uh oh!

Uh oh!

Uh oh!

Conaclos Mar 9, 2024 Maintainer Author

Uh oh!

Uh oh!

Conaclos
Aug 11, 2023
Maintainer

Replies: 193 comments 356 replies

ematipico Mar 26, 2024
Maintainer

ematipico May 21, 2024
Maintainer

Conaclos Sep 5, 2023
Maintainer Author

ematipico Sep 5, 2023
Maintainer

Conaclos Jan 6, 2024
Maintainer Author

Conaclos
Oct 17, 2023
Maintainer Author

Conaclos Oct 18, 2023
Maintainer Author

Conaclos Oct 25, 2023
Maintainer Author

Conaclos Mar 9, 2024
Maintainer Author