Configuration de monorepo TypeScript

Le monorepo est un modèle de développement qui place plusieurs projets dans le même dépôt de code.

TypeScript prend en charge le monorepo via les références de projet et les chaînes d'outils, permettant une gestion efficace de plusieurs packages.


Schéma SVG : Structure du monorepo Background Title Monorepo Project Structure Root directory Root directory (root) package.json | tsconfig.json | lerna.json | turbo.json Package directory packages/ directory Package 1 utils Package 2 ui-components Package 3 hooks Package 4 app Bottom section: Tools Management tools: npm workspaces | yarn workspaces | pnpm | lerna | turbo Arrow marker

Pourquoi le monorepo est nécessaire

Lorsqu'un projet contient plusieurs packages (tels que des bibliothèques utilitaires, des bibliothèques de composants et des applications), l'approche traditionnelle nécessite de maintenir plusieurs dépôts de code.

Le monorepo place tous les packages dans le même dépôt, ce qui rend le partage de code plus pratique et la gestion des versions plus unifiée.

La fonctionnalité de références de projet de TypeScript rend la vérification des types et la compilation des projets Monorepo plus efficaces.

Concept:Monorepo (dépôt unique) place plusieurs projets connexes dans le même dépôt de code, ce qui facilite le partage de code et le développement coordonné.


Espace de travail pnpm

pnpm est un gestionnaire de paquets moderne avec une prise en charge native des fonctionnalités d'espace de travail.

package.json racine

{
    "name": "my-monorepo",
    "version": "1.0.0",
    "private": true,

    // Activer l'espace de travail pnpm
    "packages": [
        "packages/*"
    ],

    // Dépendances de développement
    "devDependencies": {
        "typescript": "^5.0.0"
    },

    // Scripts
    "scripts": {
        "build": "pnpm -r run build",
        "clean": "pnpm -r run clean",
        "type-check": "pnpm -r run type-check"
    }
}

pnpm:La fonctionnalité Workspace de pnpm peut automatiquement lier les paquets du répertoire packages entre eux.


Structure du projet

Créer la structure de répertoires pour un projet Monorepo.

Structure du répertoire

my-monorepo/
├── packages/
│ ├── utils/# Paquet utilitaire
│ │ ├── src/
│ │ │ └── index.ts
│ │ ├── package.json
│ │ └── tsconfig.json
│   │
│ ├── ui-components/# paquet de composants UI
│ │ ├── src/
│ │ │ ├── Button.tsx
│ │ │ └── index.ts
│ │ ├── package.json
│ │ └── tsconfig.json
│   │
│ └── app/# Application
│ ├── src/
│ │ └── index.tsx
│ ├── package.json
│ └── tsconfig.json
│
├── package.json# Configuration racine
├── tsconfig.base.json# Configuration de base
└── pnpm-workspace.yaml# Configuration pnpm

packages:Tous les paquets sont placés dans le répertoire packages, chacun avec son propre package.json et tsconfig.json.


Configuration TypeScript de base

Créer une configuration de base que tous les packages peuvent utiliser.

tsconfig.base.json

{
    // Options du compilateur
    "compilerOptions": {
        // Version cible
        "target": "ES2020",

        // Système de modules
        "module": "ESNext",

        // Mode strict
        "strict": true,

        // Ignorer la vérification des types de bibliothèque
        "skipLibCheck": true,

        // Activer l'interopérabilité des modules ES
        "esModuleInterop": true,

        // Imposer une casse cohérente dans les noms de fichiers
        "forceConsistentCasingInFileNames": true,

        // Résolution des modules
        "moduleResolution": "bundler",

        // Résoudre les modules JSON
        "resolveJsonModule": true,

        // Modules isolés
        "isolatedModules": true,

        // Ne pas générer de fichiers de sortie
        "noEmit": true
    }
}

Héritage :Le tsconfig.json de chaque package hérite de la configuration de base et ne remplace que les options qui nécessitent une personnalisation.


Configuration du package utilitaire

Configurer TypeScript pour le package utilitaire.

packages/utils/tsconfig.json

{
    // Hériter de la configuration de base
    "extends": "../../tsconfig.base.json",

    // Options du compilateur
    "compilerOptions": {
        // Répertoire de sortie
        "outDir": "./dist",

        // Répertoire des fichiers de déclaration
        "declarationDir": "./dist/types",

        // Générer les fichiers de déclaration
        "declaration": true,

        // Générer les déclarations pour les fichiers d'entrée
        "declarationMap": true,

        // Format d'export du module
        "module": "ESNext",

        // Activer les références de projet
        "composite": true
    },

    // Fichiers inclus
    "include": ["src/**/*"],

    // Fichiers exclus
    "exclude": ["node_modules", "dist", "**/*.test.ts"]
}

composite:Après avoir activé les références de projet, TypeScript peut compiler ce package de manière incrémentielle.


Configuration de l'application

Configurer TypeScript pour l'application principale et référencer d'autres packages.

packages/app/tsconfig.json

{
    // Hériter de la configuration de base
    "extends": "../../tsconfig.base.json",

    // Options du compilateur
    "compilerOptions": {
        // Répertoire de sortie
        "outDir": "./dist",

        // Configuration JSX
        "jsx": "react-jsx",

        // Alias de chemins
        "baseUrl": ".",
        "paths": {
            "@my-utils/*": ["../utils/src/*"],
            "@my-ui/*": ["../ui-components/src/*"]
        }
    },

    // Références de projet
    "references": [
        { "path": "../utils" },
        { "path": "../ui-components" }
    ],

    // Fichiers inclus
    "include": ["src/**/*"],

    // Fichiers exclus
    "exclude": ["node_modules", "dist"]
}

Alias de chemin :Vous pouvez configurer des alias de chemin pour référencer directement d'autres packages dans le même dépôt.


Dépendances entre packages

Déclarez les dépendances sur les packages du même dépôt dans package.json.

packages/app/package.json

{
    "name": "@my-org/app",
    "version": "1.0.0",
    "private": true,

    "dependencies": {
        // Référencer les packages du même dépôt
        "@my-org/utils": "workspace:*",
        "@my-org/ui-components": "workspace:*",

        // Dépendances externes
        "react": "^18.2.0",
        "react-dom": "^18.2.0"
    },

    "devDependencies": {
        // Dépendances de développement
        "@types/react": "^18.2.0",
        "typescript": "^5.0.0"
    }
}

workspace :Utilisez workspace:* pour pointer vers d'autres paquets du même dépôt, et pnpm les résoudra automatiquement.


Scripts de build

Créez des scripts de build unifiés pour le monorepo.

package.json racine

{
    "scripts": {
        // Compiler tous les paquets
        "build": "pnpm -r run build",

        // Nettoyer tous les artefacts de build
        "clean": "pnpm -r run clean",

        // Vérification des types
        "type-check": "pnpm -r run type-check",

        // Tester tous les paquets
        "test": "pnpm -r run test",

        // Compilation incrémentale
        "build:watch": "pnpm -r --parallel run build:watch",

        // Démarrer l'application
        "dev": "pnpm --filter @my-org/app run dev"
    }
}

pnpm -r :Exécuter récursivement les scripts portant le même nom dans tous les paquets.


Notes

  • Convention de nommage des paquets :Utiliser le format @org-name/package
  • Versions indépendantes :Chaque paquet peut être versionné indépendamment
  • Protocole workspace :Utiliser workspace:* pour référencer des paquets dans le même dépôt
  • Ordre de compilation :Les paquets dont d'autres dépendent doivent être compilés en premier

Bonnes pratiques :Le monorepo convient à la gestion de plusieurs projets liés et peut considérablement améliorer la réutilisation du code et l'efficacité du développement.


Résumé

Le monorepo est un modèle recommandé pour la gestion de projets front-end modernes.

  • pnpm Workspace :Prise en charge native des monorepos
  • Références de projet :Activer la compilation incrémentale
  • Alias de chemins :Référencer facilement des paquets dans le même dépôt
  • Gestion unifiée :Partager la configuration et les dépendances

Recommandation :Lorsqu'un projet contient plusieurs paquets liés, envisagez d'abord l'approche Monorepo.

Autres extensions