Rev-dep

Funktionen • Installation • Dokumentation • Explorations-Toolkit • CLI-Referenz

Toolkit zur Abhängigkeitsanalyse und -optimierung für moderne JavaScript- und TypeScript-Codebasen.
Setzen Sie die Hygiene des Abhängigkeitsgraphen durch und entfernen Sie ungenutzten Code mit einer sehr schnellen CLI.

Rev-dep-CLI-Ausgabe bei Konfigurationsausführung

rev-dep version rev-dep license

Über 📣

Wenn Codebasen wachsen, wird es unmöglich, eine mentale Karte der Abhängigkeiten zu pflegen. Rev-dep ist ein Hochgeschwindigkeits-Tool für statische Analysen, das die Architekturintegrität und Abhängigkeitshygiene in großen JS/TS-Projekten durchsetzt.

Betrachten Sie Rev-dep als einen Hochgeschwindigkeits-Linter für Ihren Abhängigkeitsgraphen.

Bündeln Sie fragmentierte, sequenzielle Prüfungen mehrerer langsamer Tools zu einer einzigen Hochleistungs-Engine. Rev-dep führt eine vollständige Suite von Governance-Prüfungen aus - einschließlich Zirkularität, verwaisten Dateien, Modulgrenzen und mehr - in einem einzigen parallelisierten Durchlauf. Rev-dep ist in Go implementiert, um die Leistungsengpässe der Node-basierten Analyse zu umgehen, und kann ein 500k+ LoC-Projekt in etwa 150 ms prüfen. Siehe den Leistungsvergleich

Automatisierte Codebase-Governance

Rev-dep geht über das passive Scannen hinaus zur aktiven Durchsetzung und beantwortet die schwierigen Fragen (und lässt CI daran scheitern):

Architekturintegrität: "Importiert meine 'Domain A' unerlaubt aus 'Domain B'?"
Toter Code & Ballast: "Sind diese Dateien unerreichbar, oder sind diese node_modules ungenutzt?"
Refactoring-Sicherheit: "Welche Einstiegspunkte verwenden dieses Hilfsmittel tatsächlich, und gibt es zirkuläre Ketten?"
Workspace-Hygiene: "Sind meine Importe konsistent und sind alle Abhängigkeiten deklariert?"

Rev-dep dient als Hochgeschwindigkeits-Gatekeeper für Ihre CI und stellt sicher, dass Ihr Abhängigkeitsgraph schlank bleibt und Ihre Architektur während der Iteration intakt bleibt.

Warum Rev-dep? 🤔

🏗️ Monorepo-Unterstützung erster Klasse

Entwickelt für moderne Workspaces (pnpm, yarn, npm). Rev-dep löst nativ package.json-exports/imports-Zuordnungen und TypeScript-Aliase auf und verfolgt Abhängigkeiten über Paketgrenzen hinweg.

🛡️ Konfigurationsbasierte Codebase-Governance

Gehen Sie über das passive Scannen hinaus. Nutzen Sie die Konfigurations-Engine, um Modulgrenzen und Importkonventionen durchzusetzen. Führen Sie eine vollständige Suite von Hygiene-Prüfungen (Zirkularität, verwaiste Dateien, ungenutzte Module und mehr) in einem einzigen, parallelisierten Durchlauf aus, der als Hochgeschwindigkeits-Gatekeeper für Ihre CI dient.

🔍 Explorations-Toolkit

CLI-Toolkit, das beim Debuggen von Problemen mit Abhängigkeiten zwischen Dateien hilft. Verstehen Sie transitive Beziehungen zwischen Dateien und beheben Sie Probleme.

⚡ Entwickelt für Geschwindigkeit und CI-Effizienz

In Go implementiert, um den Leistungsaufwand der Node-basierten Analyse zu eliminieren. Durch die parallele Verarbeitung von Dateien bietet Rev-dep eine 17x-90x schnellere Ausführung als Alternativen und reduziert so CI-Kosten und Entwickler-Wartezeiten erheblich.

Rev-dep kann ein 500k+ LoC-Projekt in etwa 150 ms prüfen. Siehe den Leistungsvergleich

Funktionen 🚀

Governance und Wartung (konfigurationsbasiert) 🛡️

Verwenden Sie rev-dep config run, um mehrere Prüfungen in einem Durchlauf für alle Pakete auszuführen.

Verfügbare Prüfungen:

moduleBoundaries - Architekturgrenzen zwischen Modulen durchsetzen.
importConventions - Importstil-Konventionen durchsetzen (bietet Autofix).
unusedExportsDetection - Exporte erkennen, die nie verwendet werden (bietet Autofix).
orphanFilesDetection - tote/verwaiste Dateien erkennen (bietet Autofix).
unusedNodeModulesDetection - deklarierte, aber nicht verwendete Abhängigkeiten erkennen.
missingNodeModulesDetection - Importe erkennen, die in der package json fehlen.
unresolvedImportsDetection - nicht aufgelöste Importanfragen erkennen.
circularImportsDetection - zirkuläre Importe erkennen.
duplicatedCodeDetection - kopierten Code erkennen (wiederholte Blöcke und JSX-Elemente).
devDepsUsageOnProdDetection - Dev-Abhängigkeiten erkennen, die im Produktionscode verwendet werden.
restrictedImportsDetection - das Importieren verbotener Dateien/Module aus ausgewählten Einstiegspunkten blockieren.
restrictedImportersDetection - festlegen, welche Einstiegspunkte eine Reihe von Dateien/Modulen transitiv erreichen dürfen.
restrictedDirectImportersDetection - einschränken, welche Dateien eine Reihe von Dateien/Modulen direkt importieren dürfen (nicht transitiv).

Explorative Analyse (CLI-basiert) 🔍

Verwenden Sie CLI-Befehle für die Ad-hoc-Erkundung von Abhängigkeiten:

entry-points - Einstiegspunkte des Projekts ermitteln.
files - Dateien des Abhängigkeitsbaums für einen bestimmten Einstiegspunkt auflisten.
resolve - Abhängigkeitspfade zwischen Dateien verfolgen (wer importiert diese Datei).
imported-by - direkte Importeure einer Datei auflisten.
circular - zirkuläre Abhängigkeitsketten auflisten.
duplicated-code - kopierte Code-Blöcke und JSX-Elemente finden.
node-modules - used, unused, missing und installed Node-Module untersuchen.
lines-of-code - effektive LOC zählen.
unresolved - Importe, die nicht aufgelöst werden konnten, nach Datei gruppiert auflisten.
list-cwd-files - alle Quelldateien im aktuellen Arbeitsverzeichnis (CWD) auflisten.
debug - untersuchen, was rev-dep intern parst, auflöst und erkennt.

Installation 📦

Vollständige Dokumentation: rev-dep.com/docs/intro

Lokal installieren, um Projekt-Prüfskripte einzurichten``` yarn add -D rev-dep

I received no translatable content in this request — the `INPUT:` section is empty. Please provide the actual chunk text so I can translate it.```
npm install -D rev-dep

Umgebungsvariablen

Das Tool lädt automatisch eine .env-Datei aus dem aktuellen Verzeichnis. Diese Datei enthält Konfigurationen für Proxy-Einstellungen und die maximale Anzahl gleichzeitiger Anfragen.

Sie können diese auch als tatsächliche Umgebungsvariablen setzen, wenn Sie dies bevorzugen. Die unterstützten Umgebungsvariablen sind:

PROXY_HOST (Standard: leer) – Hostname oder IP-Adresse des Proxyservers
PROXY_PORT (Standard: leer) – Portnummer des Proxyservers
MAX_CONCURRENT_REQUESTS (Standard: 50) – Maximale Anzahl gleichzeitiger HTTP-Anfragen

Ratenbegrenzung & Leistung

Das Tool verfügt über eine integrierte Ratenbegrenzung, um eine Überlastung der Shodan-API zu vermeiden. Die standardmäßige Parallelität von 50 gleichzeitigen Anfragen bewegt sich in der Regel gut innerhalb der Ratenlimits von Shodan.

Wenn Sie auf Fehler durch Ratenbegrenzung stoßen, können Sie die Parallelität in Ihrer .env-Datei reduzieren:``` pnpm add -D rev-dep

Erstellen Sie eine Konfigurationsdatei für einen Schnellstart:```
npx rev-dep config init

Global installieren, um es als CLI-Tool zu verwenden:``` yarn global add rev-dep

- `--stop` : Beende einen Dienst (Es gibt auch ein eigenes Skript, um den Gerätestatus zu überprüfen, sodass der Benutzer erkennen kann, ob der Dienst läuft oder gestoppt ist).```
npm install -g rev-dep

Vollständig verschleiert (Sie können Cross-Build-Injection und CombineObfuscation verwenden)``` pnpm global add rev-dep

### Schritt-für-Schritt-Integrationsanleitungen

Folgen Sie dem Leitfaden, der zu Ihrem Projekt passt, um von null zu einer funktionierenden Einrichtung zu gelangen:

- [Monorepo-Integrationsanleitung](https://rev-dep.com/docs/monorepo-integration-guide) - für `pnpm`/`yarn`/`npm`-Workspaces.
- [Single-Workspace-Integrationsanleitung](https://rev-dep.com/docs/single-workspace-integration-guide) - für Projekte mit einem einzigen Paket.

## **Schnelle Beispiele 💡**

Ein paar sofort nutzbare Beispiele, um ein Gefühl für das Tool zu bekommen:```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

Config-basierte Prüfungen 🛡️

Rev-dep bietet ein Konfigurationssystem zum Orchestrieren von Projektprüfungen. Der Konfigurationsansatz ist auf Geschwindigkeit ausgelegt und der bevorzugte Weg zur Implementierung von Projektprüfungen, da er alle Prüfungen in einem einzigen Durchlauf ausführen kann, was deutlich schneller ist als das separate Ausführen mehrerer einzelner Befehle.

Verfügbare Prüfungen sind:

moduleBoundaries - Architekturgrenzen zwischen Modulen durchsetzen.
importConventions - Importstil-Konventionen durchsetzen (bietet Autofix).
unusedExportsDetection - Exporte erkennen, die nie verwendet werden (bietet Autofix).
orphanFilesDetection - tote/verwaiste Dateien erkennen (bietet Autofix).
unusedNodeModulesDetection - deklarierte, aber nicht verwendete Abhängigkeiten erkennen.
missingNodeModulesDetection - Importe erkennen, die in der package.json fehlen.
unresolvedImportsDetection - unaufgelöste Importanfragen erkennen.
circularImportsDetection - zirkuläre Importe erkennen.
duplicatedCodeDetection - kopierte Codeblöcke und JSX-Elemente erkennen.
devDepsUsageOnProdDetection - Entwicklungsabhängigkeiten erkennen, die im Produktionscode verwendet werden.
restrictedImportsDetection - das Importieren verbotener Dateien/Module aus ausgewählten Einstiegspunkten blockieren.
restrictedImportersDetection - per Whitelist festlegen, welche Einstiegspunkte transitiv eine Reihe von Dateien/Modulen erreichen dürfen.
restrictedDirectImportersDetection - einschränken, welche Dateien direkt eine Reihe von Dateien/Modulen importieren dürfen (nicht transitiv).

Prüfungen sind in Workspaces gruppiert. Sie können mehrere Workspaces haben, z. B. für jedes Monorepo-Paket.

Erste Schritte

Initialisieren Sie eine Konfigurationsdatei in Ihrem Projekt:```bash

Create a default configuration file

rev-dep config init

Verhalten von `rev-dep config init`:

- Monorepo-Wurzel: Die Ausführung von `rev-dep config init` im Workspace-Wurzelverzeichnis erstellt einen Root-Workspace und einen Workspace für jedes erkannte Workspace-Paket.
- Monorepo-Workspace-Paket oder reguläre Projekte: Die Ausführung von `rev-dep config init` innerhalb eines Verzeichnisses erstellt eine Konfiguration mit einem einzelnen Workspace mit `path: "."` für dieses Verzeichnis.

Alle konfigurierten Prüfungen ausführen (Probelauf, noch keine Korrekturen angewendet):```bash
# Execute all workspaces and checks defined in the config
rev-dep config run

Alle erkannten Probleme auflisten:```bash

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

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

Behebe alle behebbaren Prüfungen:```bash
# Fix checks configured with autofix
rev-dep config run --fix

Konfigurationsstruktur

Die Konfigurationsdatei (rev-dep.config.json(c) oder .rev-dep.config.json(c)) ermöglicht es Ihnen, mehrere Arbeitsbereiche zu definieren, die jeweils mit bestimmten aktivierten Prüfungen auf verschiedene Teile Ihrer Codebasis abzielen.

Schnellstart-Konfiguration```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 } } ] }

#### Umfassendes Konfigurationsbeispiel

Hier ist ein umfassendes Beispiel, das alle verfügbaren Eigenschaften zeigt:```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
      }
    }
  ]
}

Verfügbare Eigenschaften

Root-Level-Eigenschaften

configVersion (erforderlich): Versionszeichenkette der Konfiguration
$schema (optional): JSON-Schema-Referenz für die Validierung
conditionNames (optional): Array von Bedingungsnamen für die Auflösung von Exporten
customAssetExtensions (optional): Zusätzliche Asset-Erweiterungen, die als auflösbare Importe behandelt werden (z. B. ["glb", "mp3"]). Die Standardliste umfasst gängige Erweiterungen für Schriftarten, Bilder und Konfigurationsdateien.
ignoreFiles (optional): Globale Dateimuster, die in allen Workspaces ignoriert werden. Git-ignorierte Dateien werden standardmäßig übersprungen.
processIgnoredFiles (optional): Globale Dateimuster, die verarbeitet werden, auch wenn sie mit gitignore oder ignoreFiles übereinstimmen.
nodeModulesResolution (optional): Anhand welcher package.json jeder Drittanbieter-Import für die Prüfungen missingNodeModules, unusedNodeModules und unresolvedImports validiert wird. Konfigurieren Sie es als Objekt { "resolutionType": ..., "includeDevDepsFromRoot": ... } – die Form, die rev-dep config init erzeugt. resolutionType ist "entry-package" (Standard, validiert gegen die Einstiegs-package.json des Workspace) oder "nearest-package" (validiert gegen die package.json, die jede Datei besitzt – für das Standard-Layout von pnpm verwenden, bei dem jedes Paket nur seine eigenen Abhängigkeiten auflöst). includeDevDepsFromRoot (Standard false) erlaubt Paketcode die Verwendung von Dev-Abhängigkeiten, die nur im Monorepo-Root deklariert sind, ohne dass missingNodeModules oder unresolvedImports sie melden. Eine nackte Zeichenkette (z. B. "nearest-package") wird ebenfalls als abwärtskompatible Kurzform für resolutionType akzeptiert. Gilt für alle Workspaces. Siehe die Dokumentation.
workspaces (erforderlich): Array von Workspace-Objekten

Workspace-Eigenschaften

Jeder Workspace kann die folgenden Eigenschaften enthalten:

path (erforderlich): Zielverzeichnispfad für diesen Workspace (entweder . oder ein Pfad, der mit dem Namen eines Unterverzeichnisses beginnt)
followMonorepoPackages (optional): Steuert die Auflösung von Monorepo-Paketen. true folgt allen Workspace-Paketen (Standard), false deaktiviert dies, ein Array folgt nur ausgewählten Paketnamen.
prodEntryPoints (optional): Produktions-Einstiegspunktmuster auf Workspace-Ebene für die Standardwerte der Detektoren
devEntryPoints (optional): Entwicklungs-Einstiegspunktmuster auf Workspace-Ebene für die Standardwerte der Detektoren
ignoreEntryPoints (optional): Muster auf Workspace-Ebene für übrig gebliebene Einstiegspunkte, die nicht mehr relevant sind. Dateien, die diesen Mustern entsprechen, werden nicht als Probleme behandelt – sie werden nie als verwaiste Dateien gemeldet, und ihre ungenutzten Exporte werden nicht gemeldet. Nützlich für Dateien, die eingecheckt bleiben müssen, aber nicht mehr in die App eingebunden sind.
moduleBoundaries (optional): Array von Modulgrenzen-Regeln
circularImportsDetection (optional): Konfiguration zur Erkennung zyklischer Importe (einzelnes Objekt oder Array von Objekten)
duplicatedCodeDetection (optional): Konfiguration zur Erkennung doppelten Codes (einzelnes Objekt oder Array von Objekten)
orphanFilesDetection (optional): Konfiguration zur Erkennung verwaister Dateien (einzelnes Objekt oder Array von Objekten)
unusedNodeModulesDetection (optional): Konfiguration zur Erkennung ungenutzter Node-Module (einzelnes Objekt oder Array von Objekten)
missingNodeModulesDetection (optional): Konfiguration zur Erkennung fehlender Node-Module (einzelnes Objekt oder Array von Objekten)
unusedExportsDetection (optional): Konfiguration zur Erkennung ungenutzter Exporte (einzelnes Objekt oder Array von Objekten)
unresolvedImportsDetection (optional): Konfiguration zur Erkennung unaufgelöster Importe (einzelnes Objekt oder Array von Objekten)
devDepsUsageOnProdDetection (optional): Konfiguration zur Erkennung der Nutzung eingeschränkter Dev-Abhängigkeiten (einzelnes Objekt oder Array von Objekten)
restrictedImportsDetection (optional): Beschränkt das Importieren verbotener Dateien/Module aus ausgewählten Einstiegspunkten (einzelnes Objekt oder Array von Objekten)
restrictedImportersDetection (optional): Legt per Whitelist fest, welche Einstiegspunkte eine Gruppe von Dateien/Modulen transitiv erreichen dürfen (einzelnes Objekt oder Array von Objekten)
restrictedDirectImportersDetection (optional): Schränkt ein, welche Dateien eine Gruppe von Dateien/Modulen direkt importieren dürfen; nicht transitiv (einzelnes Objekt oder Array von Objekten)
importConventions (optional): Array von Importkonventions-Regeln

Modulgrenzen-Eigenschaften

name (erforderlich): Name der Grenze
pattern (erforderlich): Glob-Muster für Dateien in dieser Grenze
allow (optional): Array zulässiger Importmuster
deny (optional): Array verbotener Importmuster (überschreibt allow)

Importkonventions-Eigenschaften

rule (erforderlich): Art der Regel, derzeit nur relative-internal-absolute-external
autofix (optional): Ob Verstöße gegen Importkonventionen automatisch behoben werden sollen (Standard: false)
domains (erforderlich): Array von Domain-Definitionen. Kann eine Zeichenkette (Glob-Muster) oder ein Objekt sein mit:
- path (erforderlich): Verzeichnis mit den Domain-Dateien
- alias (optional): Alias, der für absolute Importe von Code aus dieser Domain verwendet werden soll
- enabled (optional): Auf false setzen, um Prüfungen für diese Domain zu überspringen (Standard: true)

Eigenschaften der Erkennungsoptionen

Jede Erkennungseigenschaft kann konfiguriert werden als:

ein einzelnes Objekt (eine Detektorinstanz) oder
ein Array von Objekten (mehrere Detektorinstanzen, die innerhalb desselben Workspace ausgewertet werden).

CircularImportsDetection:

enabled (erforderlich): Aktiviert/deaktiviert die Erkennung zyklischer Importe
ignoreTypeImports (optional): Typ-Only-Importe beim Erstellen des Graphen ausschließen (Standard: false)

DuplicatedCodeDetection:

enabled (erforderlich): Aktiviert/deaktiviert die Erkennung doppelten Codes
blindIdentifiers (optional): Namen als Wildcards behandeln, sodass eine umbenannte Kopie weiterhin zählt (Standard: false)
blindStrings (optional): Zeichenketten- und Vorlageninhalte als Wildcards behandeln (Standard: false)
blindNumbers (optional): Numerische Literale als Wildcards behandeln (Standard: false)
minTokens (optional): Kleinste zu meldende Duplizierung in Token (Standard: 50)
minLines (optional): Kleinste zu meldende Duplizierung in Zeilen (Standard: 3)
minDepth (optional): Geringste Verschachtelungstiefe, wobei der Block selbst mitzählt. 2 erfordert mindestens eine Verschachtelungsebene (Standard: 0)
minStatements (optional): Geringste Anzahl von Anweisungen; gilt nur für Anweisungsblöcke (Standard: 0)
minDuplicates (optional): Wie viele Kopien ein Codeabschnitt benötigt, bevor er gemeldet wird (Standard: 2)
skipObjects (optional): Duplizierungen, die nur Objektliterale sind, nicht melden (Standard: false)
ignoreFiles (optional): Glob-Muster, die von der Analyse ausgeschlossen werden
snapshotPath (optional): Pfad zu einer eingecheckten Basislinie anerkannter Duplizierungen, relativ zum Workspace. Damit meldet die Prüfung, was sich geändert hat, statt der Gesamtzahl

OrphanFilesDetection:

enabled (erforderlich): Aktiviert/deaktiviert die Erkennung verwaister Dateien
validEntryPoints (optional): Array gültiger Einstiegspunktmuster. Wenn nicht angegeben, Standard: prodEntryPoints + devEntryPoints aus der Workspace-Ebene.
ignoreTypeImports (optional): Typ-Only-Importe beim Erstellen des Graphen ausschließen (Standard: false)
graphExclude (optional): Dateimuster, die von der Graphenanalyse ausgeschlossen werden
autofix (optional): Erkannte verwaiste Dateien automatisch löschen, wenn rev-dep config run --fix ausgeführt wird (Standard: false)

UnusedNodeModulesDetection:

enabled (erforderlich): Aktiviert/deaktiviert die Erkennung ungenutzter Module
includeModules (optional): Modulmuster, die in die Analyse einbezogen werden
excludeModules (optional): Modulmuster, die von der Analyse ausgeschlossen werden
pkgJsonFieldsWithBinaries (optional): Package.json-Felder, die Binärreferenzen enthalten (z. B. lint-staged). Führt eine Klartextsuche durch
filesWithBinaries (optional): Dateimuster, die nach Binärnutzung durchsucht werden. Führt eine Klartextsuche durch
filesWithModules (optional): Nicht-JS/TS-Dateimuster, die nach Modulimporten durchsucht werden (z. B. Shell-Skripte). Führt eine Klartextsuche durch
outputType (optional): Ausgabeformat - "list", "groupByModule", "groupByFile"

MissingNodeModulesDetection:

enabled (erforderlich): Aktiviert/deaktiviert die Erkennung fehlender Module
includeModules (optional): Modulmuster, die in die Analyse einbezogen werden
excludeModules (optional): Modulmuster, die von der Analyse ausgeschlossen werden
outputType (optional): Ausgabeformat - "list", "groupByModule", "groupByFile", "groupByModuleFilesCount"

UnusedExportsDetection:

enabled (erforderlich): Aktiviert/deaktiviert die Erkennung ungenutzter Exporte
validEntryPoints (optional): Glob-Muster für Dateien, deren Exporte nie als ungenutzt gemeldet werden. Wenn nicht angegeben, Standard: prodEntryPoints + devEntryPoints aus der Workspace-Ebene.
ignoreTypeExports (optional): export type / export interface von der Analyse ausnehmen (Standard: false)
graphExclude (optional): Dateimuster, die von der Analyse ungenutzter Exporte ausgeschlossen werden
ignore (optional): Zuordnung von Dateipfad-Globs (relativ zum Workspace-Pfadverzeichnis) zu Exportnamen/-spezifizierer-Globs, die unterdrückt werden sollen; jeder Wert kann eine Zeichenkette oder ein Array von Zeichenketten sein
ignoreFiles (optional): Dateipfad-Globs; alle ungenutzten Exporte aus übereinstimmenden Dateien werden unterdrückt
ignoreExports (optional): Exportnamen/-spezifizierer (oder Globs), die global unterdrückt werden sollen (unterstützt "default")
autofix (optional): Behebbare Änderungen an ungenutzten Exporten automatisch anwenden, wenn rev-dep config run --fix ausgeführt wird (Standard: false)

UnresolvedImportsDetection:

enabled (erforderlich): Aktiviert/deaktiviert die Erkennung unaufgelöster Importe
ignore (optional): Zuordnung von Dateipfad-Globs (relativ zum Workspace-Pfadverzeichnis) zu Importanfrage-Globs, die unterdrückt werden sollen; jeder Wert kann eine Zeichenkette oder ein Array von Zeichenketten sein
ignoreFiles (optional): Dateipfad-Globs; alle unaufgelösten Importe aus übereinstimmenden Dateien werden unterdrückt
ignoreImports (optional): Importanfragen (oder Globs), die in unaufgelösten Ergebnissen global unterdrückt werden sollen

DevDepsUsageOnProdDetection:

enabled (erforderlich): Aktiviert/deaktiviert die Erkennung der Nutzung eingeschränkter Dev-Abhängigkeiten
prodEntryPoints (optional): Produktions-Einstiegspunktmuster, von denen aus Abhängigkeiten verfolgt werden. Wenn nicht angegeben, Standard: prodEntryPoints auf Workspace-Ebene.
ignoreTypeImports (optional): Typ-Only-Importe von der Graphen-Traversierung und Modulzuordnung ausschließen (Standard: false)

RestrictedImportsDetection:

enabled (erforderlich): Aktiviert/deaktiviert die Erkennung eingeschränkter Importe
entryPoints (erforderlich, wenn aktiviert): Einstiegspunktmuster, die zum Erstellen des erreichbaren Abhängigkeitsgraphen verwendet werden (Einstiegspunkte auf Workspace-Ebene werden hier nicht angewendet)
graphExclude (optional): Dateimuster, die von der Graphenanalyse eingeschränkter Importe ausgeschlossen werden
denyFiles (optional): Verbotene Dateipfadmuster (z. B. ["**/*.tsx"])
denyModules (optional): Verbotene Modulmuster (z. B. ["react", "react-*"])
ignoreMatches (optional): Datei-/Modulmuster, die in den Ergebnissen eingeschränkter Importe unterdrückt werden sollen
ignoreTypeImports (optional): Typ-Only-Importe von der Traversierung ausschließen (Standard: false)

Leistungsvorteile

Der Konfigurationsansatz bietet erhebliche Leistungsvorteile:

Ein einziger Abhängigkeitsbaum: Erstellt einen umfassenden Abhängigkeitsbaum für alle Workspaces
Parallele Workspace-Ausführung: Verarbeitet mehrere Workspaces gleichzeitig
Parallele Prüfungsausführung: Führt alle aktivierten Prüfungen innerhalb jedes Workspace parallel aus
Optimierte Dateierkennung: Erkennt Dateien einmal und nutzt sie für alle Prüfungen erneut

Dadurch sind konfigurationsbasierte Prüfungen schneller als die sequenzielle Ausführung einzelner Befehle, insbesondere bei großen Codebasen mit mehreren Unterpaketen.

Explorations-Toolkit 🔧

Praktische Beispiele zeigen, wie Sie rev-dep-CLI-Befehle verwenden können, um Codequalitätsprüfungen für Ihr Projekt zu erkunden, zu debuggen oder zu erstellen.

Wie Sie herausfinden, wo eine Datei im Projekt verwendet wird```

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

Sie sehen alle Einstiegspunkte, die diese Datei implizit erfordern, zusammen mit den Auflösungspfaden.

### **So überprüfen Sie, ob eine Datei verwendet wird**```
rev-dep resolve --file path/to/file.ts --compact-summary

Zeigt, wie viele Einstiegspunkte indirekt von der Datei abhängen.

So identifizieren Sie tote Dateien```

rev-dep entry-points

Schließen Sie bei Bedarf Framework-Einstiegspunkte mit `--result-exclude` aus.

Schließen Sie zum Beispiel gültige Next.js-Einstiegspunkte aus, wenn Sie den Pages Router verwenden, schließen Sie das scripts-Verzeichnis aus - Skripte sind gültige Einstiegspunkte - und schließen Sie alle Testdateien aus:```
rev-dep entry-points --result-exclude "pages/**","scripts/**","**/*.test.*"

So listen Sie alle Dateien auf, die von einem Einstiegspunkt importiert werden```

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

Nützlich zum Identifizieren schwerer Komponenten oder unbeabsichtigter Abhängigkeiten.

### **So reduzieren Sie unnötige Importe für einen Einstiegspunkt**

1. Listen Sie alle importierten Dateien auf:   ```
   rev-dep files --entry-point path/to/entry.ts

Verdächtige Dateien identifizieren.
Nachverfolgen, warum sie enthalten sind: ``` rev-dep resolve --file path/to/suspect --entry-points path/to/entry.ts --all

So erkennen Sie zirkuläre Abhängigkeiten```

rev-dep circular

### **Wie man duplizierten Code erkennt**```
rev-dep duplicated-code

Reports repeated code blocks and JSX elements - units you can extract - rather than repeated lines. Add --blind-identifiers to catch copies whose variables were renamed.

So finden Sie ungenutzte Node-Module```

rev-dep node-modules unused

### **So finden Sie fehlende Node-Module**```
rev-dep node-modules missing

So überprüfen Sie die Speichernutzung von node_modules```

rev-dep node-modules dirs-size

### **Wie man Dev-Abhängigkeiten im Produktionscode erkennt**```
rev-dep config run

Wenn devDepsUsageOnProdDetection in deiner Konfiguration aktiviert ist, wird rev-dep:

Abhängigkeitsgraphen von deinen festgelegten Produktions-Einstiegspunkten verfolgen
Alle Dateien identifizieren, die von diesen Einstiegspunkten aus erreichbar sind
Prüfen, ob importierte Module in devDependencies in package.json aufgeführt sind
Verstöße melden, die anzeigen, welche Entwicklungsabhängigkeiten wo verwendet werden

Beispielausgabe:``` ❌ 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)

**Wichtige Hinweise:**
- Type-only imports (z. B. `import type { ReactNode } from 'react'`) werden ignoriert, wenn `ignoreTypeImports` aktiviert ist
- Nur Abhängigkeiten aus `devDependencies` in package.json werden markiert
- Produktionsabhängigkeiten aus `dependencies` sind erlaubt
- Hilft, Laufzeitfehler in Produktions-Builds zu verhindern

## Arbeiten mit Monorepo 🏗️

Rev-dep bietet erstklassige Unterstützung für Monorepo-Projekte und ermöglicht eine präzise Abhängigkeitsanalyse über Workspace-Pakete hinweg.

### followMonorepoPackages-Flag

Das Flag `--follow-monorepo-packages` ermöglicht die Auflösung von Importen aus Workspace-Paketen des Monorepos. Standardmäßig ist dieses Flag auf `false` gesetzt, um die Kompatibilität mit Einzelpaket-Projekten zu gewährleisten.```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

Wenn aktiviert, wird rev-dep Folgendes tun:

Workspace-Pakete erkennen automatisch durch Scannen nach Monorepo-Konfiguration
Importe zwischen Paketen auflösen innerhalb des Workspace
package.json-Exporte berücksichtigen für eine korrekte Modulauflösung

Exports-Map-Unterstützung

Rev-dep unterstützt das exports-Feld in package.json-Dateien vollständig, das in modernen Node.js-Projekten der Standardweg zur Definition von Paketeinstiegspunkten ist.

Die Exports-Map-Unterstützung umfasst:

Bedingte Exporte unter Verwendung von Bedingungen wie node, import, default und benutzerdefinierten Bedingungen
Wildcard-Muster für flexible Subpfad-Zuordnung
Sugar-Syntax für einfache Definitionen von Hauptexporten
Verschachtelte Bedingungen für komplexe Auflösungsszenarien

Condition-Names-Flag

Um zu steuern, welche bedingten Exporte aufgelöst werden, verwende das --condition-names-Flag. Damit kannst du die Priorität der Bedingungen beim Auflösen von Paketexporten festlegen:```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

Die Bedingungen werden in der angegebenen Reihenfolge verarbeitet, wobei die erste zutreffende Bedingung verwendet wird. Zu den gängigen Bedingungen gehören:
- `node` - Node.js-Umgebung
- `import` - ES-Module
- `require` - CommonJS
- `default` - Fallback-Bedingung
- Benutzerdefinierte Bedingungen, die für Ihr Projekt oder Ihre Build-Tools spezifisch sind

Beispiel für package.json mit 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"
  }
}

So funktioniert die Monorepo-Auflösung

Monorepo-Erkennung: Wenn followMonorepoPackages aktiviert ist, durchsucht rev-dep die Workspace-Konfiguration (pnpm-workspace.yaml, package.json workspaces usw.)
Paketauflösung: Importe in Workspace-Pakete werden mithilfe der exports-Konfiguration des Pakets aufgelöst. Ist exports nicht definiert, wird auf die Felder main/module zurückgegriffen.
Abhängigkeitsvalidierung: Das Tool validiert, dass Cross-Package-Importe nur erlaubt sind, wenn das Zielpaket in den dependencies oder devDependencies des Verbrauchers aufgeführt ist.
Pfadauflösung: Alle Pfade werden relativ zu den jeweiligen Paketwurzeln aufgelöst, was eine genaue Abhängigkeitsverfolgung über das gesamte Monorepo hinweg gewährleistet.

Dadurch ist rev-dep besonders effektiv für Monorepo-Projekte in großem Maßstab, bei denen das Verständnis von Cross-Package-Abhängigkeiten entscheidend für die Aufrechterhaltung von Codequalität und Architektur ist.

Leistungsvergleich ⚡

Rev-dep kann mehrere Prüfungen an einem Monorepo mit 500k+ Codezeilen und mehreren Unterpaketen in etwa 150 ms durchführen.

Es übertrifft Madge, dpdm, dependency-cruiser, skott, knip, depcheck und andere ähnliche Tools.

Hier ist ein Leistungsvergleich spezifischer Aufgaben zwischen rev-dep und Alternativen:

Aufgabe	Ausführungszeit [ms]	Alternative	Alternative Ausführungszeit [ms]	Langsamer als Rev-dep
Zirkulare Abhängigkeiten finden	151	knip	3 040	20x
Unbenutzte Exporte finden	186	knip	3 176	17x
Unbenutzte Dateien finden	168	knip	3 006	18x
Unbenutzte Node-Module finden	170	knip	3 069	18x
Fehlende Node-Module finden	160	knip	3 076	19x
Alle von einem Einstiegspunkt importierten Dateien auflisten	81	madge	6 591	81x
Einstiegspunkte entdecken	149	madge	13 632	92x
Modulgrenzen durchsetzen	164	dependency-cruiser	8 140	50x
Eingeschränkte Importe finden	170	dependency-cruiser	10 995	65x
Eingeschränkte Importeure finden	179	dependency-cruiser	9 234	52x
Abhängigkeitspfad zwischen Dateien auflösen	221	bitte vorschlagen
Codezeilen zählen	251	bitte vorschlagen
Größen der node_modules-Verzeichnisse analysieren	561	bitte vorschlagen

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

Messungen: hyperfine -w 4 -r 8 (4 Aufwärm- + 8 Messläufe)

Projekt: 580k Codezeilen, 6024 Quelldateien next.js-App

Leistungsvergleich der Zyklusprüfung

Die folgende Tabelle zeigt einen Leistungsvergleich verschiedener Tools zur Erkennung zirkularer Importe.

Die Zyklusprüfung von rev-dep ist ~20-mal schneller als die schnellste Alternative.

Tool	Version	Zeit [ms]
🥇 rev-dep	3.0.0	154
🥈 knip *	6.29.0	3 040
🥉 circular-dependency-scanner	3.0.1	3 355
dpdm-fast	1.0.14	6 070
dpdm	4.2.0	6 667
dependency-cruiser	18.1.0	8 258
madge	8.0.0	13 569
skott	0.35.11	61 613

* knip ignoriert immer Type-only-Importkanten und bietet kein Flag, um sie einzuschließen. Jeder Zyklus in dieser Codebasis enthält mindestens eine solche Kante, daher meldet knip 0 Zyklen – seine 3 040 ms sind eine echte vollständige Analyse, nur eines kleineren Graphen. rev-dep circular -t, das dieselbe Regel anwendet, stimmt exakt überein (0 Zyklen) in 143.3 ms ± 10.3.

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

Messungen: hyperfine -w 4 -r 8 (4 Aufwärm- + 8 Messläufe)

Projekt: 580k Codezeilen, 6024 Quelldateien next.js-App

Detaillierte Messungen mit mittlerer Zeit und den verwendeten Befehlen findest du in PERFORMANCE.md.

CLI-Referenz 📖

rev-dep circular

Erkenne zirkulare Abhängigkeiten in deinem Projekt

Übersicht

Analysiert das Projekt, um zirkulare Abhängigkeiten zwischen Modulen zu finden. Zirkulare Abhängigkeiten können schwer zu debuggende Probleme verursachen und sollten im Allgemeinen vermieden werden.``` rev-dep circular [flags]

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

Optionen```

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

Erstellen und Ausführen von rev-dep-Konfigurationsdateien

#### Übersicht

Befehle zum Erstellen und Ausführen von rev-dep-Konfigurationsdateien.

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

rev-dep config run

Führe alle in (.)rev-dep.config.json(c) definierten Prüfungen aus.

Zusammenfassung

Verarbeite (.)rev-dep.config.json(c) und führe alle aktivierten Prüfungen (zirkuläre Importe, verwaiste Dateien, Modulgrenzen, Importkonventionen, Node-Module, ungenutzte Exporte, nicht aufgelöste Importe, eingeschränkte Importe und eingeschränkte Nutzung von Dev-Abhängigkeiten) pro Workspace aus.``` rev-dep config run [flags]

#### Optionen```
  -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

Initialisiert eine neue rev-dep.config.json-Datei

Übersicht

Erstellt eine neue rev-dep.config.json-Konfigurationsdatei im aktuellen Verzeichnis mit Standardeinstellungen.``` rev-dep config init [flags]

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

rev-dep config lint

Meldet (und entfernt optional) Konfigurations-Glob-/Pfadmuster, die nichts finden

Übersicht

Durchsucht eine (.)rev-dep.config.json(c) nach „toten“ Glob- und Pfadmustern – Ignorier-Muster, Einstiegspunkt-Muster, Arbeitsbereichspfade, Graph-Ausschlüsse, blockierte Dateien/Module und Ähnliches –, die keinem erkannten Datei- oder Modulpfad mehr entsprechen. Mit der Zeit sammeln sich in Konfigurationen Muster für Dateien an, die umbenannt oder gelöscht wurden; dieser Befehl deckt sie auf, damit die Konfiguration schlank bleibt.

Mit --fix werden tote Muster direkt entfernt, wobei alle Kommentare und Formatierungen erhalten bleiben. Einige Muster werden gemeldet, aber nie automatisch entfernt, weil das Löschen das Verhalten eines Checks ändern oder die Konfiguration ungültig machen könnte – Arbeitsbereichspfade, erforderliche Einstiegspunkte/Dateien/Module und Modulgrenz-Selektoren. Diese sind als „nicht automatisch entfernt“ markiert; lösen Sie sie von Hand auf.``` rev-dep config lint [flags]

#### Optionen```
  -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

Übersicht

Aktualisieren Sie eine (.)rev-dep.config.json(c) vom v2-Schema auf v3 (Konfigurationsversion 2.0).

Es wendet die sicheren, eindeutigen Änderungen direkt an (das Array 'rules' auf oberster Ebene wird in 'workspaces' umbenannt, 'configVersion' wird auf 2.0 angehoben, und die eingestellte Option 'algorithm' wird aus den Detektoren für zirkuläre Importe entfernt), wobei alle Kommentare und die Formatierung erhalten bleiben. Überprüfen Sie die Änderung vor dem Übernehmen mit git.

Anschließend listet es auf, was es für Sie NICHT ändern konnte: Glob-Muster, deren Treffermenge sich unter v3s strengeren, an gitignore angeglichenen Regeln verschoben haben könnte, sowie Verhaltensänderungen, die keine Konfigurationsänderung beheben kann. Prüfen Sie diese manuell - siehe den Leitfaden zu Breaking Changes in v3.``` rev-dep config migrate [flags]

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

rev-dep debug

Debugging-Werkzeuge zur Untersuchung der internen Abläufe von Parser und Resolver

Übersicht

Debugging-Werkzeuge zur Untersuchung, wie rev-dep Dateien parst und Abhängigkeiten auflöst. Die Ausgabe folgt nicht dem Semver-Standard.

Optionen```

-h, --help help for debug

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

Debug: Vollständigen Abhängigkeitsbaum für die Analyse anzeigen

#### Übersicht

Debugging-Werkzeug zur Untersuchung des vollständigen Abhängigkeitsbaums. Die Ausgabe folgt nicht semver.```
rev-dep debug get-tree-for-cwd [flags]

Optionen```

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

Listet alle Dateien im aktuellen Arbeitsverzeichnis auf

#### Synopsis

Listet rekursiv alle Dateien im angegebenen Verzeichnis auf,
mit Optionen zum Filtern der Ergebnisse.```
rev-dep debug list-cwd-files [flags]

Beispiele```

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

#### Optionen```
      --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

Debug: Zeigt geparste Importe für eine einzelne Datei an

Übersicht

Debugging-Werkzeug zur Untersuchung, wie der Parser eine bestimmte Datei verarbeitet. Die Ausgabe folgt nicht semver.``` rev-dep debug parse-file [flags]

#### Optionen```
      --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

Debug: Zeigt geparste TypeScript-Konfigurationsaliase

Übersicht

Debugging-Werkzeug zur Überprüfung, wie die TypeScript-Konfiguration geparst wird und welche Aliase extrahiert werden. Die Ausgabe folgt nicht semver.``` rev-dep debug parse-tsconfig [flags]

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

rev-dep duplicated-code

Findet Code, der über (und innerhalb der) Dateien des Projekts dupliziert ist.

Kurzübersicht

Durchsucht jede Quelldatei nach kopierbaren Blöcken - Klammerblöcke und JSX-Elemente auf jeder Verschachtelungsebene - und meldet diejenigen, die mehr als einmal vorkommen.

Der Vergleich ignoriert Formatierung und Kommentare vollständig, sodass neu eingerückte Kopien weiterhin übereinstimmen.

Vier Filter entscheiden, was als berichtenswert gilt. --min-tokens und --min-lines messen die Größe; --min-depth und --min-statements messen die Komplexität - genau das unterscheidet ein dupliziertes Konfigurationsobjekt mit drei Schlüsseln von duplizierter Logik; keine Größenuntergrenze kann das leisten, da die Schlüssel und String-Werte des Objekts lang sein können. --min-duplicates legt fest, wie viele Kopien erforderlich sind, um als Duplikat zu gelten.

Standardmäßig muss der Code exakt wie geschrieben übereinstimmen. Jedes --blind-*-Flag entfernt eine Token-Kategorie aus dem Vergleich, und sie lassen sich frei kombinieren:

--blind-identifiers names are wildcards, so a copy whose variables, functions or components were renamed is still reported --blind-strings string and template contents are wildcards --blind-numbers numeric literals are wildcards``` rev-dep duplicated-code [flags]

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

Optionen```

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

Findet und listet alle Einstiegspunkte im Projekt auf

#### Kurzbeschreibung

Analysiert die Projektstruktur, um alle potenziellen Einstiegspunkte zu identifizieren.
Nützlich, um die Architektur und Abhängigkeiten deiner Anwendung zu verstehen.```
rev-dep entry-points [flags]

Beispiele```

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

#### Optionen```
      --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 alle Dateien im Abhängigkeitsbaum eines Einstiegspunkts auf

Synopsis

Findet rekursiv und listet alle Dateien auf, die vom angegebenen Einstiegspunkt benötigt werden.``` rev-dep files [flags]

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

Optionen```

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

Alle Dateien auflisten, die die angegebene Datei direkt importieren

#### Übersicht

Findet und listet alle Dateien im Projekt auf, die die angegebene Datei direkt importieren.
Dies ist nützlich, um die Auswirkungen von Änderungen an einer bestimmten Datei zu verstehen.```
rev-dep imported-by [flags]

Beispiele```

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

#### Optionen```
      --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

Zähle die tatsächlichen Codezeilen im Projekt, ohne Kommentare und leere Zeilen.``` rev-dep lines-of-code [flags]

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

Optionen```

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

### rev-dep list-cwd-files

Listet alle Dateien im aktuellen Arbeitsverzeichnis auf

#### Übersicht

Listet rekursiv alle Dateien im angegebenen Verzeichnis auf,
mit Optionen zum Filtern der Ergebnisse.```
rev-dep list-cwd-files [flags]

Beispiele```

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

#### Optionen```
      --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

Unaufgelöste Importe im Projekt auflisten

Übersicht

Erkennt und listet Importe, die während der Importauflösung nicht aufgelöst werden konnten. Gruppiert Importe nach Datei.``` rev-dep unresolved [flags]

#### Optionen```
      --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

Node.js-Abhängigkeiten analysieren und verwalten

Zusammenfassung

Werkzeuge zum Analysieren und Verwalten von Node.js-Modulabhängigkeiten. Hilft, ungenutzte, fehlende oder doppelte Abhängigkeiten in Ihrem Projekt zu identifizieren.

Beispiele```

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

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

rev-dep node-modules analyze-size

Analysiert die Speichernutzung von node_modules

Übersicht

Bietet eine detaillierte Größenanalyse des node_modules-Verzeichnisses. Hilft, platzfressende Abhängigkeiten zu identifizieren.``` rev-dep node-modules analyze-size [flags]

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

Optionen```

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

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

Calculates cumulative files size in node_modules directories

#### Synopsis

Calculates and displays the size of node_modules folders
in the current directory and subdirectories. Sizes will be smaller than actual file size taken on disk. Tool is calculating actual file size rather than file size on disk (related to disk blocks usage)```
rev-dep node-modules dirs-size [flags]

Beispiele```

rev-dep node-modules dirs-size

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

rev-dep node-modules installed-duplicates

Doppelte Paketinstallationen finden und optimieren

Übersicht

Identifiziert Pakete, die mehrfach in node_modules installiert sind. Kann den Speicherplatz optimieren, indem es Symlinks zwischen doppelten Paketen erstellt.``` rev-dep node-modules installed-duplicates [flags]

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

Optionen```

-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 installiert

Listet alle installierten npm-Pakete im Projekt auf.

#### Zusammenfassung

Durchsucht rekursiv node_modules-Verzeichnisse, um alle installierten Pakete aufzulisten. Nützlich zur Überprüfung von Abhängigkeiten in Monorepos.```
rev-dep node-modules installed [flags]

Beispiele```

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

#### Optionen```
  -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 fehlend

Findet importierte Pakete, die nicht in package.json aufgelistet sind.

Übersicht

Identifiziert Pakete, die in Ihrem Code importiert, aber nicht deklariert in den Abhängigkeiten Ihrer package.json sind.``` rev-dep node-modules missing [flags]

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

Optionen```

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

Entfernt Markdown-/Doku-ähnliche Dateien aus installierten node_modules-Paketen

#### Synopsis

Entfernt Dateien aus installierten node_modules-Paketen basierend auf Glob-Mustern.
Nützlich zum Entfernen von README/Lizenz/Doku-Dateien, um die Abhängigkeitsgröße zu reduzieren.```
rev-dep node-modules prune-docs [flags]

Beispiele```

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"

#### Optionen```
  -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 unused

Finde installierte Pakete, die in deinem Code nicht importiert werden

Zusammenfassung

Vergleicht die Abhängigkeiten in package.json mit den tatsächlichen Imports in deiner Codebasis, um potenziell ungenutzte Pakete zu identifizieren.``` rev-dep node-modules unused [flags]

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

Optionen```

  --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 verwendete node-modules

Liste alle in deinem Code importierten npm-Pakete auf.

#### Übersicht

Analysiert deinen Code, um zu ermitteln, welche npm-Pakete tatsächlich verwendet werden.
Hilft dabei, die Laufzeitabhängigkeiten deines Projekts im Blick zu behalten.```
rev-dep node-modules used [flags]

Beispiele```

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

#### Optionen```
      --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

Verfolge und zeige den Abhängigkeitspfad zwischen Dateien in deinem Projekt an.

Übersicht

Analysiere und zeige die Abhängigkeitskette zwischen den angegebenen Dateien an. Hilft zu verstehen, wie verschiedene Teile deiner Codebasis miteinander verbunden sind.``` rev-dep resolve [flags]

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

Optionen```

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


## Glossar 📚

Einige der Begriffe im Problembereich, die **rev-dep** abdeckt, können verwirrend sein. Hier ist ein kleines Glossar, das dir hilft, dich in den Konzepten zurechtzufinden.

### Abhängigkeit

Eine *Abhängigkeit* kann wörtlich verstanden werden. Im Kontext des Abhängigkeitsgraphen eines Projekts kann sie sich beziehen auf:

* ein **Node-Modul / Paket** (ein Paket ist eine Abhängigkeit eines Projekts oder einer Datei), oder
* eine **Quellcodedatei** (eine Datei ist eine Abhängigkeit einer anderen Datei, wenn sie diese importiert).

### Einstiegspunkt

Ein *Einstiegspunkt* ist eine Quelldatei, die **von keiner anderen Datei importiert wird**. Er kann repräsentieren:

* den Haupteinstieg der Anwendung
* eine einzelne Seite oder Funktion
* Konfigurations- oder Test-Bootstrap-Dateien

- abhängig von der Projektstruktur.

### Unbenutzte / tote Datei

Eine Datei gilt als *unbenutzt* oder *tot*, wenn:

* sie ein **Einstiegspunkt** ist (nichts importiert sie), **und**
* ihre Ausführung **keine sinnvolle Ausgabe** oder keinen Nebeneffekt erzeugt.

In der Praxis können solche Dateien oft gefahrlos entfernt werden.

### Zirkuläre Abhängigkeit

Eine *zirkuläre Abhängigkeit* tritt auf, wenn eine Datei **sich selbst direkt oder indirekt importiert** über eine Kette von Importen.

Dies kann zu unvorhersehbarem Laufzeitverhalten, nicht initialisierten Werten oder subtilen Fehlern führen. Zirkuläre Abhängigkeiten zwischen **TypeScript-Typ-Importen** sind jedoch in der Regel harmlos.

### Umgekehrte Abhängigkeit (bzw. „Dependents“)

Dateien, die eine bestimmte Datei *importieren*. Nützlich zur Beantwortung der Frage: „Was bricht, wenn ich diese Datei ändere oder lösche?“

### Importgraph / Abhängigkeitsgraph

Eine visuelle Darstellung davon, wie Dateien oder Module einander importieren.

### Fehlende Abhängigkeit / ungenutztes Node-Modul

Ein Modul, das dein Code importiert, das aber **nicht in package.json aufgeführt ist**.

### Ungenutzte Abhängigkeit / ungenutztes Node-Modul

Eine in **package.json** aufgeführte Abhängigkeit, die im Quellcode **niemals importiert** wird.

### Root-Verzeichnis / Projektwurzel

Das Verzeichnis der obersten Ebene, das als Ausgangspunkt für die Abhängigkeitsanalyse verwendet wird.

## Telemetrie

Rev-Dep erfasst ein einzelnes **anonymes** Ereignis, nur während `rev-dep config run`. Mehr dazu in der [Telemetrie-Dokumentation](https://rev-dep.com/docs/telemetry).

Deaktiviere die Telemetrie vollständig, indem du `REV_DEP_TELEMETRY_OFF=true` setzt.

## Gemacht in 🇵🇱 und 🇯🇵 mit 🧠 von [@jayu](https://github.com/jayu)

Ich hoffe, dass dir dieses kleine Stück Software hilft, die Komplexität deines Projekts zu entdecken und zu verstehen, und dir dadurch mehr Selbstvertrauen beim Refactoring gibt. Wenn dir dieses Tool nützlich war, zögere nicht, ihm einen ⭐ zu geben!

### Meine anderen Projekte

- [CodeQue - Structural code search](https://codeque.co)
- [Structural Code Search VSCode](https://marketplace.visualstudio.com/items?itemName=CodeQue.codeque)

rev-dep v2.19.1

Kategorien