Rev-dep

Capacités  •   Installation  •   Documentation  •   Toolkit d'exploration  •   Référence CLI

Toolkit d'analyse et d'optimisation des dépendances pour les bases de code JavaScript et TypeScript modernes.
Appliquez l'hygiène du graphe de dépendances et supprimez le code inutilisé avec une CLI très rapide.

À propos 📣

À mesure que les bases de code grandissent, maintenir une carte mentale des dépendances devient impossible. Rev-dep est un outil d'analyse statique haute vitesse conçu pour appliquer l'intégrité de l'architecture et l'hygiène des dépendances dans les projets JS/TS à grande échelle.

Considérez Rev-dep comme un linter haute vitesse pour votre graphe de dépendances.

Consolidez les contrôles fragmentés et séquentiels de plusieurs outils lents en un moteur unique et haute performance. Rev-dep exécute une suite complète de contrôles de gouvernance — circularité, orphelins, frontières de modules et plus encore — en un seul passage parallélisé. Implémenté en Go pour contourner les goulots d'étranglement de performance des analyses basées sur Node, il peut auditer un projet de plus de 500k lignes de code en environ 150ms. Voir la comparaison des performances

Gouvernance automatisée de la base de code

Rev-dep va au-delà de l'analyse passive pour appliquer activement les règles, en répondant (et en faisant échouer la CI sur) aux questions difficiles :

• Intégrité de l'architecture : « Est-ce que mon « Domaine A » importe illégalement depuis le « Domaine B » ? ».
• Code mort et gonflement : « Ces fichiers sont-ils inaccessibles, ou ces node_modules sont-ils inutilisés ? ».
• Sécurité du refactoring : « Quels points d'entrée utilisent réellement cet utilitaire, et y a-t-il des chaînes circulaires ? ».
• Hygiène de l'espace de travail : « Mes imports sont-ils cohérents et toutes les dépendances sont-elles déclarées ? ».

Rev-dep sert de gardien haute vitesse pour votre CI, garantissant que votre graphe de dépendances reste léger et que votre architecture demeure intacte pendant vos itérations.

Pourquoi Rev-dep ? 🤔

🏗️ Prise en charge de premier ordre pour les monorepos

Conçu pour les espaces de travail modernes (pnpm, yarn, npm). Rev-dep résout nativement les cartes exports/imports de package.json, les alias TypeScript et trace les dépendances à travers les frontières des packages.

🛡️ Gouvernance de la base de code basée sur la configuration

Allez au-delà de l'analyse passive. Utilisez le moteur de configuration pour appliquer les Frontières de Modules et les Conventions d'Import. Exécutez une suite complète de contrôles d'hygiène (circularité, orphelins, modules inutilisés et plus encore) en un seul passage parallélisé qui sert de gardien haute vitesse pour votre CI.

🔍 Toolkit d'exploration

Toolkit CLI qui aide à déboguer les problèmes de dépendances entre fichiers. Comprenez les relations transitives entre fichiers et corrigez les problèmes.

⚡ Conçu pour la vitesse et l'efficacité de la CI

Implémenté en Go pour éliminer le coût de performance de l'analyse basée sur Node. En traitant les fichiers en parallèle, Rev-dep offre une exécution 17x à 90x plus rapide que les alternatives, réduisant considérablement les coûts de CI et les temps d'attente des développeurs.

Rev-dep peut auditer un projet de plus de 500k lignes de code en environ 150ms. Voir la comparaison des performances

Capacités 🚀

Gouvernance et maintenance (basées sur la configuration) 🛡️

Utilisez rev-dep config run pour exécuter plusieurs contrôles en un seul passage pour tous les packages.

Contrôles disponibles :

• moduleBoundaries - applique les frontières d'architecture entre les modules.
• importConventions - applique les conventions de style d'import (propose une correction automatique).
• unusedExportsDetection - détecte les exports jamais utilisés (propose une correction automatique).
• orphanFilesDetection - détecte les fichiers morts/orphelins (propose une correction automatique).
• unusedNodeModulesDetection - détecte les dépendances déclarées mais non utilisées.
• missingNodeModulesDetection - détecte les imports manquants dans le package json.
• unresolvedImportsDetection - détecte les requêtes d'import non résolues.
• circularImportsDetection - détecte les imports circulaires.
• duplicatedCodeDetection - détecte le code copié-collé (blocs répétés et éléments JSX).
• devDepsUsageOnProdDetection - détecte les dépendances de développement utilisées dans le code de production.
• restrictedImportsDetection - bloque l'import de fichiers/modules interdits depuis des points d'entrée sélectionnés.
• restrictedImportersDetection - liste blanche des points d'entrée pouvant atteindre transitivement un ensemble de fichiers/modules.
• restrictedDirectImportersDetection - restreint les fichiers pouvant importer directement un ensemble de fichiers/modules (non transitif).

Analyse exploratoire (basée sur CLI) 🔍

Utilisez les commandes CLI pour l'exploration ad hoc des dépendances :

• entry-points - découvre les points d'entrée du projet.
• files - liste les fichiers de l'arbre de dépendances pour un point d'entrée donné.
• resolve - trace les chemins de dépendances entre fichiers (qui importe ce fichier).
• imported-by - liste les importateurs directs d'un fichier.
• circular - liste les chaînes de dépendances circulaires.
• duplicated-code - trouve les blocs de code copiés-collés et les éléments JSX.
• node-modules - inspecte les modules node utilisés, inutilisés, manquants et installés.
• lines-of-code - compte les lignes de code effectives.
• unresolved - liste les imports qui n'ont pas pu être résolus, groupés par fichier.
• list-cwd-files - liste tous les fichiers de code source dans le CWD.
• debug - inspecte ce que rev-dep analyse, résout et découvre en interne.

Installation 📦

Documentation complète : rev-dep.com/docs/intro

Installez localement pour configurer les scripts de vérification du projet``` yarn add -D rev-dep

Supprimer```
npm install -D rev-dep

Le contenu à traduire est vide. Veuillez fournir le texte source pour cette portion (chunk 5/205).``` pnpm add -D rev-dep

Créez un fichier de configuration pour un démarrage rapide :```
npx rev-dep config init

Installez globalement pour l'utiliser comme outil CLI :``` yarn global add rev-dep

I don't see any content to translate. The input after "INPUT:" is empty, so there is nothing to render.```
npm install -g rev-dep

Aucun contenu n'a été fourni dans cette entrée (chunk 13 vide). Merci de transmettre le texte à traduire.``` pnpm global add rev-dep

### Guides d'intégration étape par étape

Suivez le guide qui correspond à votre projet pour passer de zéro à une configuration fonctionnelle :

- [Guide d'intégration monorepo](https://rev-dep.com/docs/monorepo-integration-guide) - pour les espaces de travail `pnpm`/`yarn`/`npm`.
- [Guide d'intégration pour espace de travail unique](https://rev-dep.com/docs/single-workspace-integration-guide) - pour les projets à package unique.

## **Exemples rapides 💡**

Quelques exemples d'utilisation instantanée pour se familiariser avec l'outil :```bash

# Detect circular imports/dependencies
rev-dep circular

# Find copy-pasted code
rev-dep duplicated-code

# Detect unused node modules
rev-dep node-modules unused

# List all entry points in the project
rev-dep entry-points

# Check which files an entry point imports
rev-dep files --entry-point src/index.ts

# Find every entry point that depends on a file
rev-dep resolve --file src/utils/math.ts

# Resolve dependency path between files
rev-dep resolve --file src/utils/math.ts --entry-point src/index.ts

Vérifications basées sur la configuration 🛡️

Rev-dep fournit un système de configuration pour orchestrer les vérifications de projet. L'approche par configuration est conçue pour la vitesse et constitue la méthode préférée pour implémenter les vérifications de projet, car elle peut exécuter toutes les vérifications en un seul passage, nettement plus rapidement que l'exécution de plusieurs commandes individuelles séparément.

Les vérifications disponibles sont :

• moduleBoundaries - appliquer des frontières d'architecture entre les modules.
• importConventions - appliquer les conventions de style d'import (propose une correction automatique).
• unusedExportsDetection - détecter les exports jamais utilisés (propose une correction automatique).
• orphanFilesDetection - détecter les fichiers morts/orphelins (propose une correction automatique).
• unusedNodeModulesDetection - détecter les dépendances déclarées mais non utilisées.
• missingNodeModulesDetection - détecter les imports manquants dans le package json.
• unresolvedImportsDetection - détecter les demandes d'import non résolues.
• circularImportsDetection - détecter les imports circulaires.
• duplicatedCodeDetection - détecter les blocs de code copiés-collés et les éléments JSX.
• devDepsUsageOnProdDetection - détecter les dépendances de développement utilisées dans le code de production.
• restrictedImportsDetection - bloquer l'import de fichiers/modules interdits depuis des points d'entrée sélectionnés.
• restrictedImportersDetection - mettre sur liste blanche les points d'entrée qui peuvent atteindre transitivement un ensemble de fichiers/modules.
• restrictedDirectImportersDetection - restreindre les fichiers pouvant importer directement un ensemble de fichiers/modules (non transitif).

Les vérifications sont regroupées dans des espaces de travail. Vous pouvez avoir plusieurs espaces de travail, par ex. pour chaque paquet du monorepo.

Pour commencer

Initialisez un fichier de configuration dans votre projet :```bash

Create a default configuration file

rev-dep config init

Comportement de `rev-dep config init` :

- Racine d'un monorepo : Exécuter `rev-dep config init` à la racine de l'espace de travail crée un espace de travail racine et un espace de travail pour chaque package d'espace de travail découvert.
- Package d'espace de travail d'un monorepo ou projets standards : Exécuter `rev-dep config init` dans un répertoire crée une configuration avec un seul espace de travail avec `path: "."` pour ce répertoire.

Exécute toutes les vérifications configurées (essai à blanc, aucune correction appliquée pour l'instant) :```bash
# Execute all workspaces and checks defined in the config
rev-dep config run

Listez tous les problèmes détectés :```bash

Lists all detected issues, by default lists first five issues for each check

rev-dep config run --list-all-issues

Corrigez toutes les vérifications corrigeables :```bash
# Fix checks configured with autofix
rev-dep config run --fix

Structure de configuration

Le fichier de configuration (rev-dep.config.json(c) ou .rev-dep.config.json(c)) vous permet de définir plusieurs espaces de travail, chacun ciblant différentes parties de votre base de code avec des contrôles spécifiques activés.

Configuration de démarrage rapide```jsonc

{ "configVersion": "2.0", "$schema": "https://github.com/jayu/rev-dep/blob/master/config-schema/2.0.schema.json?raw=true", "nodeModulesResolution": { "resolutionType": "entry-package", "includeDevDepsFromRoot": false }, "workspaces": [ { "path": ".", "prodEntryPoints": ["src/main.tsx", "src/pages//*.tsx"], "devEntryPoints": ["scripts/", "**/.test."], "unusedExportsDetection": { "enabled": true, "autofix": true }, "orphanFilesDetection": { "enabled": true, "autofix": true }, "unusedNodeModulesDetection": { "enabled": true }, "circularImportsDetection": { "enabled": true }, "devDepsUsageOnProdDetection": { "enabled": true, "ignoreTypeImports": true } } ] }

#### Exemple de configuration complet

Voici un exemple complet montrant toutes les propriétés disponibles :```jsonc
{
  "configVersion": "1.10",
  "$schema": "https://github.com/jayu/rev-dep/blob/master/config-schema/1.10.schema.json?raw=true", // enables json autocompletion
  "conditionNames": ["import", "default"],
  "ignoreFiles": ["**/*.test.*"],
  "nodeModulesResolution": { "resolutionType": "entry-package", "includeDevDepsFromRoot": false },
  "workspaces": [
    {
      "path": ".",
      "followMonorepoPackages": true,
      "prodEntryPoints": ["src/main.tsx", "src/pages/**/*.tsx", "src/server.ts"],
      "devEntryPoints": ["scripts/**", "**/*.test.*"],
      "ignoreEntryPoints": ["src/legacy/oldDashboard.tsx"],
      "moduleBoundaries": [
        {
          "name": "ui-components",
          "pattern": "src/components/**/*",
          "allow": ["src/utils/**/*", "src/types/**/*"],
          "deny": ["src/api/**/*"]
        },
        {
          "name": "api-layer",
          "pattern": "src/api/**/*",
          "allow": ["src/utils/**/*", "src/types/**/*"],
          "deny": ["src/components/**/*"]
        }
      ],
      "importConventions": [
        {
          "rule": "relative-internal-absolute-external",
          "autofix": true,
          "domains": [
            {
              "path": "src/features/auth",
              "alias": "@auth",
              "enabled": true
            },
            {
              "path": "src/shared/ui",
              "alias": "@ui-kit",
              "enabled": false // checks disabled for this domain, but alias is still used for absolute imports from other domains
            }
          ]
        }
      ],
      "circularImportsDetection": {
        "enabled": true,
        "ignoreTypeImports": true
      },
      "orphanFilesDetection": {
        "enabled": true,
        "ignoreTypeImports": true,
        "graphExclude": ["**/*.test.*", "**/stories/**/*"],
        "autofix": true
      },
      "unusedNodeModulesDetection": {
        "enabled": true,
        "includeModules": ["@myorg/**"],
        "excludeModules": ["@types/**"],
        "pkgJsonFieldsWithBinaries": ["scripts", "bin"],
        "filesWithBinaries": ["scripts/check-something.sh"],
        "filesWithModules": [".storybook/main.ts"],
        "outputType": "groupByModule"
      },
      "missingNodeModulesDetection": {
        "enabled": true,
        "includeModules": ["lodash", "axios"],
        "excludeModules": ["@types/**"],
        "outputType": "groupByFile"
      },
      "unusedExportsDetection": {
        "enabled": true,
        "autofix": true,
        "ignoreTypeExports": true,
        "graphExclude": ["**/*.stories.tsx"],
        "ignore": {
          "src/types.ts": "B*",
          "**/generated/**/*.ts": "*"
        },
        "ignoreFiles": ["**/*.generated.ts"],
        "ignoreExports": ["default", "unused*"],
      },
      "unresolvedImportsDetection": {
        "enabled": true,
        "ignore": {
          "src/index.ts": "legacy-*"
        },
        "ignoreFiles": ["**/*.generated.ts"],
        "ignoreImports": ["@internal/*"]
      },
      "devDepsUsageOnProdDetection": {
        "enabled": true,
        "ignoreTypeImports": true
      },
      "restrictedImportsDetection": {
        "enabled": true,
        "entryPoints": ["src/server.ts", "src/server/**/*.ts"],
        "graphExclude": ["some-file-coupling-other-files.ts"],
        "denyFiles": ["**/*.tsx"],
        "denyModules": ["react", "react-*"],
        "ignoreMatches": ["src/server/allowed-view.tsx", "react-awsome-lib"],
        "ignoreTypeImports": true
      }
    }
  ]
}

Available Properties

Root Level Properties

• configVersion (obligatoire) : chaîne de version de la configuration
• $schema (optionnel) : référence au schéma JSON pour la validation
• conditionNames (optionnel) : tableau de noms de conditions pour la résolution des exports
• customAssetExtensions (optionnel) : extensions d'assets supplémentaires traitées comme des imports résolubles (ex. ["glb", "mp3"]). La liste par défaut couvre les extensions courantes pour les polices, images, fichiers de configuration.
• ignoreFiles (optionnel) : motifs de fichiers globaux à ignorer dans tous les workspaces. Les fichiers ignorés par Git sont ignorés par défaut.
• processIgnoredFiles (optionnel) : motifs de fichiers globaux à traiter même s'ils correspondent à gitignore ou à ignoreFiles.
• nodeModulesResolution (optionnel) : détermine avec quel package.json chaque import tiers est validé pour les vérifications missingNodeModules, unusedNodeModules, et unresolvedImports. Configurez-le comme un objet { "resolutionType": ..., "includeDevDepsFromRoot": ... } — la forme générée par rev-dep config init. resolutionType est "entry-package" (par défaut, valide par rapport au package.json d'entrée du workspace) ou "nearest-package" (valide par rapport au package.json propriétaire de chaque fichier — à utiliser pour la disposition par défaut de pnpm, où chaque package ne résout que ses propres dépendances). includeDevDepsFromRoot (par défaut false) permet au code des packages d'utiliser les dev dependencies déclarées uniquement à la racine du monorepo sans que missingNodeModules ou unresolvedImports ne les signalent. Une chaîne simple (ex. "nearest-package") est également acceptée comme forme abrégée rétrocompatible pour resolutionType. S'applique à tous les workspaces. Voir la documentation.
• workspaces (obligatoire) : tableau d'objets workspace

Workspace Properties

Chaque workspace peut contenir les propriétés suivantes :

• path (obligatoire) : chemin du répertoire cible pour ce workspace (soit ., soit un chemin commençant par un nom de sous-répertoire)
• followMonorepoPackages (optionnel) : contrôle la résolution des packages du monorepo. true suit tous les packages du workspace (par défaut), false la désactive, un tableau ne suit que les noms de packages sélectionnés.
• prodEntryPoints (optionnel) : motifs de points d'entrée de production au niveau du workspace pour les valeurs par défaut des détecteurs
• devEntryPoints (optionnel) : motifs de points d'entrée de développement au niveau du workspace pour les valeurs par défaut des détecteurs
• ignoreEntryPoints (optionnel) : motifs au niveau du workspace pour les points d'entrée restants dont vous n'avez plus besoin. Les fichiers correspondant à ces motifs ne sont pas traités comme des problèmes — ils ne sont jamais signalés comme fichiers orphelins, et leurs exports inutilisés ne sont pas signalés. Utile pour les fichiers qui doivent rester commités mais ne sont plus câblés dans l'application.
• moduleBoundaries (optionnel) : tableau de règles de limites de modules
• circularImportsDetection (optionnel) : configuration de détection des imports circulaires (objet unique ou tableau d'objets)
• duplicatedCodeDetection (optionnel) : configuration de détection du code dupliqué (objet unique ou tableau d'objets)
• orphanFilesDetection (optionnel) : configuration de détection des fichiers orphelins (objet unique ou tableau d'objets)
• unusedNodeModulesDetection (optionnel) : configuration de détection des node modules inutilisés (objet unique ou tableau d'objets)
• missingNodeModulesDetection (optionnel) : configuration de détection des node modules manquants (objet unique ou tableau d'objets)
• unusedExportsDetection (optionnel) : configuration de détection des exports inutilisés (objet unique ou tableau d'objets)
• unresolvedImportsDetection (optionnel) : configuration de détection des imports non résolus (objet unique ou tableau d'objets)
• devDepsUsageOnProdDetection (optionnel) : configuration de détection de l'utilisation restreinte des dev dependencies (objet unique ou tableau d'objets)
• restrictedImportsDetection (optionnel) : restreint l'import de fichiers/modules interdits depuis les points d'entrée sélectionnés (objet unique ou tableau d'objets)
• restrictedImportersDetection (optionnel) : liste blanche des points d'entrée pouvant atteindre transitivement un ensemble de fichiers/modules (objet unique ou tableau d'objets)
• restrictedDirectImportersDetection (optionnel) : contraint les fichiers pouvant importer directement un ensemble de fichiers/modules ; non transitif (objet unique ou tableau d'objets)
• importConventions (optionnel) : tableau de règles de conventions d'import

Module Boundary Properties

• name (obligatoire) : nom de la limite
• pattern (obligatoire) : motif glob pour les fichiers de cette limite
• allow (optionnel) : tableau de motifs d'import autorisés
• deny (optionnel) : tableau de motifs d'import interdits (remplace allow)

Import Convention Properties

• rule (obligatoire) : type de la règle, actuellement uniquement relative-internal-absolute-external
• autofix (optionnel) : indique s'il faut corriger automatiquement les violations de conventions d'import (défaut : false)
• domains (obligatoire) : tableau de définitions de domaines. Peut être une chaîne (motif glob) ou un objet avec :
  • path (obligatoire) : répertoire contenant les fichiers du domaine
  • alias (optionnel) : alias à utiliser pour les imports absolus du code de ce domaine
  • enabled (optionnel) : définir sur false pour ignorer les vérifications pour ce domaine (défaut : true)

Detection Options Properties

Chaque propriété de détection peut être configurée comme :

• un objet unique (une instance de détecteur), ou
• un tableau d'objets (plusieurs instances de détecteur évaluées dans le même workspace).

CircularImportsDetection :

• enabled (obligatoire) : active/désactive la détection des imports circulaires
• ignoreTypeImports (optionnel) : exclut les imports de type uniquement lors de la construction du graphe (défaut : false)

DuplicatedCodeDetection :

• enabled (obligatoire) : active/désactive la détection du code dupliqué
• blindIdentifiers (optionnel) : traite les noms comme des jokers, de sorte qu'une copie renommée compte toujours (défaut : false)
• blindStrings (optionnel) : traite le contenu des chaînes et des templates comme des jokers (défaut : false)
• blindNumbers (optionnel) : traite les littéraux numériques comme des jokers (défaut : false)
• minTokens (optionnel) : plus petite duplication à signaler, en tokens (défaut : 50)
• minLines (optionnel) : plus petite duplication à signaler, en lignes (défaut : 3)
• minDepth (optionnel) : profondeur d'imbrication minimale, en comptant le bloc lui-même. 2 exige au moins un niveau imbriqué (défaut : 0)
• minStatements (optionnel) : nombre minimal d'instructions ; s'applique uniquement aux blocs d'instructions (défaut : 0)
• minDuplicates (optionnel) : nombre de copies qu'un fragment doit avoir avant d'être signalé (défaut : 2)
• skipObjects (optionnel) : ne pas signaler les duplications qui ne sont que des littéraux d'objet (défaut : false)
• ignoreFiles (optionnel) : motifs glob à exclure de l'analyse
• snapshotPath (optionnel) : chemin vers une base de référence commitée des duplications reconnues, relatif au workspace. Avec cela, la vérification signale ce qui a changé plutôt que le total

OrphanFilesDetection :

• enabled (obligatoire) : active/désactive la détection des fichiers orphelins
• validEntryPoints (optionnel) : tableau de motifs de points d'entrée valides. S'il est omis, utilise par défaut prodEntryPoints + devEntryPoints du niveau workspace.
• ignoreTypeImports (optionnel) : exclut les imports de type uniquement lors de la construction du graphe (défaut : false)
• graphExclude (optionnel) : motifs de fichiers à exclure de l'analyse du graphe
• autofix (optionnel) : supprime automatiquement les fichiers orphelins détectés lors de l'exécution de rev-dep config run --fix (défaut : false)

UnusedNodeModulesDetection :

• enabled (obligatoire) : active/désactive la détection des modules inutilisés
• includeModules (optionnel) : motifs de modules à inclure dans l'analyse
• excludeModules (optionnel) : motifs de modules à exclure de l'analyse
• pkgJsonFieldsWithBinaries (optionnel) : champs du Package.json contenant des références binaires (ex. lint-staged). Effectue une recherche en texte brut
• filesWithBinaries (optionnel) : motifs de fichiers à rechercher pour l'utilisation de binaires. Effectue une recherche en texte brut
• filesWithModules (optionnel) : motifs de fichiers non JS/TS à rechercher pour les imports de modules (ex. scripts shell). Effectue une recherche en texte brut
• outputType (optionnel) : format de sortie - "list", "groupByModule", "groupByFile"

MissingNodeModulesDetection :

• enabled (obligatoire) : active/désactive la détection des modules manquants
• includeModules (optionnel) : motifs de modules à inclure dans l'analyse
• excludeModules (optionnel) : motifs de modules à exclure de l'analyse
• outputType (optionnel) : format de sortie - "list", "groupByModule", "groupByFile", "groupByModuleFilesCount"

UnusedExportsDetection :

• enabled (obligatoire) : active/désactive la détection des exports inutilisés
• validEntryPoints (optionnel) : motifs glob pour les fichiers dont les exports ne sont jamais signalés comme inutilisés. S'il est omis, utilise par défaut prodEntryPoints + devEntryPoints du niveau workspace.
• ignoreTypeExports (optionnel) : ignore export type / export interface de l'analyse (défaut : false)
• graphExclude (optionnel) : motifs de fichiers à exclure de l'analyse des exports inutilisés
• ignore (optionnel) : correspondance de motifs glob de chemins de fichiers (relatifs au répertoire du chemin du workspace) vers des motifs glob de noms/specifiers d'export à supprimer ; chaque valeur peut être une chaîne ou un tableau de chaînes
• ignoreFiles (optionnel) : motifs glob de chemins de fichiers ; tous les exports inutilisés des fichiers correspondants sont supprimés
• ignoreExports (optionnel) : noms/specifiers d'export (ou globs) à supprimer globalement (prend en charge "default")
• autofix (optionnel) : applique automatiquement les modifications d'exports inutilisés corrigeables lors de l'exécution de rev-dep config run --fix (défaut : false)

UnresolvedImportsDetection :

• enabled (obligatoire) : active/désactive la détection des imports non résolus
• ignore (optionnel) : correspondance de motifs glob de chemins de fichiers (relatifs au répertoire du chemin du workspace) vers des motifs glob de demandes d'import à supprimer ; chaque valeur peut être une chaîne ou un tableau de chaînes
• ignoreFiles (optionnel) : motifs glob de chemins de fichiers ; tous les imports non résolus des fichiers correspondants sont supprimés
• ignoreImports (optionnel) : demandes d'import (ou globs) à supprimer globalement dans les résultats non résolus

DevDepsUsageOnProdDetection :

• enabled (obligatoire) : active/désactive la détection de l'utilisation restreinte des dev dependencies
• prodEntryPoints (optionnel) : motifs de points d'entrée de production à partir desquels tracer les dépendances. S'il est omis, utilise par défaut prodEntryPoints du niveau workspace.
• ignoreTypeImports (optionnel) : exclut les imports de type uniquement du parcours du graphe et de la correspondance des modules (défaut : false)

RestrictedImportsDetection :

• enabled (obligatoire) : active/désactive la détection des imports restreints
• entryPoints (obligatoire si activé) : motifs de points d'entrée utilisés pour construire le graphe de dépendances atteignable (les points d'entrée du niveau workspace ne sont pas appliqués ici)
• graphExclude (optionnel) : motifs de fichiers à exclure de l'analyse du graphe des imports restreints
• denyFiles (optionnel) : motifs de chemins de fichiers interdits (ex. ["**/*.tsx"])
• denyModules (optionnel) : motifs de modules interdits (ex. ["react", "react-*"])
• ignoreMatches (optionnel) : motifs de fichiers/modules à supprimer des résultats d'imports restreints
• ignoreTypeImports (optionnel) : exclut les imports de type uniquement du parcours (défaut : false)

Performance Benefits

L'approche par configuration offre des avantages de performance significatifs :

• Construction d'un arbre de dépendances unique : construit un arbre de dépendances complet pour tous les workspaces
• Exécution parallèle des workspaces : traite plusieurs workspaces simultanément
• Exécution parallèle des vérifications : exécute toutes les vérifications activées dans chaque workspace en parallèle
• Découverte de fichiers optimisée : découvre les fichiers une seule fois et les réutilise pour toutes les vérifications

Cela rend les vérifications basées sur la configuration plus rapides que l'exécution de commandes individuelles en séquence, en particulier pour les grandes bases de code avec plusieurs sous-packages.

Exploratory Toolkit 🔧

Des exemples pratiques montrent comment utiliser les commandes CLI de rev-dep pour explorer, déboguer ou créer des vérifications de qualité de code pour votre projet.

Comment identifier où un fichier est utilisé dans le projet```

rev-dep resolve --file path/to/file.ts

Vous verrez tous les points d’entrée qui requièrent implicitement ce fichier, ainsi que les chemins de résolution.

### **Comment vérifier si un fichier est utilisé**```
rev-dep resolve --file path/to/file.ts --compact-summary

Indique combien de points d’entrée dépendent indirectement du fichier.

Comment identifier les fichiers morts```

rev-dep entry-points

Excluez les points d'entrée du framework si nécessaire à l'aide de `--result-exclude`.

Par exemple, excluez les points d'entrée valides de Next.js lors de l'utilisation du routeur de pages, excluez le répertoire scripts - les scripts sont des points d'entrée valides et excluez tous les fichiers de test:```
rev-dep entry-points --result-exclude "pages/**","scripts/**","**/*.test.*"

Comment lister tous les fichiers importés par un point d'entrée```

rev-dep files --entry-point path/to/file.ts

Utile pour identifier les composants lourds ou les dépendances involontaires.

### **Comment réduire les importations inutiles pour un point d'entrée**

1. Listez tous les fichiers importés :   ```
   rev-dep files --entry-point path/to/entry.ts

2. Identifiez les fichiers suspects.
3. Retracez pourquoi ils sont inclus : ``` rev-dep resolve --file path/to/suspect --entry-points path/to/entry.ts --all
   root@kitploit:~

Comment détecter les dépendances circulaires```

rev-dep circular

### **Comment détecter le code dupliqué**```
rev-dep duplicated-code

Signale les blocs de code répétés et les éléments JSX - des unités que vous pouvez extraire - plutôt que des lignes répétées. Ajoutez --blind-identifiers pour détecter les copies dont les variables ont été renommées.

Comment trouver les modules node inutilisés```

rev-dep node-modules unused

### **Comment trouver les modules node manquants**```
rev-dep node-modules missing

Comment vérifier l'espace utilisé par node_modules```

rev-dep node-modules dirs-size

### **Comment détecter les dépendances de développement utilisées dans le code de production**```
rev-dep config run

Lorsque devDepsUsageOnProdDetection est activé dans votre configuration, rev-dep va :

1. Tracer les graphes de dépendances à partir de vos points d'entrée de production spécifiés
2. Identifier tous les fichiers accessibles depuis ces points d'entrée
3. Vérifier si des modules importés sont listés dans devDependencies dans package.json
4. Signaler les violations en indiquant quelles dépendances de développement sont utilisées et où

Exemple de sortie :``` ❌ Restricted Dev Dependencies Usage Issues (2): lodash (dev dependency) - src/components/Button.tsx (from entry point: src/pages/index.tsx) - src/utils/helpers.ts (from entry point: src/pages/index.tsx) eslint (dev dependency) - src/config/eslint-config.js (from entry point: src/server.ts)

**Notes importantes :**
- Les imports de types uniquement (p. ex., `import type { ReactNode } from 'react'`) sont ignorés lorsque `ignoreTypeImports` est activé
- Seules les dépendances de `devDependencies` dans package.json sont signalées
- Les dépendances de production de `dependencies` sont autorisées
- Aide à prévenir les échecs d'exécution dans les builds de production

## Travailler avec Monorepo 🏗️

Rev-dep offre un support de première classe pour les projets monorepo, permettant une analyse précise des dépendances entre les paquets du workspace.

### Indicateur followMonorepoPackages

L'indicateur `--follow-monorepo-packages` permet de résoudre les imports depuis les paquets workspace du monorepo. Par défaut, cet indicateur est défini sur `false` pour maintenir la compatibilité avec les projets à paquet unique.```bash
# Enable monorepo package resolution
rev-dep circular --follow-monorepo-packages
rev-dep resolve --file src/utils.ts --follow-monorepo-packages
rev-dep entry-points --follow-monorepo-packages

Une fois activé, rev-dep va :

• Détecter automatiquement les paquets du workspace en recherchant la configuration monorepo
• Résoudre les imports entre les paquets du workspace
• Suivre les exports de package.json pour une résolution de module correcte

Prise en charge de la carte des exports

Rev-dep prend entièrement en charge le champ exports dans les fichiers package.json, qui est la méthode standard pour définir les points d'entrée des paquets dans les projets Node.js modernes.

La prise en charge de la carte des exports inclut :

• Exports conditionnels utilisant des conditions comme node, import, default et des conditions personnalisées
• Motifs génériques pour un mappage flexible des sous-chemins
• Sucre syntaxique pour les définitions d'export principal simples
• Conditions imbriquées pour des scénarios de résolution complexes

Indicateur des noms de conditions

Pour contrôler quels exports conditionnels sont résolus, utilisez le drapeau --condition-names. Cela vous permet de spécifier la priorité des conditions lors de la résolution des exports de paquets :```bash

Resolve exports for different environments

rev-dep circular --condition-names=node,import,default rev-dep resolve --file src/utils.ts --condition-names=import,node rev-dep entry-points --condition-names=default,node,import

Les conditions sont traitées dans l'ordre spécifié, la première condition correspondante étant utilisée. Les conditions courantes incluent :
- `node` - Environnement Node.js
- `import` - Modules ES
- `require` - CommonJS
- `default` - Condition de repli
- Conditions personnalisées spécifiques à votre projet ou à vos outils de build

Exemple de package.json avec exports :```json
{
  "name": "@myorg/utils",
  "exports": {
    ".": {
      "import": "./dist/index.mjs",
      "require": "./dist/index.js",
      "default": "./dist/index.js"
    },
    "./helpers": "./dist/helpers.js",
    "./types/*": "./dist/types/*.d.ts"
  }
}

Comment fonctionne la résolution des monorepos

1. Détection de monorepo : Lorsque followMonorepoPackages est activé, rev-dep recherche la configuration des espaces de travail (pnpm-workspace.yaml, workspaces de package.json, etc.)

2. Résolution des packages : Les imports vers les packages de l'espace de travail sont résolus à l'aide de la configuration des exports du package, avec repli sur les champs main/module lorsque les exports ne sont pas définis.

3. Validation des dépendances : L'outil vérifie que les imports inter-packages ne sont autorisés que lorsque le package cible est répertorié dans les dependencies ou devDependencies du consommateur.

4. Résolution des chemins : Tous les chemins sont résolus par rapport à la racine de leur package respectif, ce qui garantit un suivi précis des dépendances dans l'ensemble du monorepo.

Cela rend rev-dep particulièrement efficace pour les projets monorepo à grande échelle, où la compréhension des dépendances inter-packages est cruciale pour maintenir la qualité du code et l'architecture.

Comparaison des performances ⚡

Rev-dep peut effectuer plusieurs vérifications sur un monorepo de plus de 500k lignes de code avec plusieurs sous-packages en environ 150 ms.

Il surpasse Madge, dpdm, dependency-cruiser, skott, knip, depcheck et d'autres outils similaires.

Voici une comparaison des performances de tâches spécifiques entre rev-dep et les alternatives :

Plateforme : WSL Linux Debian Intel(R) Core(TM) i9-14900KF CPU

Mesures : hyperfine -w 4 -r 8 (4 essais de préchauffage + 8 exécutions mesurées)

Projet : 580k lignes de code, 6024 fichiers de code source d'une application next.js

Comparaison des performances de la vérification des dépendances circulaires

Le tableau ci-dessous présente une comparaison des performances de différents outils de détection des imports circulaires.

La vérification circulaire de rev-dep est ~20 fois plus rapide que l'alternative la plus rapide.

* knip ignore toujours les arêtes d'import de type uniquement et n'offre aucun drapeau pour les inclure. Chaque cycle de ce codebase en contient au moins un, donc knip rapporte 0 cycle - ses 3 040 ms sont une véritable analyse complète, mais d'un graphe plus petit. rev-dep circular -t, qui applique la même règle, concorde exactement (0 cycle) en 143.3 ms ± 10.3.

Plateforme : WSL Linux Debian Intel(R) Core(TM) i9-14900KF CPU

Mesures : hyperfine -w 4 -r 8 (4 essais de préchauffage + 8 exécutions mesurées)

Projet : 580k lignes de code, 6024 fichiers de code source d'une application next.js

Voir les mesures détaillées avec le temps moyen et les commandes utilisées dans PERFORMANCE.md.

Référence CLI 📖

rev-dep circular

Détecter les dépendances circulaires dans votre projet

Synopsis

Analyse le projet pour trouver les dépendances circulaires entre les modules. Les dépendances circulaires peuvent provoquer des problèmes difficiles à déboguer et devraient généralement être évitées.``` rev-dep circular [flags]

#### Exemples```
rev-dep circular --ignore-types-imports

Options```

  --condition-names strings                                     List of conditions for package.json imports resolution (e.g. node, imports, default)

-c, --cwd string Working directory for the command (default "$PWD") --follow-monorepo-packages strings Enable resolution of imports from monorepo workspace packages. Pass without value to follow all, or pass package names -h, --help help for circular -t, --ignore-type-imports Exclude type imports from the analysis --process-ignored-files strings Glob patterns to process even if they are ignored by gitignore or exclude patterns --tsconfig-json string Path to tsconfig.json (default: ./tsconfig.json) -v, --verbose Show warnings and verbose output

### rev-dep config

Créer et exécuter des fichiers de configuration rev-dep

#### Synopsis

Commandes pour créer et exécuter des fichiers de configuration rev-dep.

#### Options```
  -c, --cwd string   Working directory (default "$PWD")
  -h, --help         help for config

rev-dep config run

Exécute toutes les vérifications définies dans (.)rev-dep.config.json(c)

Synopsis

Traite le fichier (.)rev-dep.config.json(c) et exécute toutes les vérifications activées (imports circulaires, fichiers orphelins, limites de modules, conventions d'importation, modules Node, exports inutilisés, imports non résolus, imports restreints et utilisation restreinte des dépendances de développement) pour chaque espace de travail.``` rev-dep config run [flags]

#### Options```
  -c, --cwd string                  Working directory (default "$PWD")
      --fix                         Automatically fix fixable issues
      --format string               Output format (json, issues-list)
  -h, --help                        help for run
      --lint-config                 Also lint the config after running; prints only error/warning counts and fails (non-zero exit) on any lint error. Use 'config lint' for details and --fix
      --lint-config-rules strings   Which lint rules to run with --lint-config (comma-separated). Default: all. Implies --lint-config
      --list-all-issues             List all issues instead of limiting output
      --recheck                     Run all checks again after '--fix' to validate the final state
      --update-snapshot             Rewrite every configured duplicated-code snapshot from this run, acknowledging what it found.
  -v, --verbose                     Show warnings and verbose output
      --workspaces strings          Subset of workspaces to run (comma-separated list of workspace paths)

rev-dep config init

Initialiser un nouveau fichier rev-dep.config.json

Synopsis

Créer un nouveau fichier de configuration rev-dep.config.json dans le répertoire courant avec les paramètres par défaut.``` rev-dep config init [flags]

#### Options```
  -c, --cwd string   Working directory (default "$PWD")
  -h, --help         help for init

lint de configuration rev-dep

Signale (et éventuellement supprime) les motifs de glob/chemin de configuration qui ne correspondent à rien

Synopsis

Analyse un (.)rev-dep.config.json(c) pour détecter les motifs de glob et de chemin « morts » — motifs d'ignorance, motifs de points d'entrée, chemins d'espace de travail, exclusions du graphe, fichiers/modules refusés et similaires — qui ne correspondent plus à aucun fichier ou module découvert. Au fil du temps, les configurations accumulent des motifs pour des fichiers qui ont été renommés ou supprimés ; cette commande les fait remonter à la surface afin que la configuration reste épurée.

Avec --fix, les motifs morts sont supprimés sur place, en préservant tous les commentaires et le formatage. Certains motifs sont signalés mais jamais supprimés automatiquement, car leur suppression pourrait modifier le comportement d'un contrôle ou rendre la configuration invalide — chemins d'espace de travail, points d'entrée / fichiers / modules requis, et sélecteurs de frontières de modules. Ceux-ci sont marqués « non auto-supprimés » ; résolvez-les à la main.``` rev-dep config lint [flags]

#### Options```
  -c, --cwd string      Working directory (default "$PWD")
      --fix             Remove dead patterns from the config file (preserves comments and formatting)
  -h, --help            help for lint
      --rules strings   Lint rules to run (comma-separated): orphan-file-globs, orphan-module-globs, overlapping-globs, trailing-commas, compact. Default: all. orphan-file-globs/overlapping-globs use file discovery; orphan-module-globs parses the dependency tree; trailing-commas and compact only read the config file.
  -v, --verbose         Show warnings and verbose output

rev-dep config migrate

Mettre à niveau une configuration v2 vers le schéma v3 (2.0)

Synopsis

Mettre à niveau un (.)rev-dep.config.json(c) du schéma v2 vers v3 (version de configuration 2.0).

Il applique les modifications sûres et sans ambiguïté en place (renomme le tableau 'rules' de premier niveau en 'workspaces', fait passer 'configVersion' à 2.0, et supprime l'option abandonnée 'algorithm' des détecteurs d'importations circulaires), tout en préservant les commentaires et le formatage. Passez en revue la modification avec git avant de valider.

Il liste ensuite ce qu'il n'a PAS pu modifier pour vous : les motifs glob dont l'ensemble de correspondances peut avoir changé sous les règles plus strictes alignées sur gitignore de v3, ainsi que les changements de comportement qu'aucune modification de configuration ne peut corriger. Examinez-les manuellement - consultez le guide des changements cassants de v3.``` rev-dep config migrate [flags]

#### Options```
  -c, --cwd string   Working directory (default "$PWD")
  -h, --help         help for migrate

rev-dep debug

Outils de débogage pour inspecter les internes du parseur et du résolveur

Synopsis

Outils de débogage pour inspecter comment rev-dep analyse les fichiers et résout les dépendances. La sortie ne suit pas semver.

Options```

-h, --help help for debug

### rev-dep debug get-tree-for-cwd

Débogage : Afficher l'arbre de dépendances complet pour l'analyse

#### Synopsis

Outil de débogage pour inspecter l'arbre de dépendances complet. La sortie ne suit pas semver.```
rev-dep debug get-tree-for-cwd [flags]

Options```

  --condition-names strings                                     List of conditions for package.json imports resolution (e.g. node, imports, default)
  --cwd string                                                  Working directory for the command (default "$PWD")
  --follow-monorepo-packages strings                            Enable resolution of imports from monorepo workspace packages. Pass without value to follow all, or pass package names

-h, --help help for get-tree-for-cwd -t, --ignore-type-imports Exclude type imports from the analysis --include-dev-deps-from-root Treat the monorepo root package.json devDependencies as available to package code, so they are not reported as missing or unresolved. Mirrors config nodeModulesResolution.includeDevDepsFromRoot --node-modules-resolution string Which package.json each import is validated against: 'entry-package' (the cwd package.json, default) or 'nearest-package' (each file's own nearest package.json) (default "entry-package") --tsconfig-json string Path to tsconfig.json (default: ./tsconfig.json) -v, --verbose Show warnings and verbose output

### rev-dep debug list-cwd-files

Liste tous les fichiers dans le répertoire de travail courant

#### Synopsis

Liste récursivement tous les fichiers dans le répertoire spécifié,
avec des options pour filtrer les résultats.```
rev-dep debug list-cwd-files [flags]

Exemples```

rev-dep debug list-cwd-files --include='.ts' --exclude='.test.ts'

#### Options```
      --count             Only display the count of matching files
      --cwd string        Directory to list files from (default "$PWD")
      --exclude strings   Exclude files matching these glob patterns
  -h, --help              help for list-cwd-files
      --include strings   Only include files matching these glob patterns

rev-dep debug parse-file

Débogage : afficher les imports analysés pour un seul fichier

Synopsis

Outil de débogage pour inspecter comment l'analyseur traite un fichier spécifique. La sortie ne suit pas le semver.``` rev-dep debug parse-file [flags]

#### Options```
      --condition-names strings                                     List of conditions for package.json imports resolution (e.g. node, imports, default)
      --cwd string                                                  Working directory for the command (default "$PWD")
      --file string                                                 file to parse
      --follow-monorepo-packages strings                            Enable resolution of imports from monorepo workspace packages. Pass without value to follow all, or pass package names
  -h, --help                                                        help for parse-file
      --include-dev-deps-from-root                                  Treat the monorepo root package.json devDependencies as available to package code, so they are not reported as missing or unresolved. Mirrors config nodeModulesResolution.includeDevDepsFromRoot
      --node-modules-resolution string                              Which package.json each import is validated against: 'entry-package' (the cwd package.json, default) or 'nearest-package' (each file's own nearest package.json) (default "entry-package")
      --tsconfig-json string                                        Path to tsconfig.json (default: ./tsconfig.json)
  -v, --verbose                                                     Show warnings and verbose output

rev-dep debug parse-tsconfig

Débogage : affiche les alias de configuration TypeScript analysés

Synopsis

Outil de débogage permettant d'inspecter la manière dont la configuration TypeScript est analysée et quels alias sont extraits. La sortie ne suit pas la sémantique versionnelle (semver).``` rev-dep debug parse-tsconfig [flags]

#### Options```
  -h, --help              help for parse-tsconfig
      --tsconfig string   Path to TypeScript configuration file

rev-dep duplicated-code

Détecte le code dupliqué parmi (et dans) les fichiers du projet

Résumé

Analyse chaque fichier source à la recherche de fragments copiables - blocs entre accolades et éléments JSX, à tous les niveaux d'imbrication - et signale ceux qui apparaissent plus d'une fois.

La comparaison ignore entièrement la mise en forme et les commentaires, donc les copies ré-indentées correspondent toujours.

Quatre filtres déterminent ce qui mérite d'être signalé. --min-tokens et --min-lines mesurent la taille; --min-depth et --min-statements mesurent la complexité, ce qui distingue un objet de configuration dupliqué à trois clés d'une logique dupliquée - aucun seuil de taille ne peut le faire, car les clés et les valeurs de chaîne de l'objet peuvent être longues. --min-duplicates définit le nombre de copies nécessaire pour être signalé.

Par défaut, le code doit correspondre tel qu'il est écrit. Chaque option --blind-* retire une catégorie de jetons de la comparaison, et elles se combinent librement :

--blind-identifiers les noms sont des jokers, donc une copie dont les variables, fonctions ou composants ont été renommés est toujours signalée --blind-strings les contenus de chaînes et de templates sont des jokers --blind-numbers les littéraux numériques sont des jokers``` rev-dep duplicated-code [flags]

#### Exemples```
rev-dep duplicated-code --cwd ./src --blind-identifiers

Options```

  --blind-identifiers               Ignore the spelling of names, so a copy whose variables, functions or components were renamed still counts as duplication.
  --blind-numbers                   Ignore the value of numeric literals, so a copy with different constants still counts
  --blind-strings                   Ignore the text of string and template literals, so a copy with different messages or keys still counts

-c, --cwd string Working directory for the command (default "$PWD") -f, --format string Output format: "human" or "json". JSON reports every finding with its canonical hash and the byte and line range of each occurrence, for comparing against another run or another tool (default "human") -h, --help help for duplicated-code --ignore-files strings Glob patterns of files to leave out of the analysis. --json-snippets Include the source of each finding in JSON output. Off by default because snippets dominate the file size and a comparison keyed on ranges does not need them --min-depth int Smallest duplication to report, in nesting levels counting the block itself. 1 admits everything; 2 requires at least one nested level, which is what filters out flat objects and single JSX elements however long their keys or strings are --min-duplicates int How many copies a chunk needs before it is reported. Raise to 3 to ignore code that has only been copied once (default 2) --min-lines int Smallest duplication to report, in lines of the first occurrence (default 3) --min-statements int Smallest duplication to report, in statements directly inside the block. Applies only to statement blocks (function and control-flow bodies); object literals and JSX elements are expressions and are not filtered by it - use --min-depth for those --min-tokens int Smallest duplication to report, in tokens. Tokens rather than characters because the count does not change when a --blind-* flag is applied, so one number means the same amount of code whatever is being ignored (default 50) --process-ignored-files strings Glob patterns to analyse even when gitignore excludes them. --skip-objects Do not report duplications that are only object literals. --snapshot string Path to a JSON snapshot of acknowledged duplications. With it, the command reports what changed since the snapshot instead of everything that exists, and exits non-zero on any difference --update-snapshot Rewrite the --snapshot file from this run, acknowledging everything it found. Always explicit: nothing updates a snapshot on its own

### rev-dep entry-points

Découvrez et listez tous les points d'entrée du projet

#### Synopsis

Analyse la structure du projet pour identifier tous les points d'entrée potentiels.
Utile pour comprendre l'architecture et les dépendances de votre application.```
rev-dep entry-points [flags]

Exemples```

rev-dep entry-points --print-deps-count

#### Options```
      --condition-names strings                                     List of conditions for package.json imports resolution (e.g. node, imports, default)
  -n, --count                                                       Only display the number of entry points found
  -c, --cwd string                                                  Working directory for the command (default "$PWD")
      --follow-monorepo-packages strings                            Enable resolution of imports from monorepo workspace packages. Pass without value to follow all, or pass package names
      --graph-exclude strings                                       Exclude files matching these glob patterns from analysis
  -h, --help                                                        help for entry-points
  -t, --ignore-type-imports                                         Exclude type imports from the analysis
      --print-deps-count                                            Show the number of dependencies for each entry point
      --process-ignored-files strings                               Glob patterns to process even if they are ignored by gitignore or exclude patterns
      --result-exclude strings                                      Exclude files matching these glob patterns from results
      --result-include strings                                      Only include files matching these glob patterns in results
      --tsconfig-json string                                        Path to tsconfig.json (default: ./tsconfig.json)
  -v, --verbose                                                     Show warnings and verbose output

rev-dep files

Liste tous les fichiers dans l'arbre de dépendances d'un point d'entrée

Synopsis

Recherche et liste récursivement tous les fichiers requis par le point d'entrée spécifié.``` rev-dep files [flags]

#### Exemples```
rev-dep files --entry-point src/index.ts

Options```

  --condition-names strings                                     List of conditions for package.json imports resolution (e.g. node, imports, default)

-n, --count Only display the count of files in the dependency tree -c, --cwd string Working directory for the command (default "$PWD") -p, --entry-point string Entry point file to analyze (required) --follow-monorepo-packages strings Enable resolution of imports from monorepo workspace packages. Pass without value to follow all, or pass package names -h, --help help for files -t, --ignore-type-imports Exclude type imports from the analysis --process-ignored-files strings Glob patterns to process even if they are ignored by gitignore or exclude patterns --tsconfig-json string Path to tsconfig.json (default: ./tsconfig.json) -v, --verbose Show warnings and verbose output

### rev-dep imported-by

Liste tous les fichiers qui importent directement le fichier spécifié

#### Synopsis

Recherche et liste tous les fichiers du projet qui importent directement le fichier spécifié.
Ceci est utile pour comprendre l'impact des modifications apportées à un fichier particulier.```
rev-dep imported-by [flags]

Exemples```

rev-dep imported-by --file src/utils/helpers.ts

#### Options```
      --condition-names strings                                     List of conditions for package.json imports resolution (e.g. node, imports, default)
  -n, --count                                                       Only display the count of importing files
  -c, --cwd string                                                  Working directory for the command (default "$PWD")
  -f, --file string                                                 Target file to find importers for (required)
      --follow-monorepo-packages strings                            Enable resolution of imports from monorepo workspace packages. Pass without value to follow all, or pass package names
  -h, --help                                                        help for imported-by
      --list-imports                                                List the import identifiers used by each file
      --process-ignored-files strings                               Glob patterns to process even if they are ignored by gitignore or exclude patterns
      --tsconfig-json string                                        Path to tsconfig.json (default: ./tsconfig.json)
  -v, --verbose                                                     Show warnings and verbose output

rev-dep lines-of-code

Compte les lignes de code réelles du projet, en excluant les commentaires et les lignes vides.``` rev-dep lines-of-code [flags]

#### Exemples```
rev-dep lines-of-code

Options```

-c, --cwd string Directory to analyze (default "$PWD") -h, --help help for lines-of-code

### rev-dep list-cwd-files

Liste tous les fichiers du répertoire de travail actuel

#### Synopsis

Liste récursivement tous les fichiers du répertoire spécifié,
avec des options pour filtrer les résultats.```
rev-dep list-cwd-files [flags]

Exemples```

rev-dep list-cwd-files --include='.ts' --exclude='.test.ts'

#### Options```
      --count             Only display the count of matching files
      --cwd string        Directory to list files from (default "$PWD")
      --exclude strings   Exclude files matching these glob patterns
  -h, --help              help for list-cwd-files
      --include strings   Only include files matching these glob patterns

rev-dep unresolved

Liste les imports non résolus dans le projet

Synopsis

Détecte et liste les imports qui n'ont pas pu être résolus lors de la résolution des imports. Regroupe les imports par fichier.``` rev-dep unresolved [flags]

#### Options```
      --condition-names strings                                     List of conditions for package.json imports resolution (e.g. node, imports, default)
      --custom-asset-extensions strings                             Additional asset extensions treated as resolvable (e.g. glb,mp3)
  -c, --cwd string                                                  Working directory for the command (default "$PWD")
      --follow-monorepo-packages strings                            Enable resolution of imports from monorepo workspace packages. Pass without value to follow all, or pass package names
  -h, --help                                                        help for unresolved
      --ignore stringToString                                       Map of file path (relative to cwd) to exact import request to ignore (e.g. --ignore src/index.ts=some-module) (default [])
      --ignore-files strings                                        File path glob patterns to ignore in unresolved output
      --ignore-imports strings                                      Import requests to ignore globally in unresolved output
      --include-dev-deps-from-root                                  Treat the monorepo root package.json devDependencies as available to package code, so they are not reported as missing or unresolved. Mirrors config nodeModulesResolution.includeDevDepsFromRoot
      --node-modules-resolution string                              Which package.json each import is validated against: 'entry-package' (the cwd package.json, default) or 'nearest-package' (each file's own nearest package.json) (default "entry-package")
      --process-ignored-files strings                               Glob patterns to process even if they are ignored by gitignore or exclude patterns
      --tsconfig-json string                                        Path to tsconfig.json (default: ./tsconfig.json)
  -v, --verbose                                                     Show warnings and verbose output

rev-dep node-modules

Analyser et gérer les dépendances Node.js

Synopsis

Outils pour analyser et gérer les dépendances des modules Node.js. Aide à identifier les dépendances inutilisées, manquantes ou dupliquées dans votre projet.

Exemples```

rev-dep node-modules used -p src/index.ts rev-dep node-modules unused --exclude-modules=@types/* rev-dep node-modules missing --entry-points=src/main.ts

#### Options```
  -h, --help   help for node-modules

rev-dep node-modules analyze-size

Analyse l'utilisation disque de node_modules

Synopsis

Fournit une analyse détaillée de la taille du répertoire node_modules. Aide à identifier les dépendances les plus gourmandes en espace.``` rev-dep node-modules analyze-size [flags]

#### Exemples```
rev-dep node-modules analyze-size

Options```

-c, --cwd string Working directory for the command (default "$PWD") -h, --help help for analyze-size

### rev-dep node-modules dirs-size

Calcule la taille cumulée des fichiers dans les répertoires node_modules

#### Synopsis

Calcule et affiche la taille des dossiers node_modules
dans le répertoire courant et ses sous-répertoires. Les tailles seront inférieures à la taille réelle occupée sur le disque. L'outil calcule la taille réelle des fichiers plutôt que la taille sur le disque (liée à l'utilisation des blocs disque)```
rev-dep node-modules dirs-size [flags]

Exemples```

rev-dep node-modules dirs-size

#### Options```
  -c, --cwd string   Working directory for the command (default "$PWD")
  -h, --help         help for dirs-size

rev-dep node-modules installed-duplicates

Trouver et optimiser les installations de paquets en double

Synopsis

Identifie les paquets installés plusieurs fois dans node_modules. Peut optimiser le stockage en créant des liens symboliques entre les paquets en double.``` rev-dep node-modules installed-duplicates [flags]

#### Exemples```
rev-dep node-modules installed-duplicates --optimize --size-stats

Options```

-c, --cwd string Working directory for the command (default "$PWD") -h, --help help for installed-duplicates --isolate Create symlinks only within the same top-level node_module directories. By default optimize creates symlinks between top-level node_module directories (eg. when workspaces are used). Needs --optimize flag to take effect --optimize Automatically create symlinks to deduplicate packages --size-stats Print node modules dirs size before and after optimization. Might take longer than optimization itself --verbose Show detailed information about each optimization

### rev-dep node-modules installés

Lister tous les packages npm installés dans le projet

#### Synopsis

Analyse récursivement les répertoires node_modules pour lister tous les packages installés.
Utile pour auditer les dépendances dans les monorepos.```
rev-dep node-modules installed [flags]

Exemples```

rev-dep node-modules installed --include-modules=@myorg/*

#### Options```
  -c, --cwd string                Working directory for the command (default "$PWD")
  -e, --exclude-modules strings   list of modules to exclude from the output
  -h, --help                      help for installed
  -i, --include-modules strings   list of modules to include in the output

rev-dep node-modules missing

Find imported packages not listed in package.json

Synopsis

Identifies packages that are imported in your code but not declared in your package.json dependencies.``` rev-dep node-modules missing [flags]

#### Exemples```
rev-dep node-modules missing --entry-points=src/main.ts

Options```

  --condition-names strings                                     List of conditions for package.json imports resolution (e.g. node, imports, default)

-n, --count Only display the count of modules -c, --cwd string Working directory for the command (default "$PWD") -p, --entry-points strings Entry point file(s) to start analysis from (default: auto-detected) -e, --exclude-modules strings list of modules to exclude from the output -b, --files-with-binaries strings Additional files to search for binary usages. Use paths relative to cwd -m, --files-with-node-modules strings Additional files to search for module imports. Use paths relative to cwd --follow-monorepo-packages strings Enable resolution of imports from monorepo workspace packages. Pass without value to follow all, or pass package names --group-by-file Organize output by project file path --group-by-module Organize output by npm package name --group-by-module-files-count Organize output by npm package name and show count of files using it -h, --help help for missing -t, --ignore-type-imports Exclude type imports from the analysis --include-dev-deps-from-root Treat the monorepo root package.json devDependencies as available to package code, so they are not reported as missing or unresolved. Mirrors config nodeModulesResolution.includeDevDepsFromRoot -i, --include-modules strings list of modules to include in the output --node-modules-resolution string Which package.json each import is validated against: 'entry-package' (the cwd package.json, default) or 'nearest-package' (each file's own nearest package.json) (default "entry-package") --pkg-fields-with-binaries strings Additional package.json fields to check for binary usages --tsconfig-json string Path to tsconfig.json (default: ./tsconfig.json) -v, --verbose Show warnings and verbose output --zero-exit-code Use this flag to always return zero exit code

### rev-dep node-modules prune-docs

Supprime les fichiers de type markdown/docs des paquets node_modules installés

#### Synopsis

Supprime les fichiers des paquets node_modules installés en fonction de motifs glob.
Utile pour élaguer les fichiers README/LICENSE/docs afin de réduire la taille des dépendances.```
rev-dep node-modules prune-docs [flags]

Exemples```

rev-dep node-modules prune-docs --defaults rev-dep node-modules prune-docs --patterns ".md,README.md,docs/**" rev-dep node-modules prune-docs --defaults --patterns ".txt"

#### Options```
  -c, --cwd string         Working directory for the command (default "$PWD")
      --defaults           Use default prune patterns: LICENSE, README.md, docs/**
  -h, --help               help for prune-docs
      --pattern strings    Alias for --patterns
  -p, --patterns strings   Glob patterns (relative to each package root) of files to remove, e.g. "*.md,README.md,docs/**"

rev-dep node-modules inutilisés

Trouvez les paquets installés qui ne sont pas importés dans votre code

Synopsis

Compare les dépendances package.json avec les importations réelles dans votre codebase pour identifier les paquets potentiellement inutilisés.``` rev-dep node-modules unused [flags]

#### Exemples```
rev-dep node-modules unused --exclude-modules=@types/*

Options```

  --condition-names strings                                     List of conditions for package.json imports resolution (e.g. node, imports, default)

-n, --count Only display the count of modules -c, --cwd string Working directory for the command (default "$PWD") -p, --entry-points strings Entry point file(s) to start analysis from (default: auto-detected) -e, --exclude-modules strings list of modules to exclude from the output -b, --files-with-binaries strings Additional files to search for binary usages. Use paths relative to cwd -m, --files-with-node-modules strings Additional files to search for module imports. Use paths relative to cwd --follow-monorepo-packages strings Enable resolution of imports from monorepo workspace packages. Pass without value to follow all, or pass package names -h, --help help for unused -t, --ignore-type-imports Exclude type imports from the analysis --include-dev-deps-from-root Treat the monorepo root package.json devDependencies as available to package code, so they are not reported as missing or unresolved. Mirrors config nodeModulesResolution.includeDevDepsFromRoot -i, --include-modules strings list of modules to include in the output --node-modules-resolution string Which package.json each import is validated against: 'entry-package' (the cwd package.json, default) or 'nearest-package' (each file's own nearest package.json) (default "entry-package") --pkg-fields-with-binaries strings Additional package.json fields to check for binary usages --tsconfig-json string Path to tsconfig.json (default: ./tsconfig.json) -v, --verbose Show warnings and verbose output --zero-exit-code Use this flag to always return zero exit code

### rev-dep node-modules utilisés

Liste tous les packages npm importés dans votre code

#### Synopsis

Analyse votre code pour identifier quels packages npm sont réellement utilisés.
Aide à suivre les dépendances d'exécution de votre projet.```
rev-dep node-modules used [flags]

Exemples```

rev-dep node-modules used -p src/index.ts --group-by-module

#### Options```
      --condition-names strings                                     List of conditions for package.json imports resolution (e.g. node, imports, default)
  -n, --count                                                       Only display the count of modules
  -c, --cwd string                                                  Working directory for the command (default "$PWD")
  -p, --entry-points strings                                        Entry point file(s) to start analysis from (default: auto-detected)
  -e, --exclude-modules strings                                     list of modules to exclude from the output
  -b, --files-with-binaries strings                                 Additional files to search for binary usages. Use paths relative to cwd
  -m, --files-with-node-modules strings                             Additional files to search for module imports. Use paths relative to cwd
      --follow-monorepo-packages strings                            Enable resolution of imports from monorepo workspace packages. Pass without value to follow all, or pass package names
      --group-by-entry-point                                        Organize output by entry point file path
      --group-by-entry-point-modules-count                          Organize output by entry point and show count of unique modules
      --group-by-file                                               Organize output by project file path
      --group-by-module                                             Organize output by npm package name
      --group-by-module-entry-points-count                          Organize output by npm package name and show count of entry points using it
      --group-by-module-files-count                                 Organize output by npm package name and show count of files using it
      --group-by-module-show-entry-points                           Organize output by npm package name and list entry points using it
  -h, --help                                                        help for used
  -t, --ignore-type-imports                                         Exclude type imports from the analysis
      --include-dev-deps-from-root                                  Treat the monorepo root package.json devDependencies as available to package code, so they are not reported as missing or unresolved. Mirrors config nodeModulesResolution.includeDevDepsFromRoot
  -i, --include-modules strings                                     list of modules to include in the output
      --node-modules-resolution string                              Which package.json each import is validated against: 'entry-package' (the cwd package.json, default) or 'nearest-package' (each file's own nearest package.json) (default "entry-package")
      --pkg-fields-with-binaries strings                            Additional package.json fields to check for binary usages
      --tsconfig-json string                                        Path to tsconfig.json (default: ./tsconfig.json)
  -v, --verbose                                                     Show warnings and verbose output

rev-dep resolve

Tracer et afficher le chemin de dépendance entre les fichiers de votre projet

Synopsis

Analyser et afficher la chaîne de dépendance entre les fichiers spécifiés. Aide à comprendre comment les différentes parties de votre base de code sont connectées.``` rev-dep resolve [flags]

#### Exemples```
rev-dep resolve -p src/index.ts -f src/utils/helpers.ts

Options```

-a, --all Show all possible resolution paths, not just the first one --compact-summary Display a compact summary of found paths --condition-names strings List of conditions for package.json imports resolution (e.g. node, imports, default) -c, --cwd string Working directory for the command (default "$PWD") -p, --entry-points strings Entry point file(s) or glob pattern(s) to start analysis from (default: auto-detected) -f, --file string Target file to check for dependencies --follow-monorepo-packages strings Enable resolution of imports from monorepo workspace packages. Pass without value to follow all, or pass package names --graph-exclude strings Glob patterns to exclude files from dependency analysis -h, --help help for resolve -t, --ignore-type-imports Exclude type imports from the analysis --include-dev-deps-from-root Treat the monorepo root package.json devDependencies as available to package code, so they are not reported as missing or unresolved. Mirrors config nodeModulesResolution.includeDevDepsFromRoot --module string Target node module name to check for dependencies --node-modules-resolution string Which package.json each import is validated against: 'entry-package' (the cwd package.json, default) or 'nearest-package' (each file's own nearest package.json) (default "entry-package") --process-ignored-files strings Glob patterns to process even if they are ignored by gitignore or exclude patterns --tsconfig-json string Path to tsconfig.json (default: ./tsconfig.json) -v, --verbose Show warnings and verbose output

<!-- cli-docs-end -->


## Glossaire 📚

Certains termes utilisés dans le domaine couvert par **rev-dep** peuvent prêter à confusion.
Voici un petit glossaire pour vous aider à naviguer parmi ces concepts.

### Dépendance

Une *dépendance* peut être comprise au sens littéral. Dans le contexte du graphe de dépendances d’un projet, elle peut désigner :

* un **module / paquet node** (un paquet est une dépendance d’un projet ou d’un fichier), ou
* un **fichier de code source** (un fichier est une dépendance d’un autre fichier s’il l’importe).

### Point d’entrée

Un *point d’entrée* est un fichier source qui **n’est importé par aucun autre fichier**.
Il peut représenter :

* l’entrée principale de l’application
* une page ou une fonctionnalité individuelle
* des fichiers de bootstrap de configuration ou de tests

- selon la structure du projet.

### Fichier inutilisé / fichier mort

Un fichier est considéré comme *inutilisé* ou *mort* lorsque :

* c’est un **point d’entrée** (rien ne l’importe), **et**
* son exécution ne **produit aucune sortie ou effet de bord significatif**.

En pratique, ces fichiers peuvent souvent être supprimés sans risque.

### Dépendance circulaire

Une *dépendance circulaire* se produit lorsqu’un fichier **s’importe directement ou indirectement lui-même** via une chaîne d’imports.

Cela peut entraîner un comportement d’exécution imprévisible, des valeurs non initialisées ou des bogues subtils.
Cependant, les dépendances circulaires entre **imports de types TypeScript uniquement** sont généralement inoffensives.

### Dépendance inverse (ou « dependents »)

Les fichiers qui *importent* un fichier donné.
Utile pour répondre à la question : « Qu’est-ce qui casse si je modifie ou supprime ce fichier ? »

### Graphe d’imports / graphe de dépendances

Une représentation visuelle de la manière dont les fichiers ou modules s’importent mutuellement.

### Dépendance manquante / module node inutilisé

Un module que votre code importe mais qui **n’est pas répertorié dans package.json**.

### Dépendance inutilisée / module node inutilisé

Une dépendance répertoriée dans **package.json** mais qui **n’est jamais importée** dans le code source.

### Répertoire racine / racine du projet

Le répertoire de premier niveau utilisé comme point de départ pour l’analyse des dépendances.

## Télémétrie

Rev-Dep collecte un unique événement **anonyme**, uniquement lors de l’exécution de `rev-dep config run`. En savoir plus dans la [documentation Télémétrie](https://rev-dep.com/docs/telemetry).

Pour vous désinscrire complètement, définissez `REV_DEP_TELEMETRY_OFF=true`.

## Fabriqué en 🇵🇱 et 🇯🇵 avec 🧠 par [@jayu](https://github.com/jayu)

J’espère que ce petit logiciel vous aidera à découvrir et à comprendre la complexité de votre projet, et donc à vous sentir plus confiant lors du refactoring. Si cet outil vous a été utile, n’hésitez pas à lui donner une ⭐ !

### Mes autres projets

- [CodeQue - Recherche de code structurelle](https://codeque.co)
- [Recherche de code structurelle VSCode](https://marketplace.visualstudio.com/items?itemName=CodeQue.codeque)