Configuration

`$schema`

Permet de passer un chemin vers un fichier de schéma JSON.

Nous publions un schéma JSON pour le fichier biome.json.

Vous pouvez spécifier un chemin relatif vers le schéma du paquet npm @biomejs/biome si @biomejs/biome est installé dans le dossier node_modules :

1
{
2
  "$schema": "./node_modules/@biomejs/biome/configuration_schema.json"
3
}

Si vous avez des problèmes avec la résolution du fichier sur disque, vous pouvez utiliser celui que nous publions sur notre site :

1
{
2
  "$schema": "https://biomejs.dev/schemas/1.9.4/schema.json"
3
}

`extends`

Une liste de chemins vers d’autres fichiers de configuration Biome. Biome résout et applique les paramètres de configuration contenus dans les fichiers listés dans extends, puis applique les options définies dans ce fichier biome.json ou biome.jsonc.

L’ordre des chemins dans la liste va du moins pertinent au plus pertinent.

Depuis la version 2, cette option accepte une chaîne de caractères correspondant à "//", qui peut être utilisée lors de la configuration de monorepos.

`root`

Indique si cette configuration doit être considérée comme une racine. Par défaut, tout fichier de configuration est considéré comme une racine.

Lorsqu’un fichier de configuration est imbriqué (nested configuration), il doit définir "root": false, sinon une erreur est générée.

Cela est nécessaire pour que Biome puisse orchestrer plusieurs fichiers en ligne de commande et dans les éditeurs simultanément.

Valeur par défaut : true

`files`

`files.includes`

Une liste de motifs glob représentant les fichiers à traiter.

Si un dossier correspond à un motif glob, tous les fichiers à l’intérieur de ce dossier seront traités.

L’exemple suivant correspond à tous les fichiers avec une extension .js dans le dossier src :

1
{
2
  "files": {
3
    "includes": ["src/**/*.js"]
4
  }
5
}

* est utilisé pour correspondre à tous les fichiers dans un dossier, tandis que ** correspond récursivement à tous les fichiers et sous-dossiers dans un dossier. Pour plus d’informations sur les globs, consulte la référence de la syntaxe glob.

includes prend également en charge les motifs négatifs, ou exceptions. Ce sont des motifs qui commencent par ! et peuvent être utilisés pour indiquer à Biome de traiter tous les fichiers sauf ceux qui correspondent au motif négatif. Lors de l’utilisation d’un motif négatif, il est recommandé de spécifier d’abord ** pour inclure tous les fichiers et dossiers, sinon le motif négatif ne correspondra à aucun fichier.

Note que les exceptions sont traitées dans l’ordre, ce qui permet de définir des exceptions aux exceptions.

Considère l’exemple suivant :

1
{
2
  "files": {
3
    "includes": ["**", "!**/*.test.js", "**/special.test.js", "!test"]
4
  }
5
}

Cet exemple indique que :

Tous les fichiers dans tous les dossiers (et sous-dossiers) sont traités, grâce au motif ** …
… sauf ceux ayant une extension .test.js …
… mais le fichier special.test.ts est tout de même traité …
… sauf s’il se trouve dans le dossier nommé test, car aucun fichier dans ce dossier n’est traité.

Ce qui donne :

src/app.js est traité.
src/app.test.js n’est pas traité.
src/special.test.js est traité.
test/special.test.js n’est pas traité.

Remarque sur le scanner de Biome

Biome dispose d’un scanner chargé de détecter les fichiers .gitignore imbriqués ainsi que d’indexer les projets si certaines règles du domaine projet sont activées.

Le scanner respecte le paramètre files.includes, mais il y a quelques subtilités. Consulte la documentation du scanner pour plus d’informations.

`files.ignoreUnknown`

Biome n’engendrera pas de diagnostics s’il rencontre des fichiers qu’il ne peut pas prendre en charge.

1
{
2
  "files": {
3
    "ignoreUnknown": true
4
  }
5
}

Valeur par défaut : false

`files.maxSize`

La taille maximale autorisée pour les fichiers de code source, en octets. Les fichiers dépassant cette limite seront ignorés pour des questions de performance.

Valeur par défaut : 1048576 (1024*1024, 1 Mo)

`files.experimentalScannerIgnores`

Un tableau de chemins que le scanner doit ignorer lors de l’exploration. Les fichiers ignorés ne seront pas indexés, ce qui signifie qu’ils ne feront pas partie du graphe de modules, et que leurs types ne seront pas inférés.

Dans l’exemple suivant, les dossiers lodash et dist, ainsi que le fichier RedisCommander.d.ts, seront ignorés :

1
{
2
  "files" : {
3
    "experimentalScannerIgnores": [
4
      "lodash",
5
      "dist",
6
      "RedisCommander.d.ts"
7
    ]
8
  }
9
}

il ne faut utiliser cette option qu’en dernier recours, dans les cas où Biome met beaucoup de temps à analyser ou vérifier le projet. Les chemins de type glob ne sont pas pris en charge, seuls les noms de base sont comparés.

Voir la documentation du scanner pour plus d’informations.

`vcs`

Ensemble de propriétés pour intégrer Biome à un VCS (logiciel de contrôle de versions, Version Control Software).

`vcs.enabled`

Si Biome devrait s’intégrer au client VCS ou non.

Valeur par défaut : false

`vcs.clientKind`

Le type de client.

Valeurs :

"git"

`vcs.useIgnoreFile`

Si Biome devrait utiliser le fichier ignore du VCS ou non. Si true, Biome ignorera les fichiers spécifiés dans le fichier ignore.

`vcs.root`

Le dossier où Biome devrait vérifier les fichiers du VCS. Par défaut, Biome utilisera le même dossier où biome.json a été trouvé.

Si Biome ne peut pas trouver la configuration, il tentera d’utiliser le répertoire de l’espace de travail actuel. Si aucun répertoire de l’espace de travail actuel ne peut être trouvé, Biome n’utilisera pas l’intégration au VCS et un diagnostic sera généré.

`vcs.defaultBranch`

La branche principale du projet. Biome utilisera cette branche quand il évaluera les fichiers modifiés.

`linter`

`linter.enabled`

Active l’outil de linting de Biome.

Valeur par défaut : true

`linter.includes`

Une liste de motifs glob représentant les fichiers à analyser avec le linter.

L’exemple suivant analyse tous les fichiers avec une extension .js dans le dossier src :

1
{
2
  "linter": {
3
    "includes": ["src/**/*.js"]
4
  }
5
}

Note que les exceptions sont traitées dans l’ordre, ce qui permet de définir des exceptions aux exceptions.

Considère l’exemple suivant :

1
{
2
  "linter": {
3
    "includes": ["**", "!**/*.test.js", "**/special.test.js"]
4
  }
5
}

Cet exemple indique que :

Tous les fichiers dans tous les dossiers (et sous-dossiers) sont traités, grâce au motif ** …
… sauf ceux ayant une extension .test.js …
… mais le fichier special.test.ts est tout de même traité …

Ce qui donne :

src/app.js est traité.
src/app.test.js n’est pas traité.
src/special.test.js est traité.

À noter : linter.includes est appliqué après files.includes. Cela signifie que tout fichier non inclus par files.includes ne pourra pas être analysé par linter.includes.

L’exemple suivant ne fonctionne pas :

1
{
2
  "files": {
3
    "includes": "src/**"
4
  },
5
  "linter": {
6
    // Cela ne correspond à rien car il n’y a pas de chevauchement avec `files.includes` :
7
    "includes": "scripts/**"
8
  }
9
}

Si linter.includes n’est pas spécifié, tous les fichiers correspondants à files.includes seront analysés.

`linter.rules.recommended`

Active les règles recommandées pour tous les groupes.

Valeur par défaut : true

`linter.rules.[groupe]`

Options qui influencent les règles d’un seul groupe. Biome prend en charge les groupes suivants :

accessibility: Règles visant à prévenir les problèmes d’accessibilité.
complexity: Règles qui inspectent du code complexe pouvant être simplifié.
correctness: Règles qui détectent du code garanti comme incorrect ou inutile.
nursery: Nouvelles règles encore en développement. Ces règles nécessitent une activation explicite dans la configuration des versions stables, car elles peuvent contenir des bugs ou des problèmes de performance. Elles sont activées par défaut dans les versions nightly, mais leur sévérité peut être définie comme erreur ou avertissement selon leur niveau de recommandation futur. Les règles de ce groupe peuvent être promues vers d’autres groupes une fois stabilisées, ou supprimées. Elles ne sont pas soumises au versionnement sémantique.
performance: Règles qui identifient des moyens d’écrire du code plus rapide ou plus efficace.
security: Règles qui détectent des failles potentielles de sécurité.
style: Règles qui imposent une manière cohérente et idiomatique d’écrire du code.
suspicious: Règles qui détectent du code probablement incorrect ou inutile.

Chaque groupe peut être configuré avec une valeur de sévérité ou un objet où chaque règle est définie individuellement.

Quand la sévérité est passée, elle s’appliquera à toutes les règles du groupe. Par exemple, pour configurer le groupe a11y afin qu’il émette des diagnostics de type “info” :

1
{
2
  "linter": {
3
    "rules": {
4
      "a11y": "info"
5
    }
6
  }
7
}

Valeurs acceptées :

"on": Chaque règle du groupe émettra un diagnostic avec sa sévérité par défaut. Tu peux consulter la documentation de la règle ou utiliser la commande biome explain :
Fenêtre de terminal
```
biome explain noDebugger
```
"off": Aucune règle du groupe n’émettra de diagnostic.
"info": Toutes les règles du groupe émettront des diagnostics de type information.
"warn": Toutes les règles du groupe émettront des diagnostics de type avertissement.
"error": Toutes les règles du groupe émettront des diagnostics de type erreur.

`linter.rules.[groupe].recommended`

Active les règles recommandées pour un seul groupe.

Exemple :

1
{
2
  "linter": {
3
    "enabled": true,
4
    "rules": {
5
      "nursery": {
6
        "recommended": true
7
      }
8
    }
9
  }
10
}

`assist`

`assist.enabled`

Active l’assistant de Biome.

Default: true

`assist.includes`

Une liste de motifs glob représentant les fichiers à analyser avec l’assistant.

L’exemple suivant analyse tous les fichiers avec une extension .js dans le dossier src :

1
{
2
  "assist": {
3
    "includes": ["src/**/*.js"]
4
  }
5
}

Note que les exceptions sont traitées dans l’ordre, ce qui permet de définir des exceptions aux exceptions.

Considère l’exemple suivant :

1
{
2
  "assist": {
3
    "includes": ["**", "!**/*.test.js", "**/special.test.js"]
4
  }
5
}

Cet exemple indique que :

Tous les fichiers dans tous les dossiers (et sous-dossiers) sont traités, grâce au motif ** …
… sauf ceux ayant une extension .test.js …
… mais le fichier special.test.ts est tout de même traité …

Ce qui donne :

src/app.js est traité.
src/app.test.js n’est pas traité.
src/special.test.js est traité.

À noter : assist.includes est appliqué après files.includes. Cela signifie que tout fichier non inclus par files.includes ne pourra pas être analysé par assist.includes.

L’exemple suivant ne fonctionne pas :

1
{
2
  "files": {
3
    "includes": "src/**"
4
  },
5
  "assist": {
6
    // Cela ne correspond à rien car il n’y a pas de chevauchement avec `files.includes` :
7
    "includes": "scripts/**"
8
  }
9
}

Si assist.includes n’est pas spécifié, tous les fichiers correspondants à files.includes seront analysés.

`assist.actions.recommended`

Active les actions recommandées pour tous les groupes.

`assist.actions.[group]`

Options qui influencent les règles d’un groupe spécifique. Biome prend en charge les groupes suivants :

source: Ce groupe représente les actions qui peuvent être appliquées en toute sécurité à un document lors de l’enregistrement. Ces actions sont généralement sûres : elles ne modifient pas le fonctionnement du programme.

`assist.actions.[group].recommended`

Active les règles recommandées pour un groupe spécifique.

Exemple:

1
{
2
  "assist": {
3
    "enabled": true,
4
    "actions": {
5
      "source": {
6
        "recommended": true
7
      }
8
    }
9
  }
10
}

`formatter`

Ces options s’appliquent à tous les langages. Plus loin, il y a des options de formatage supplémentaires propres à un langage.

`formatter.enabled`

Active l’outil de formatage de Biome.

Valeur par défaut : true

`formatter.includes`

Une liste de motifs glob représentant les fichiers à formatter.

L’exemple suivant analyse tous les fichiers avec une extension .js dans le dossier src :

1
{
2
  "formatter": {
3
    "includes": ["src/**/*.js"]
4
  }
5
}

Note que les exceptions sont traitées dans l’ordre, ce qui permet de définir des exceptions aux exceptions.

Considère l’exemple suivant :

1
{
2
  "formatter": {
3
    "includes": ["**", "!**/*.test.js", "**/special.test.js"]
4
  }
5
}

Cet exemple indique que :

Tous les fichiers dans tous les dossiers (et sous-dossiers) sont traités, grâce au motif ** …
… sauf ceux ayant une extension .test.js …
… mais le fichier special.test.ts est tout de même traité …

Ce qui donne :

src/app.js est traité.
src/app.test.js n’est pas traité.
src/special.test.js est traité.

À noter : formatter.includes est appliqué après files.includes. Cela signifie que tout fichier non inclus par files.includes ne pourra pas être analysé par formatter.includes.

L’exemple suivant ne fonctionne pas :

1
{
2
  "files": {
3
    "includes": "src/**"
4
  },
5
  "formatter": {
6
    // Cela ne correspond à rien car il n’y a pas de chevauchement avec `files.includes` :
7
    "includes": "scripts/**"
8
  }
9
}

Si formatter.includes n’est pas spécifié, tous les fichiers correspondants à files.includes seront analysés.

`formatter.formatWithErrors`

Permet de formater un document comportant des erreurs de syntaxe.

1
{
2
  "formatter": {
3
    "formatWithErrors": true
4
  }
5
}

Valeur par défaut : false

`formatter.indentStyle`

Le style d’indentation. La valeur peut être "tab" ou "space".

Valeur par défaut : "tab"

`formatter.indentWidth`

Quelle devrait être la largeur de l’indentation.

Valeur par défaut : 2

`formatter.lineEnding`

Le type de fin de ligne :

"lf" : caractère de retour à la ligne seulement (\n), courant sur Linux et macOS, ainsi que dans les dépôts git ;
"crlf" : caractère de retour chariot + caractère de retour à la ligne (\r\n), courant sur Windows ;
"cr" : caractère de retour chariot seulement (\r), très rarement utilisé.

Valeur par défaut : "lf"

`formatter.lineWidth`

Combien de caractères peuvent être écrits sur une seule ligne.

Valeur par défaut : 80

`formatter.attributePosition`

Le style de positionnement d’un attribut dans les langages HTML et assimilés :

"auto" : les attributs sont automatiquement formatés et ne se répartiront en plusieurs lignes que s’ils répondent à certains critères ;
"multiline" : les attributs sont toujours formatés en plusieurs lignes, quoi qu’il en soit.

Valeur par défaut : "auto"

`formatter.bracketSpacing`

Détermine si des espaces doivent être ajoutés entre les crochets et les valeurs internes.

Valeur par défaut : true

`formatter.expand`

Indique si les tableaux et objets doivent être formatés sur plusieurs lignes.

"auto" : les objets sont mis sur plusieurs lignes si la première propriété contient un saut de ligne ; les tableaux restent sur une seule ligne s’ils tiennent dans la largeur.
"always" : les objets et tableaux sont toujours formatés sur plusieurs lignes, peu importe leur taille.
"never" : les objets et tableaux sont toujours formatés sur une seule ligne s’ils tiennent dans la largeur.

Lors du formatage du fichier package.json, Biome utilisera always par défaut, sauf si une autre option est spécifiée.

Valeur par défaut : "auto"

`formatter.useEditorconfig`

Si Biome devrait utiliser le fichier .editorconfig pour déterminer les options de formatage ou non. Si true, les options applicables dans le fichier .editorconfig seront utilisées ; mais, toute configuration dans le fichier biome.json sera toujours prioritaire.

En migrant depuis Prettier avec biome migrate, cette option est définie à true pour se conformer au comportement de Prettier.

Valeur par défaut : false

`javascript`

Ces options ne s’appliquent qu’aux fichiers JavaScript (et TypeScript).

`javascript.parser.unsafeParameterDecoratorsEnabled`

Permet la prise en charge des décorateurs de paramètre non sûrs/expérimentaux.

1
{
2
  "javascript": {
3
    "parser": {
4
      "unsafeParameterDecoratorsEnabled": true
5
    }
6
  }
7
}

Valeur par défaut : false

`javascript.parser.jsxEverywhere`

Lorsqu’elle est définie sur true, cette option permet d’analyser la syntaxe JSX dans les fichiers .js.

Valeur par défaut : true

1
{
2
  "javascript": {
3
    "parser": {
4
      "jsxEverywhere": false
5
    }
6
  }
7
}

`javascript.formatter.quoteStyle`

Le type de guillemets utilisé pour représenter les littéraux de chaîne. La valeur peut être "single" ou "double".

Valeur par défaut : "double"

`javascript.formatter.jsxQuoteStyle`

Le type de guillemets utilisé pour représenter les littéraux de chaîne JSX. La valeur peut être "single" ou "double".

Valeur par défaut : "double"

1
{
2
  "javascript": {
3
    "formatter": {
4
      "jsxQuoteStyle": "single"
5
    }
6
  }
7
}

`javascript.formatter.quoteProperties`

Quand les propriétés d’objet devraient être entourées de guillemets. La valeur peut être "asNeeded" ou "preserve".

Valeur par défaut : "asNeeded"

1
{
2
  "javascript": {
3
    "formatter": {
4
      "quoteProperties": "preserve"
5
    }
6
  }
7
}

`javascript.formatter.trailingComma`

Cette option est obsolète, veuillez utiliser javascript.formatter.trailingCommas à la place.

Obsolète

Ajoute si possible des virgules de fin dans les structures syntaxiques séparées par des virgules et réparties sur plusieurs lignes. Valeurs possibles :

"all" : la virgule de fin est toujours ajoutée ;
"es5" : la virgule de fin n’est ajoutée qu’aux endroits où elle est prise en charge par les anciennes versions de JavaScript ;
"none" : les virgules de fin ne sont jamais ajoutées.

Valeur par défaut : "all"

`javascript.formatter.trailingCommas`

Ajoute si possible des virgules de fin dans les structures syntaxiques séparées par des virgules et réparties sur plusieurs lignes. Valeurs possibles :

"all" : la virgule de fin est toujours ajoutée ;
"es5" : la virgule de fin n’est ajoutée qu’aux endroits où elle est prise en charge par les anciennes versions de JavaScript ;
"none" : les virgules de fin ne sont jamais ajoutées.

Valeur par défaut : "all"

`javascript.formatter.semicolons`

Configure l’endroit où l’outil de formatage insère les points-virgules :

"always" : les points-virgules sont toujours ajoutés à la fin de chaque instruction ;
"asNeeded" : les points-virgules ne sont ajoutés qu’aux endroits où ils sont nécessaires, pour protéger le code de l’insertion automatique de points-virgules.

Valeur par défaut : "always"

Exemple :

1
{
2
  "javascript": {
3
    "formatter": {
4
      "semicolons": "asNeeded"
5
    }
6
  }
7
}

`javascript.formatter.arrowParentheses`

S’il faut ajouter ou non des parenthèses non nécessaires aux fonctions fléchées :

"always" : les parenthèses sont toujours ajoutées ;
"asNeeded" : les parenthèses ne sont ajoutées que si elles sont nécessaires.

Valeur par défaut : "always"

`javascript.formatter.enabled`

Active l’outil de formatage de Biome pour les fichiers JavaScript (et ses super-langages).

Valeur par défaut : true

`javascript.formatter.indentStyle`

Le style d’indentation pour les fichiers JavaScript (et ses super-langages). La valeur peut être "tab" ou "space".

Valeur par défaut : "tab"

`javascript.formatter.indentWidth`

Quelle devrait être la largeur de l’indentation pour les fichiers JavaScript (et ses super-langages).

Valeur par défaut : 2

`javascript.formatter.lineEnding`

Le type de fin de ligne pour les fichiers JavaScript (et ses super-langages) :

"lf" : caractère de retour à la ligne seulement (\n), courant sur Linux et macOS, ainsi que dans les dépôts git ;
"crlf" : caractère de retour chariot + caractère de retour à la ligne (\r\n), courant sur Windows ;
"cr" : caractère de retour chariot seulement (\r), très rarement utilisé.

Valeur par défaut : "lf"

`javascript.formatter.lineWidth`

Combien de caractères peuvent être écrits sur une seule ligne dans les fichiers JavaScript (et ses super-langages).

Valeur par défaut : 80

`javascript.formatter.bracketSameLine`

Détermine si le > de fin d’un élément JSX écrit sur plusieurs lignes devrait être sur la ligne du dernier attribut ou non.

Valeur par défaut : false

`javascript.formatter.bracketSpacing`

Détermine si les espaces devraient être ajoutés ou non entre les accolades et les valeurs à l’intérieur de ces dernières.

Valeur par défaut : true

`javascript.formatter.attributePosition`

Le style de positionnement d’un attribut dans les éléments JSX.

"auto" : les attributs sont automatiquement formatés et ne se répartiront en plusieurs lignes que s’ils répondent à certains critères ;
"multiline" : les attributs sont toujours formatés en plusieurs lignes, quoi qu’il en soit.

Valeur par défaut : "auto"

`javascript.formatter.expand`

Détermine si les tableaux et objets doivent être formatés sur plusieurs lignes.

"auto" : les objets littéraux sont formatés sur plusieurs lignes si la première propriété contient un saut de ligne. Les tableaux sont formatés sur une seule ligne s’ils tiennent dans la largeur.
"always" : les objets et tableaux sont toujours formatés sur plusieurs lignes, quelle que soit leur longueur.
"never" : les objets et tableaux sont formatés sur une seule ligne s’ils tiennent dans la largeur.

Valeur par défaut : "after".

`javascript.formatter.operatorLinebreak`

Définit si, lors du retour à la ligne dans une expression binaire, l’opérateur doit être placé avant ou après la ligne.

Valeur par défaut : "after".

"after" : l’opérateur est placé après l’expression :

1
if (
2
  expressionOne &&
3
  expressionTwo &&
4
  expressionThree &&
5
  expressionFour
6
) {}

"before" : l’opérateur est placé avant l’expression :

1
if (
2
  expressionOne
3
  && expressionTwo
4
  && expressionThree
5
  && expressionFour
6
) {}

`javascript.globals`

Une liste de noms globaux que Biome devrait ignorer (analyzer, linter, etc.).

1
{
2
  "javascript": {
3
    "globals": ["$", "_", "externalVariable"]
4
  }
5
}

`javascript.jsxRuntime`

Indique le type d’environnement d’exécution ou de transformation utilisé pour interpréter le JSX.

"transparent" : indique un environment JSX moderne ou natif, qui ne requiert pas de prise en charge spéciale par Biome ;
"reactClassic" : indique un environment React classique qui requiert l’import React, correspond à la valeur react de l’option jsx dans le tsconfig.json de TypeScript.

1
{
2
  "javascript": {
3
    "jsxRuntime": "reactClassic"
4
  }
5
}

Pour plus de renseignements sur les environnements d’exécution JSX anciens et nouveaux, veuillez consulter : https://legacy.reactjs.org/blog/2020/09/22/introducing-the-new-jsx-transform.html

Valeur par défaut : "transparent"

`javascript.linter.enabled`

Active l’outil de linting de Biome pour les fichiers JavaScript (et ses super-langages).

Valeur par défaut : true

1
{
2
  "javascript": {
3
    "linter": {
4
      "enabled": false
5
    }
6
  }
7
}

`javascript.assist.enabled`

Active l’assistance de Biome pour les fichiers JavaScript (et ses super-langages).

Valeur par défaut : true

1
{
2
  "javascript": {
3
    "assist": {
4
      "enabled": false
5
    }
6
  }
7
}

`json`

Options appliquées aux fichiers JSON.

`json.parser.allowComments`

Active l’analyse des commentaires dans les fichiers JSON.

1
{
2
  "json": {
3
    "parser": {
4
      "allowComments": true
5
    }
6
  }
7
}

`json.parser.allowTrailingCommas`

Active l’analyse des virgules de fin dans les fichiers JSON.

1
{
2
  "json": {
3
    "parser": {
4
      "allowTrailingCommas": true
5
    }
6
  }
7
}

`json.formatter.enabled`

Active l’outil de formatage de Biome pour les fichiers JSON (et ses super-langages).

Valeur par défaut : true

1
{
2
  "json": {
3
    "formatter": {
4
      "enabled": false
5
    }
6
  }
7
}

`json.formatter.indentStyle`

Le style d’indentation pour les fichiers JSON (et ses super-langages). La valeur peut être "tab" ou "space".

Valeur par défaut : "tab"

`json.formatter.indentWidth`

Quelle devrait être la largeur de l’indentation pour les fichiers JSON (et ses super-langages).

Valeur par défaut : 2

`json.formatter.lineEnding`

Le type de fin de ligne pour les fichiers JSON (et ses super-langages).

"lf" : caractère de retour à la ligne seulement (\n), courant sur Linux et macOS, ainsi que dans les dépôts git ;
"crlf" : caractère de retour chariot + caractère de retour à la ligne (\r\n), courant sur Windows ;
"cr" : caractère de retour chariot seulement (\r), très rarement utilisé.

Valeur par défaut : "lf"

`json.formatter.lineWidth`

Combien de caractères peuvent être écrits sur une seule ligne dans les fichiers JSON (et ses super-langages).

Valeur par défaut : 80

`json.formatter.trailingCommas`

Ajoute si possible des virgules de fin dans les structures syntaxiques séparées par des virgules et réparties sur plusieurs lignes.

Valeurs possibles :

"none" : la virgule de fin est supprimée ;
"all" : la virgule de fin est préservée et préférée.

Valeur par défaut : "none"

`json.formatter.bracketSpacing`

Détermine si des espaces doivent être ajoutés entre les crochets et les valeurs internes.

Valeur par défaut : true

`json.formatter.expand`

Détermine si les tableaux et objets doivent être formatés sur plusieurs lignes.

"auto" : les objets sont formatés sur plusieurs lignes si la première propriété contient un saut de ligne. Les tableaux sont formatés sur une seule ligne s’ils tiennent dans la largeur.
"always" : les objets et tableaux sont toujours formatés sur plusieurs lignes, quelle que soit leur longueur.
"never" : les objets et tableaux sont formatés sur une seule ligne s’ils tiennent dans la largeur.

Lors du formatage du fichier package.json, Biome utilisera always par défaut, sauf si une autre option est spécifiée.

Valeur par défaut : auto

`json.linter.enabled`

Active l’outil de linting de Biome pour les fichiers JSON (et ses super-langages).

Valeur par défaut : true

1
{
2
  "json": {
3
    "linter": {
4
      "enabled": false
5
    }
6
  }
7
}

`json.assist.enabled`

Active l’assistance de Biome pour les fichiers JSON (et ses super-langages).

Valeur par défaut : true

1
{
2
  "json": {
3
    "assist": {
4
      "enabled": false
5
    }
6
  }
7
}

`css`

Options appliquées aux fichiers CSS.

`css.parser.cssModules`

Active l’analyse des modules CSS.

Valeur par défaut : false

`css.formatter.enabled`

Active l’outil de formatage de Biome pour les fichiers CSS (et ses super-langages).

Valeur par défaut : false

1
{
2
  "css": {
3
    "formatter": {
4
      "enabled": false
5
    }
6
  }
7
}

`css.formatter.indentStyle`

Le style d’indentation pour les fichiers CSS (et ses super-langages). La valeur peut être "tab" ou "space".

Valeur par défaut : "tab"

`css.formatter.indentWidth`

Quelle devrait être la largeur de l’indentation pour les fichiers CSS (et ses super-langages).

Valeur par défaut : 2

1
{
2
  "css": {
3
    "formatter": {
4
      "indentWidth": 2
5
    }
6
  }
7
}

`css.formatter.lineEnding`

Le type de fin de ligne pour les fichiers CSS (et ses super-langages).

"lf" : caractère de retour à la ligne seulement (\n), courant sur Linux et macOS, ainsi que dans les dépôts git ;
"crlf" : caractère de retour chariot + caractère de retour à la ligne (\r\n), courant sur Windows ;
"cr" : caractère de retour chariot seulement (\r), très rarement utilisé.

Valeur par défaut : "lf"

`css.formatter.lineWidth`

Combien de caractères peuvent être écrits sur une seule ligne dans les fichiers CSS (et ses super-langages).

Valeur par défaut : 80

`css.formatter.quoteStyle`

Le type de guillemets utilisé pour représenter les littéraux de chaîne. La valeur peut être "single" ou "double".

Valeur par défaut : "double"

`css.linter.enabled`

Active l’outil de linting de Biome pour les fichiers CSS (et ses super-langages).

Valeur par défaut : true

1
{
2
  "css": {
3
    "linter": {
4
      "enabled": false
5
    }
6
  }
7
}

`css.assist.enabled`

Active l’assistance de Biome pour les fichiers CSS.

Valeur par défaut : true

1
{
2
  "css": {
3
    "assist": {
4
      "enabled": false
5
    }
6
  }
7
}

`graphql`

Options appliquées aux fichiers GraphQL.

`graphql.formatter.enabled`

Active le formateur de Biome pour les fichiers GraphQL.

Valeur par défaut : false

`graphql.formatter.indentStyle`

Définit le style d’indentation pour les fichiers GraphQL. Peut être "tab" (tabulation) ou "space" (espaces).

Valeur par défaut : "tab"

`graphql.formatter.indentWidth`

Définit la largeur de l’indentation dans les fichiers GraphQL.

Valeur par défaut : 2

`graphql.formatter.lineEnding`

Définit le type de saut de ligne utilisé dans les fichiers GraphQL :

"lf" : Line Feed uniquement (\n), courant sur Linux, macOS et dans les dépôts Git ;
"crlf" : Carriage Return + Line Feed (\r\n), courant sur Windows ;
"cr" : Carriage Return uniquement (\r), très rarement utilisé.

Valeur par défaut : "lf"

`graphql.formatter.lineWidth`

Nombre maximal de caractères autorisés sur une seule ligne dans les fichiers GraphQL.

Valeur par défaut : 80

`graphql.formatter.quoteStyle`

Définit le type de guillemets utilisés pour les littéraux de chaîne. Peut être "single" (guillemets simples) ou "double" (guillemets doubles).

Valeur par défaut : "double"

`graphql.linter.enabled`

Active le linter de Biome pour les fichiers GraphQL.

Valeur par défaut : true

`graphql.assist.enabled`

Active l’assistance de Biome pour les fichiers GraphQL.

Valeur par défaut : true

`grit`

Options appliquées aux fichiers Grit.

`grit.formatter.enabled`

Active le formateur de Biome pour les fichiers Grit.

Valeur par défaut : false

`grit.formatter.indentStyle`

Définit le style d’indentation pour les fichiers Grit. Peut être "tab" (tabulation) ou "space" (espaces).

Valeur par défaut : "tab"

`grit.formatter.indentWidth`

Définit la largeur de l’indentation dans les fichiers Grit.

Valeur par défaut : 2

`grit.formatter.lineEnding`

Définit le type de saut de ligne utilisé dans les fichiers Grit :

"lf" : Line Feed uniquement (\n), courant sur Linux, macOS et dans les dépôts Git ;
"crlf" : Carriage Return + Line Feed (\r\n), courant sur Windows ;
"cr" : Carriage Return uniquement (\r), très rarement utilisé.

Valeur par défaut : "lf"

`grit.formatter.lineWidth`

Nombre maximal de caractères autorisés sur une seule ligne dans les fichiers Grit.

Valeur par défaut : 80

`grit.formatter.quoteStyle`

Définit le type de guillemets utilisés pour les littéraux de chaîne. Peut être "single" (guillemets simples) ou "double" (guillemets doubles).

Valeur par défaut : "double"

`grit.linter.enabled`

Active le linter de Biome pour les fichiers Grit.

Valeur par défaut : true

1
{
2
  "grit": {
3
    "linter": {
4
      "enabled": false
5
    }
6
  }
7
}

`grit.assist.enabled`

Active l’assistance de Biome pour les fichiers Grit.

Valeur par défaut : true

1
{
2
  "grit": {
3
    "assist": {
4
      "enabled": false
5
    }
6
  }
7
}

`html`

`html.parser.interpolation`

Active l’analyse des expressions entre doubles accolades comme {{ expression }} dans les fichiers .html.

Valeur par défaut : false

`html.formatter.enabled`

Active le formateur de Biome pour les fichiers HTML.

Valeur par défaut : false

`html.formatter.indentStyle`

Définit le style d’indentation pour les fichiers HTML. Peut être "tab" (tabulation) ou "space" (espaces).

Valeur par défaut : "tab"

`html.formatter.indentWidth`

Définit la largeur de l’indentation dans les fichiers HTML.

Valeur par défaut : 2

`html.formatter.lineEnding`

Définit le type de saut de ligne utilisé dans les fichiers HTML :

"lf" : Line Feed uniquement (\n), courant sur Linux, macOS et dans les dépôts Git ;
"crlf" : Carriage Return + Line Feed (\r\n), courant sur Windows ;
"cr" : Carriage Return uniquement (\r), très rarement utilisé.

Valeur par défaut : "lf"

`html.formatter.lineWidth`

Nombre maximal de caractères autorisés sur une seule ligne dans les fichiers HTML.

Valeur par défaut : 80

`html.formatter.attributePosition`

Définit le style de positionnement des attributs dans les éléments HTML :

"auto" : les attributs sont formatés automatiquement et ne passent à la ligne que si certaines conditions sont remplies ;
"multiline" : les attributs passent à la ligne si plus d’un attribut est utilisé.

Valeur par défaut : "auto"

`html.formatter.bracketSameLine`

Indique si la balise fermante d’un élément HTML multilignes doit être collée à la dernière ligne plutôt que seule sur une nouvelle ligne.

Valeur par défaut : false

`html.formatter.whitespacesSensitivity`

Définit la sensibilité aux espaces lors du formatage HTML (et ses super-langages).

Valeur par défaut : "css"

"css" : les espaces sont considérés comme significatifs pour les éléments ayant un style d’affichage “inline” par défaut dans les feuilles de style des navigateurs.
"strict" : les espaces en début et fin de contenu sont considérés comme significatifs pour tous les éléments.

Le formateur doit conserver au moins un espace s’il est présent. Sinon, aucun espace ne doit être ajouté après > ou avant <.

Exemple de contenu collé aux balises :
```
1
<b
2
   >content</b
3
>
```
"ignore" : les espaces sont considérés comme non significatifs. Le formateur peut les ajouter ou les supprimer librement.

`html.formatter.indentScriptAndStyle`

Indique si les balises <script> et <style> doivent être indentées dans les fichiers HTML (et ses super-langages).

Valeur par défaut : true

`html.formatter.selfCloseVoidElements`

Indique si les éléments vides doivent être auto-fermés.

Valeur par défaut : "never"

"never" : le slash / dans les éléments vides est supprimé par le formateur.
"always" : le slash / est toujours ajouté dans les éléments vides.

`overrides`

Une liste de modèles.

Utilisez cette configuration pour modifier le comportement des outils pour certains fichiers.

Quand un fichier correspond à un modèle d’écrasement, la configuration spécifiée dans ce modèle écrasera la configuration du premier niveau.

L’ordre des modèles a son importance. Si un fichier peut correspondre à trois modèles, seul le premier est utilisé.

`overrides.<ITEM>.includes`

Une liste de motifs glob représentant les fichiers auxquels appliquer des paramètres personnalisés.

1
{
2
  "overrides": [{
3
    "includes": ["scripts/*.js"],
4
    // paramètres qui ne s’appliqueront qu’aux fichiers spécifiés dans le champ includes.
5
  }]
6
}

`overrides.<ITEM>.formatter`

Inclura les options de configuration de formatage du premier niveau, moins ignore et include.

Exemples

Par exemple, il est possible de modifier le formatage de lineWidth : indentStyle pour certains fichiers qui sont inclus dans le glob generated/** :

1
{
2
  "formatter": {
3
    "lineWidth": 100
4
  },
5
  "overrides": [
6
    {
7
      "include": ["generated/**"],
8
      "formatter": {
9
        "lineWidth": 160,
10
        "indentStyle": "space"
11
      }
12
    }
13
  ]
14
}

`overrides.<ITEM>.linter`

Inclura les options de configuration de linting de premier niveau, moins ignore et include.

Exemples

Vous pouvez désactiver certaines règles pour certains globs et désactiver le linting pour d’autres globs :

1
{
2
  "linter": {
3
    "enabled": true,
4
    "rules": {
5
      "recommended": true
6
    }
7
  },
8
  "overrides": [
9
    {
10
      "include": ["lib/**"],
11
      "linter": {
12
        "rules": {
13
          "suspicious": {
14
            "noDebugger": "off"
15
          }
16
        }
17
      }
18
    },
19
    {
20
      "include": ["shims/**"],
21
      "linter": {
22
        "enabled": false
23
      }
24
    }
25
  ]
26
}

`overrides.<ITEM>.organizeImports`

Inclura les options d’organisation des imports de premier niveau, moins ignore et include.

`overrides.<ITEM>.javascript`

Inclura les options de configuration de JavaScript de premier niveau.

Exemples

Vous pouvez modifier le comportement du formatage des fichiers JavaScript dans certains dossiers :

1
{
2
  "formatter": {
3
    "lineWidth": 120
4
  },
5
  "javascript": {
6
    "formatter": {
7
      "quoteStyle": "single"
8
    }
9
  },
10
  "overrides": [
11
    {
12
      "include": ["lib/**"],
13
      "javascript": {
14
        "formatter": {
15
          "quoteStyle": "double"
16
        }
17
      }
18
    }
19
  ]
20
}

`overrides.<ITEM>.json`

Inclura les options de configuration de JSON de premier niveau.

Exemples

Vous pouvez activer les fonctionnalités d’analyse pour certains fichiers JSON :

1
{
2
  "linter": {
3
    "enabled": true,
4
    "rules": {
5
      "recommended": true
6
    }
7
  },
8
  "overrides": [
9
    {
10
      "include": [".vscode/**"],
11
      "json": {
12
        "parser": {
13
          "allowComments": true,
14
          "allowTrailingCommas": true
15
        }
16
      }
17
    }
18
  ]
19
}

Glob syntax reference

Les motifs glob sont utilisés pour faire correspondre des chemins de fichiers et de dossiers. Biome prend en charge la syntaxe suivante :

* correspond à zéro ou plusieurs caractères. Il ne peut pas correspondre au séparateur de chemin /.
** correspond récursivement aux dossiers et fichiers. Cette séquence doit être utilisée comme un composant entier du chemin, donc **a et b** sont invalides et entraîneront une erreur. Une séquence de plus de deux caractères * consécutifs est également invalide.
[...] correspond à tout caractère situé entre les crochets. Il est aussi possible de spécifier des plages de caractères, selon l’ordre Unicode. Par exemple, [0-9] correspond à tout caractère entre 0 et 9 inclus.
[!...] est la négation de [...], c’est-à-dire qu’il correspond à tout caractère non présent dans les crochets.
Si le motif glob commence par !, il s’agit d’un motif dit négatif. Ce motif ne correspond que si le chemin ne correspond pas au motif. Les motifs négatifs ne peuvent pas être utilisés seuls, ils ne peuvent servir que d’exception à un motif glob classique.
Lorsqu’il détermine si un fichier est inclus ou non, Biome prend également en compte les dossiers parents. Cela signifie que si vous souhaitez inclure tous les fichiers d’un dossier, vous devez utiliser le suffixe /** pour les faire correspondre. En revanche, si vous souhaitez ignorer tous les fichiers d’un dossier, vous pouvez le faire sans le suffixe /**. Il est recommandé d’ignorer les dossiers sans le suffixe final /**, afin d’éviter de les parcourir inutilement, ainsi que le risque que Biome charge un fichier biome.json ou .gitignore depuis un dossier ignoré.

Quelques exemples :

dist/** correspond au dossier dist/ et à tous les fichiers qu’il contient.
!dist ignore le dossier dist/ et tous les fichiers qu’il contient.
**/test/** correspond à tous les fichiers situés dans un dossier nommé test, peu importe son emplacement. Par exemple : dist/test, src/test.
**/*.js correspond à tous les fichiers se terminant par l’extension .js, dans tous les dossiers.