---
contentId: bd5d11e9-876b-4ed0-b27b-ba400670de76
part: 1
title: Bien démarrer avec un monorepo, un linter et un formatter
description: Commencez votre aventure avec le monorepo ! Apprenez à configurer un linter et un formatter pour un codage rationalisé et l'organisation de votre projet.
date: 2024-11-24
seriesSlug: the-complete-guide-to-building-a-vue-js-component-library
---

Dans cette série, nous commencerons depuis zéro. C'est la meilleure façon de comprendre et d'apprendre. Nous allons mettre en place un **monorepo**, configurer un **linter** et un **formatter**.



> [!NOTE]
> Le processus est polyvalent et peut être appliqué à n'importe quel projet, pas seulement à une bibliothèque de composants.



## Mise en place du projet

Un **monorepo** est un dépôt qui abrite plusieurs projets. Dans notre cas, nous aurons le package `@barbapapazes/huchet-vue`, deux playgrounds et un storybook. L'utilisation d'un monorepo permet de gérer tous ces projets au sein d'un seul dépôt, facilite le partage de code et permet une installation unique des dépendances, maintenant tout synchronisé et compatible. Nous pourrions facilement envisager d'ajouter d'autres packages à l'avenir, comme une configuration personnalisée de **Tailwind CSS** ou une bibliothèque utilitaire partagée.

Pour créer un monorepo, nous allons utiliser [**pnpm workspaces**](https://pnpm.io/workspaces), une fonctionnalité du gestionnaire de paquets pnpm qui installe les dépendances de manière intelligente, en utilisant des liens durs et des liens symboliques pour économiser de l'espace disque et du temps.

Tout d'abord, créez un nouveau répertoire et initialisez un nouveau dépôt git :

```bash [terminal]
mkdir huchet-vue && cd huchet-vue && npm init -y
```

Ouvrez ce dossier dans votre éditeur de code et modifiez le fichier `package.json` :

```json [package.json]
{
  "name": "huchet-vue",
  "version": "0.0.0",
  "type": "module",
  "private": true
}
```



> [!NOTE]
> Définir le champ `private` à `true` dans un fichier `package.json` empêche toute publication accidentelle dans le registre npm. Notre `package.json` racine est destiné à la gestion du monorepo et non à la publication d'un package.



Ce `package.json` est le fichier principal pour notre monorepo. Les packages futurs auront chacun leur propre `package.json`. Le fichier principal n'inclura que les dépendances et les scripts ayant un impact sur l'ensemble du monorepo, pas ceux partagés entre les packages.

Avant de continuer, ajustez un paramètre de pnpm en créant un fichier `.npmrc` :

```bash [package.json]
echo "shamefully-hoist=true" > .npmrc
```

Ce paramètre permet à pnpm de hisser les dépendances vers le dossier `node_modules` racine. Bien que ce ne soit pas par défaut ou recommandé, cela est nécessaire dans notre cas.



> [!NOTE]
> Par défaut, pnpm crée un `node_modules` semi-strict, permettant l'accès aux dépendances non déclarées uniquement depuis `node_modules`.



## Linter et formatter

Ajouter un **linter** et un **formatter** garantit que notre code reste propre et cohérent, une exigence fondamentale pour tout projet, surtout une bibliothèque de composants utilisée par d'autres développeurs.



> [!NOTE]
> Un **formatter** formate automatiquement votre code selon des règles définies, tandis qu'un **linter** analyse le code statiquement pour détecter d'éventuelles erreurs.



Couramment, on utilise [**Prettier**](https://prettier.io/) comme formatter et [**ESLint**](https://eslint.org/) comme linter. Les deux ont d'amples plugins et configurations, mais leur intégration peut être complexe. Comme je ne suis pas partisan d'un style de code spécifique, tendre vers le moins de configuration est préférable.

Pour ce projet, comme pour tous mes projets, nous allons utiliser la configuration ESLint de [Anthony Fu](https://antfu.me/). C'est une configuration très affirmée utilisant **ESLint** et [**Stylistic**](https://eslint.style/).

Installez-le avec une simple commande :

```bash [terminal]
npx @antfu/eslint-config@latest && pnpm add -D typescript
```



> [!NOTE]
> Ceux-ci sont installés à la racine du monorepo pour maintenir une source unique de vérité pour le linting et le formatting, une pratique courante dans les monorepos.



Ajoutez deux scripts à votre fichier `package.json` :

```json [package.json]
{
  "scripts": {
    "lint": "eslint .",
    "lint:fix": "eslint --fix ."
  }
}
```

Mettez à jour le fichier `eslint.config.ts` pour prendre en charge **Vue**, **TypeScript**, et **Stylistic** :

```typescript [eslint.config.ts]
import antfu from '@antfu/eslint-config'

export default antfu({
  stylistic: true,
  vue: true,
  typescript: true
})
```

Vous pouvez maintenant linter votre code :

```bash [terminal]
pnpm run lint
```

Et corriger automatiquement les problèmes :

```bash [terminal]
pnpm run lint:fix
```

## Définir notre monorepo

Avec le **linter** et le **formatter** configurés, nous pouvons commencer à définir notre monorepo.

Nous aurons la structure suivante :

```txt [Exemple]
.
├── .histoire
│   └── package.json
├── package.json
├── packages
│   └── huchet-vue
│       └── package.json
└── playground
    ├── nuxt
    │   └── package.json
    └── vue
        └── package.json
```

Pour l'instant, créez le dossier `packages` et le package `huchet-vue` avec son fichier `package.json`. D'autres packages seront ajoutés dans les prochains articles de cette série.

```bash [package.json]
mkdir -p packages/huchet-vue
echo '{\n"name": "@barbapapazes/huchet-vue",\n"type": "module",\n"version": "0.0.0"\n}' > packages/huchet-vue/package.json
```

Avoir deux packages nous permet de les définir dans un fichier `pnpm-workspace.yaml` à la racine de notre monorepo :

```bash [pnpm-workspace.yaml]
echo 'packages:\n  - packages/*' > pnpm-workspace.yaml
```

Assurez-vous que le fichier `pnpm-workspace.yaml` ressemble à :

```yaml [pnpm-workspace.yaml]
packages:
  - packages/*
```

Ce fichier indique à pnpm où trouver les packages dans notre monorepo. Il lie les packages ensemble, évite la duplication, partage les dépendances et facilite l'installation avec une seule commande.

Même avec un monorepo, chaque package doit être traité comme un projet autonome, ayant son propre `package.json`, ses dépendances et ses scripts.

Installez les dépendances depuis la racine du projet :

```bash [package.json]
pnpm install
```

Vous constaterez que pnpm reconnaît 2 packages :

```txt [Exemple]
Scope: all 2 workspace projects
```

Dans le prochain article, nous créerons notre premier composant dans notre monorepo nouvellement établi.
