Rev-dep

Funzionalità  •   Installazione  •   Documentazione  •   Toolkit esplorativo  •   Riferimento CLI

Kit di analisi e ottimizzazione delle dipendenze per codebase JavaScript e TypeScript moderni.
Applica l'igiene del grafo delle dipendenze e rimuovi il codice inutilizzato con una CLI molto veloce.

Informazioni 📣

Man mano che le codebase crescono, mantenere una mappa mentale delle dipendenze diventa impossibile. Rev-dep è uno strumento di analisi statica ad alta velocità progettato per applicare l'integrità architetturale e l'igiene delle dipendenze in progetti JS/TS su larga scala.

Pensa a Rev-dep come a un linter ad alta velocità per il tuo grafo delle dipendenze.

Consolida controlli frammentati e sequenziali provenienti da più strumenti lenti in un unico motore ad alte prestazioni. Rev-dep esegue una suite completa di controlli di governance - inclusi circolarità, orfani, confini dei moduli e altro - in un'unica passata parallelizzata. Implementato in Go per aggirare i colli di bottiglia prestazionali dell'analisi basata su Node, può analizzare un progetto con oltre 500.000 righe di codice in circa 150ms. Vedi il confronto delle prestazioni

Governance automatizzata della codebase

Rev-dep va oltre la scansione passiva, arrivando all'applicazione attiva, rispondendo (e facendo fallire la CI) alle domande difficili:

• Integrità architetturale: "Il mio 'Dominio A' sta importando illegalmente dal 'Dominio B'?".
• Codice morto e sprechi: "Questi file sono irraggiungibili o questi node_modules sono inutilizzati?".
• Sicurezza del refactoring: "Quali punti di ingresso usano effettivamente questa utility e ci sono catene circolari?".
• Igiene del workspace: "Le mie importazioni sono coerenti e tutte le dipendenze sono dichiarate?".

Rev-dep funge da gatekeeper ad alta velocità per la tua CI, garantendo che il tuo grafo delle dipendenze rimanga snello e la tua architettura integra mentre iteri.

Perché Rev-dep? 🤔

🏗️ Supporto monorepo di prima classe

Progettato per workspace moderni (pnpm, yarn, npm). Rev-dep risolve nativamente le mappe exports/imports di package.json, gli alias TypeScript e traccia le dipendenze attraverso i confini dei pacchetti.

🛡️ Governance della codebase basata su configurazione

Vai oltre la scansione passiva. Usa il motore di configurazione per applicare Confini dei moduli e Convenzioni di importazione. Esegui una suite completa di controlli di igiene (circolarità, orfani, moduli inutilizzati e altro) in un'unica passata parallelizzata che funge da gatekeeper ad alta velocità per la tua CI.

🔍 Toolkit esplorativo

Toolkit CLI che aiuta a eseguire il debug dei problemi relativi alle dipendenze tra file. Comprendi le relazioni transitive tra i file e correggi i problemi.

⚡ Progettato per velocità ed efficienza in CI

Implementato in Go per eliminare il costo prestazionale dell'analisi basata su Node. Elaborando i file in parallelo, Rev-dep offre un'esecuzione da 17x a 90x più veloce rispetto alle alternative, riducendo significativamente i costi CI e i tempi di attesa degli sviluppatori.

Rev-dep può analizzare un progetto con oltre 500.000 righe di codice in circa 150ms. Vedi il confronto delle prestazioni

Funzionalità 🚀

Governance e manutenzione (basate su configurazione) 🛡️

Usa rev-dep config run per eseguire più controlli in un'unica passata per tutti i pacchetti.

Controlli disponibili:

• moduleBoundaries - applica i confini architetturali tra i moduli.
• importConventions - applica le convenzioni di stile delle importazioni (offre correzione automatica).
• unusedExportsDetection - rileva le esportazioni mai utilizzate (offre correzione automatica).
• orphanFilesDetection - rileva file morti/orfani (offre correzione automatica).
• unusedNodeModulesDetection - rileva dipendenze dichiarate ma non utilizzate.
• missingNodeModulesDetection - rileva importazioni mancanti dal package.json.
• unresolvedImportsDetection - rileva richieste di importazione non risolte.
• circularImportsDetection - rileva importazioni circolari.
• duplicatedCodeDetection - rileva codice copiato e incollato (blocchi ripetuti ed elementi JSX).
• devDepsUsageOnProdDetection - rileva dipendenze di sviluppo utilizzate nel codice di produzione.
• restrictedImportsDetection - blocca l'importazione di file/moduli non consentiti da punti di ingresso selezionati.
• restrictedImportersDetection - definisce una whitelist dei punti di ingresso che possono raggiungere transitivamente un insieme di file/moduli.
• restrictedDirectImportersDetection - vincola quali file possono importare direttamente un insieme di file/moduli (non transitorio).

Analisi esplorativa (basata su CLI) 🔍

Usa i comandi CLI per un'esplorazione ad hoc delle dipendenze:

• entry-points - individua i punti di ingresso del progetto.
• files - elenca i file dell'albero delle dipendenze per un dato punto di ingresso.
• resolve - traccia i percorsi delle dipendenze tra i file (chi importa questo file).
• imported-by - elenca gli importatori diretti di un file.
• circular - elenca le catene di dipendenze circolari.
• duplicated-code - trova blocchi di codice copiati e incollati ed elementi JSX.
• node-modules - ispeziona i moduli node used, unused, missing e installed.
• lines-of-code - conta le LOC effettive.
• unresolved - elenca le importazioni che non è stato possibile risolvere, raggruppate per file.
• list-cwd-files - elenca tutti i file di codice sorgente nella CWD
• debug - ispeziona ciò che rev-dep analizza, risolve e scopre internamente.

Installazione 📦

Documentazione completa: rev-dep.com/docs/intro

Installa localmente per configurare gli script di controllo del progetto``` yarn add -D rev-dep

Please provide the Markdown content to translate.```
npm install -D rev-dep

The input chunk appears to be missing. No content was provided after "INPUT:", so there is nothing to translate. Please provide the chunk text and I will translate it into Italian.``` pnpm add -D rev-dep

Crea un file di configurazione per un avvio rapido:```
npx rev-dep config init

Installa globalmente per usarlo come strumento CLI:``` yarn global add rev-dep

No input content was provided for chunk 11: the `INPUT:` section is empty, so there is nothing to translate.```
npm install -g rev-dep

I'm ready to translate, but the chunk content wasn't included in your message. The input section is empty. Please provide the actual text for chunk 13 of 205.``` pnpm global add rev-dep

### Guide di integrazione passo-passo

Segui la guida che corrisponde al tuo progetto per passare da zero a una configurazione funzionante:

- [Guida all'integrazione monorepo](https://rev-dep.com/docs/monorepo-integration-guide) - per i workspace `pnpm`/`yarn`/`npm`.
- [Guida all'integrazione in un singolo workspace](https://rev-dep.com/docs/single-workspace-integration-guide) - per progetti a pacchetto singolo.

## **Esempi rapidi 💡**

Alcuni esempi di uso immediato per farti un'idea dello strumento:```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

Controlli basati sulla configurazione 🛡️

Rev-dep fornisce un sistema di configurazione per orchestrare i controlli del progetto. L'approccio basato sulla configurazione è progettato per la velocità ed è il metodo preferito per implementare i controlli del progetto, perché può eseguire tutti i controlli in un'unica passata, in modo significativamente più veloce rispetto all'esecuzione separata di più comandi individuali.

I controlli disponibili sono:

• moduleBoundaries - applica i confini architetturali tra i moduli.
• importConventions - applica le convenzioni di stile degli import (offre autofix).
• unusedExportsDetection - rileva export mai utilizzati (offre autofix).
• orphanFilesDetection - rileva file morti/orfani (offre autofix).
• unusedNodeModulesDetection - rileva dipendenze dichiarate ma non utilizzate.
• missingNodeModulesDetection - rileva import mancanti dal package json.
• unresolvedImportsDetection - rileva richieste di import non risolte.
• circularImportsDetection - rileva import circolari.
• duplicatedCodeDetection - rileva blocchi di codice copiati e incollati ed elementi JSX.
• devDepsUsageOnProdDetection - rileva dipendenze di sviluppo utilizzate nel codice di produzione.
• restrictedImportsDetection - blocca l'importazione di file/moduli vietati da punti di ingresso selezionati.
• restrictedImportersDetection - inserisce nella whitelist quali punti di ingresso possono raggiungere transitivamente un insieme di file/moduli.
• restrictedDirectImportersDetection - vincola quali file possono importare direttamente un insieme di file/moduli (non transitivo).

I controlli sono raggruppati in workspace. Puoi avere più workspace, ad esempio per ogni pacchetto del monorepo.

Per Iniziare

Inizializza un file di configurazione nel tuo progetto:```bash

Create a default configuration file

rev-dep config init

Comportamento di `rev-dep config init`:

- Root di un monorepo: eseguendo `rev-dep config init` nella root del workspace si creano un workspace root e un workspace per ogni workspace package rilevato.
- Workspace package di un monorepo o progetti regolari: eseguendo `rev-dep config init` all'interno di una directory si crea una config con un singolo workspace con `path: "."` per questa directory.

Esegui tutti i check configurati (dry run, correzioni non ancora applicate):```bash
# Execute all workspaces and checks defined in the config
rev-dep config run

Elenca tutti i problemi rilevati:```bash

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

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

Correggi tutti i controlli correggibili:```bash
# Fix checks configured with autofix
rev-dep config run --fix

Struttura della configurazione

Il file di configurazione (rev-dep.config.json(c) o .rev-dep.config.json(c)) consente di definire più workspace, ciascuno mirato a diverse parti del codice con controlli specifici abilitati.

Configurazione di Avvio Rapido```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 } } ] }

#### Esempio Completo di Configurazione

Ecco un esempio completo che mostra tutte le proprietà disponibili:```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
      }
    }
  ]
}

Proprietà Disponibili

Proprietà a Livello Radice

• configVersion (obbligatoria): Stringa della versione di configurazione
• $schema (opzionale): Riferimento allo schema JSON per la validazione
• conditionNames (opzionale): Array di nomi di condizione per la risoluzione delle esportazioni
• customAssetExtensions (opzionale): Estensioni aggiuntive degli asset trattate come import risolvibili (ad es. ["glb", "mp3"]). L'elenco predefinito copre le estensioni comuni per font, immagini e file di configurazione.
• ignoreFiles (opzionale): Pattern globali di file da ignorare in tutti i workspace. I file ignorati da Git vengono saltati per impostazione predefinita.
• processIgnoredFiles (opzionale): Pattern globali di file da elaborare anche se corrispondono a gitignore o a ignoreFiles.
• nodeModulesResolution (opzionale): Indica rispetto a quale package.json viene validato ciascun import di terze parti per i controlli missingNodeModules, unusedNodeModules e unresolvedImports. Configuralo come oggetto { "resolutionType": ..., "includeDevDepsFromRoot": ... } - la forma generata da rev-dep config init. resolutionType può essere "entry-package" (predefinito, valida rispetto al package.json di ingresso del workspace) oppure "nearest-package" (valida rispetto al package.json proprietario di ciascun file - da usare per il layout predefinito di pnpm, dove ogni pacchetto risolve solo le proprie dipendenze). includeDevDepsFromRoot (predefinito false) consente al codice dei pacchetti di usare le dipendenze di sviluppo dichiarate solo nella radice del monorepo senza che missingNodeModules o unresolvedImports le segnalino. È accettata anche una semplice stringa (ad es. "nearest-package") come abbreviazione retrocompatibile di resolutionType. Si applica a tutti i workspace. Vedi la documentazione.
• workspaces (obbligatoria): Array di oggetti workspace

Proprietà dei Workspace

Ogni workspace può contenere le seguenti proprietà:

• path (obbligatoria): Percorso della directory di destinazione per questo workspace (. oppure un percorso che inizia con il nome di una sottodirectory)
• followMonorepoPackages (opzionale): Controlla la risoluzione dei pacchetti del monorepo. true segue tutti i pacchetti del workspace (predefinito), false la disabilita, un array segue solo i nomi dei pacchetti selezionati.
• prodEntryPoints (opzionale): Pattern dei punti di ingresso di produzione a livello di workspace per le impostazioni predefinite dei detector
• devEntryPoints (opzionale): Pattern dei punti di ingresso di sviluppo a livello di workspace per le impostazioni predefinite dei detector
• ignoreEntryPoints (opzionale): Pattern a livello di workspace per i punti di ingresso rimasti di cui non ti interessi più. I file che corrispondono a questi pattern non vengono elaborati come problemi - non vengono mai segnalati come file orfani e le loro esportazioni inutilizzate non vengono segnalate. Utile per i file che devono rimanere nel repository ma non sono più collegati all'applicazione.
• moduleBoundaries (opzionale): Array di regole per i confini dei moduli
• circularImportsDetection (opzionale): Configurazione per il rilevamento degli import circolari (un singolo oggetto o un array di oggetti)
• duplicatedCodeDetection (opzionale): Configurazione per il rilevamento del codice duplicato (un singolo oggetto o un array di oggetti)
• orphanFilesDetection (opzionale): Configurazione per il rilevamento dei file orfani (un singolo oggetto o un array di oggetti)
• unusedNodeModulesDetection (opzionale): Configurazione per il rilevamento dei moduli node inutilizzati (un singolo oggetto o un array di oggetti)
• missingNodeModulesDetection (opzionale): Configurazione per il rilevamento dei moduli node mancanti (un singolo oggetto o un array di oggetti)
• unusedExportsDetection (opzionale): Configurazione per il rilevamento delle esportazioni inutilizzate (un singolo oggetto o un array di oggetti)
• unresolvedImportsDetection (opzionale): Configurazione per il rilevamento degli import non risolti (un singolo oggetto o un array di oggetti)
• devDepsUsageOnProdDetection (opzionale): Configurazione per il rilevamento dell'uso limitato delle dipendenze di sviluppo (un singolo oggetto o un array di oggetti)
• restrictedImportsDetection (opzionale): Limita l'importazione di file/moduli negati da punti di ingresso selezionati (un singolo oggetto o un array di oggetti)
• restrictedImportersDetection (opzionale): Definisce una whitelist dei punti di ingresso che possono raggiungere transitivamente un insieme di file/moduli (un singolo oggetto o un array di oggetti)
• restrictedDirectImportersDetection (opzionale): Vincola quali file possono importare direttamente un insieme di file/moduli; non transitivo (un singolo oggetto o un array di oggetti)
• importConventions (opzionale): Array di regole per le convenzioni di import

Proprietà dei Confini dei Moduli

• name (obbligatoria): Nome del confine
• pattern (obbligatoria): Pattern glob per i file in questo confine
• allow (opzionale): Array di pattern di import consentiti
• deny (opzionale): Array di pattern di import negati (prevale su allow)

Proprietà delle Convenzioni di Import

• rule (obbligatoria): Tipo della regola, attualmente solo relative-internal-absolute-external
• autofix (opzionale): Se correggere automaticamente le violazioni delle convenzioni di import (predefinito: false)
• domains (obbligatoria): Array di definizioni di dominio. Può essere una stringa (pattern glob) o un oggetto con:
  • path (obbligatoria): Directory con i file del dominio
  • alias (opzionale): Alias da usare per gli import assoluti del codice di questo dominio
  • enabled (opzionale): Impostalo a false per saltare i controlli per questo dominio (predefinito: true)

Proprietà delle Opzioni di Rilevamento

Ogni proprietà di rilevamento può essere configurata come:

• un singolo oggetto (una istanza di detector), oppure
• un array di oggetti (più istanze di detector valutate all'interno dello stesso workspace).

CircularImportsDetection:

• enabled (obbligatoria): Abilita/disabilita il rilevamento degli import circolari
• ignoreTypeImports (opzionale): Esclude gli import solo di tipo durante la costruzione del grafo (predefinito: false)

DuplicatedCodeDetection:

• enabled (obbligatoria): Abilita/disabilita il rilevamento del codice duplicato
• blindIdentifiers (opzionale): Tratta i nomi come caratteri jolly, quindi una copia rinominata conta comunque (predefinito: false)
• blindStrings (opzionale): Tratta i contenuti di stringhe e template come caratteri jolly (predefinito: false)
• blindNumbers (opzionale): Tratta i letterali numerici come caratteri jolly (predefinito: false)
• minTokens (opzionale): Duplicazione minima da segnalare, in token (predefinito: 50)
• minLines (opzionale): Duplicazione minima da segnalare, in righe (predefinito: 3)
• minDepth (opzionale): Profondità di annidamento minima, contando il blocco stesso. 2 richiede almeno un livello annidato (predefinito: 0)
• minStatements (opzionale): Numero minimo di istruzioni; si applica solo ai blocchi di istruzioni (predefinito: 0)
• minDuplicates (opzionale): Quante copie deve avere un blocco prima di essere segnalato (predefinito: 2)
• skipObjects (opzionale): Non segnalare duplicazioni che sono solo literal di oggetti (predefinito: false)
• ignoreFiles (opzionale): Pattern glob da escludere dall'analisi
• snapshotPath (opzionale): Percorso di una baseline committata delle duplicazioni riconosciute, relativo al workspace. Con questo, il controllo segnala ciò che è cambiato anziché il totale

OrphanFilesDetection:

• enabled (obbligatoria): Abilita/disabilita il rilevamento dei file orfani
• validEntryPoints (opzionale): Array di pattern di punti di ingresso validi. Se omesso, usa i valori predefiniti prodEntryPoints + devEntryPoints a livello di workspace.
• ignoreTypeImports (opzionale): Esclude gli import solo di tipo durante la costruzione del grafo (predefinito: false)
• graphExclude (opzionale): Pattern di file da escludere dall'analisi del grafo
• autofix (opzionale): Elimina automaticamente i file orfani rilevati quando si esegue rev-dep config run --fix (predefinito: false)

UnusedNodeModulesDetection:

• enabled (obbligatoria): Abilita/disabilita il rilevamento dei moduli inutilizzati
• includeModules (opzionale): Pattern dei moduli da includere nell'analisi
• excludeModules (opzionale): Pattern dei moduli da escludere dall'analisi
• pkgJsonFieldsWithBinaries (opzionale): Campi di package.json contenenti riferimenti binari (ad es. lint-staged). Esegue una ricerca in testo semplice
• filesWithBinaries (opzionale): Pattern di file da cercare per l'uso dei binari. Esegue una ricerca in testo semplice
• filesWithModules (opzionale): Pattern di file non JS/TS da cercare per gli import di moduli (ad es. script shell). Esegue una ricerca in testo semplice
• outputType (opzionale): Formato di output - "list", "groupByModule", "groupByFile"

MissingNodeModulesDetection:

• enabled (obbligatoria): Abilita/disabilita il rilevamento dei moduli mancanti
• includeModules (opzionale): Pattern dei moduli da includere nell'analisi
• excludeModules (opzionale): Pattern dei moduli da escludere dall'analisi
• outputType (opzionale): Formato di output - "list", "groupByModule", "groupByFile", "groupByModuleFilesCount"

UnusedExportsDetection:

• enabled (obbligatoria): Abilita/disabilita il rilevamento delle esportazioni inutilizzate
• validEntryPoints (opzionale): Pattern glob per i file le cui esportazioni non vengono mai segnalate come inutilizzate. Se omesso, usa i valori predefiniti prodEntryPoints + devEntryPoints a livello di workspace.
• ignoreTypeExports (opzionale): Salta export type / export interface dall'analisi (predefinito: false)
• graphExclude (opzionale): Pattern di file da escludere dall'analisi delle esportazioni inutilizzate
• ignore (opzionale): Mappa di pattern glob dei percorsi file (relativi alla directory del percorso del workspace) verso pattern glob del nome/specificatore di esportazione da sopprimere; ogni valore può essere una stringa o un array di stringhe
• ignoreFiles (opzionale): Pattern glob dei percorsi file; tutte le esportazioni inutilizzate dei file corrispondenti vengono soppresse
• ignoreExports (opzionale): Nomi/specificatori di esportazione (o glob) da sopprimere globalmente (supporta "default")
• autofix (opzionale): Applica automaticamente le modifiche correggibili delle esportazioni inutilizzate quando si esegue rev-dep config run --fix (predefinito: false)

UnresolvedImportsDetection:

• enabled (obbligatoria): Abilita/disabilita il rilevamento degli import non risolti
• ignore (opzionale): Mappa di pattern glob dei percorsi file (relativi alla directory del percorso del workspace) verso pattern glob della richiesta di import da sopprimere; ogni valore può essere una stringa o un array di stringhe
• ignoreFiles (opzionale): Pattern glob dei percorsi file; tutti gli import non risolti dei file corrispondenti vengono soppressi
• ignoreImports (opzionale): Richieste di import (o glob) da sopprimere globalmente nei risultati non risolti

DevDepsUsageOnProdDetection:

• enabled (obbligatoria): Abilita/disabilita il rilevamento dell'uso limitato delle dipendenze di sviluppo
• prodEntryPoints (opzionale): Pattern dei punti di ingresso di produzione da cui tracciare le dipendenze. Se omesso, usa i valori predefiniti prodEntryPoints a livello di workspace.
• ignoreTypeImports (opzionale): Esclude gli import solo di tipo dall'attraversamento del grafo e dalla corrispondenza dei moduli (predefinito: false)

RestrictedImportsDetection:

• enabled (obbligatoria): Abilita/disabilita il rilevamento degli import limitati
• entryPoints (obbligatoria quando abilitata): Pattern dei punti di ingresso usati per costruire il grafo delle dipendenze raggiungibili (i punti di ingresso a livello di workspace non vengono applicati qui)
• graphExclude (opzionale): Pattern di file da escludere dall'analisi del grafo degli import limitati
• denyFiles (opzionale): Pattern di percorsi file negati (ad es. ["**/*.tsx"])
• denyModules (opzionale): Pattern di moduli negati (ad es. ["react", "react-*"])
• ignoreMatches (opzionale): Pattern di file/moduli da sopprimere dai risultati degli import limitati
• ignoreTypeImports (opzionale): Esclude gli import solo di tipo dall'attraversamento (predefinito: false)

Vantaggi in Termini di Prestazioni

L'approccio basato sulla configurazione offre notevoli vantaggi in termini di prestazioni:

• Costruzione di un Singolo Albero delle Dipendenze: Costruisce un unico albero completo delle dipendenze per tutti i workspace
• Esecuzione Parallela dei Workspace: Elabora più workspace simultaneamente
• Esecuzione Parallela dei Controlli: Esegue tutti i controlli abilitati all'interno di ciascun workspace in parallelo
• Individuazione Ottimizzata dei File: Individua i file una sola volta e li riutilizza in tutti i controlli

Questo rende i controlli basati sulla configurazione più veloci rispetto all'esecuzione sequenziale di singoli comandi, soprattutto per codebase di grandi dimensioni con più sottopacchetti.

Toolkit Esplorativo 🔧

Esempi pratici mostrano come usare i comandi CLI di rev-dep per esplorare, eseguire il debug o creare controlli di qualità del codice per il tuo progetto.

Come identificare dove un file viene utilizzato nel progetto```

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

Vedrai tutti i punti di ingresso che richiedono implicitamente quel file, insieme ai percorsi di risoluzione.

### **Come verificare se un file viene utilizzato**```
rev-dep resolve --file path/to/file.ts --compact-summary

Mostra quanti punti di ingresso dipendono indirettamente dal file.

Come identificare i file morti```

rev-dep entry-points

Escludi i punti di ingresso del framework se necessario usando `--result-exclude`.

Ad esempio, escludi i punti di ingresso validi di Next.js quando utilizzi il pages router, escludi la directory scripts - gli script sono punti di ingresso validi - ed escludi tutti i file di test:```
rev-dep entry-points --result-exclude "pages/**","scripts/**","**/*.test.*"

Come elencare tutti i file importati da un punto di ingresso```

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

Utile per identificare componenti pesanti o dipendenze indesiderate.

### **Come ridurre le importazioni superflue per un punto di ingresso**

1. Elenca tutti i file importati:   ```
   rev-dep files --entry-point path/to/entry.ts

2. Identificare i file sospetti.
3. Tracciare il motivo per cui sono inclusi: ``` rev-dep resolve --file path/to/suspect --entry-points path/to/entry.ts --all
   root@kitploit:~

Come rilevare le dipendenze circolari```

rev-dep circular

### **Come rilevare il codice duplicato**```
rev-dep duplicated-code

Segnala blocchi di codice e elementi JSX ripetuti - unità che puoi estrarre - piuttosto che righe ripetute. Aggiungi --blind-identifiers per individuare copie le cui variabili sono state rinominate.

Come trovare moduli node inutilizzati```

rev-dep node-modules unused

### **Come trovare i moduli node mancanti**```
rev-dep node-modules missing

Come controllare l'utilizzo dello spazio di node_modules```

rev-dep node-modules dirs-size

### **Come rilevare le dipendenze di sviluppo utilizzate nel codice di produzione**```
rev-dep config run

Quando devDepsUsageOnProdDetection è abilitato nella tua configurazione, rev-dep:

1. Traccia i grafi delle dipendenze dai punti di ingresso di produzione specificati
2. Identifica tutti i file raggiungibili da quei punti di ingresso
3. Controlla se eventuali moduli importati sono elencati in devDependencies nel package.json
4. Segnala le violazioni mostrando quali dipendenze di sviluppo vengono utilizzate e dove

Output di esempio:``` ❌ 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)

**Note importanti:**
- Gli import di soli tipi (es. `import type { ReactNode } from 'react'`) vengono ignorati quando `ignoreTypeImports` è abilitato
- Vengono segnalate solo le dipendenze da `devDependencies` in package.json
- Le dipendenze di produzione da `dependencies` sono consentite
- Aiuta a prevenire errori di runtime nelle build di produzione

## Lavorare con Monorepo 🏗️

Rev-dep offre supporto di prima classe per progetti monorepo, consentendo un'analisi accurata delle dipendenze tra i pacchetti del workspace.

### Flag followMonorepoPackages

Il flag `--follow-monorepo-packages` abilita la risoluzione degli import dai pacchetti del workspace monorepo. Per impostazione predefinita, questo flag è impostato su `false` per mantenere la compatibilità con progetti a pacchetto singolo.```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

Quando attivato, rev-dep:

• Rileva automaticamente i pacchetti del workspace esaminando la configurazione del monorepo
• Risolve le importazioni tra i pacchetti all'interno del workspace
• Segue le esportazioni di package.json per una corretta risoluzione dei moduli

Supporto della mappa delle esportazioni

Rev-dep supporta completamente il campo exports nei file package.json, che è il metodo standard per definire i punti di ingresso dei pacchetti nei moderni progetti Node.js.

Il supporto della mappa delle esportazioni include:

• Esportazioni condizionali che utilizzano condizioni come node, import, default e condizioni personalizzate
• Pattern con caratteri jolly per una mappatura flessibile dei sottopercorsi
• Sintassi zuccherina per definizioni semplici di esportazione principale
• Condizioni annidate per scenari di risoluzione complessi

Flag dei nomi delle condizioni

Per controllare quali esportazioni condizionali vengono risolte, usa il flag --condition-names. Questo consente di specificare la priorità delle condizioni durante la risoluzione delle esportazioni dei pacchetti:```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

Le condizioni vengono elaborate nell'ordine specificato, utilizzando la prima condizione corrispondente. Le condizioni comuni includono:
- `node` - Ambiente Node.js
- `import` - Moduli ES
- `require` - CommonJS
- `default` - Condizione di fallback
- Condizioni personalizzate specifiche del tuo progetto o dei tuoi strumenti di build

Esempio di package.json con 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"
  }
}

Come funziona la risoluzione nei monorepo

1. Rilevamento del monorepo: Quando followMonorepoPackages è abilitato, rev-dep cerca la configurazione del workspace (pnpm-workspace.yaml, package.json workspaces, ecc.)

2. Risoluzione dei pacchetti: Gli import verso i pacchetti del workspace vengono risolti usando la configurazione di "exports" del pacchetto, ricadendo sui campi main/module quando "exports" non è definito.

3. Validazione delle dipendenze: Lo strumento verifica che gli import tra pacchetti siano consentiti solo se il pacchetto di destinazione è elencato nelle dependencies o devDependencies del consumer.

4. Risoluzione dei percorsi: Tutti i percorsi vengono risolti rispetto alla radice del rispettivo pacchetto, garantendo un tracciamento accurato delle dipendenze nell'intero monorepo.

Questo rende rev-dep particolarmente efficace per progetti monorepo su larga scala, dove comprendere le dipendenze tra pacchetti è fondamentale per mantenere la qualità del codice e l'architettura.

Confronto delle prestazioni ⚡

Rev-dep può eseguire più controlli su un monorepo con oltre 500k righe di codice e diversi sotto-pacchetti in circa 150ms.

Supera Madge, dpdm, dependency-cruiser, skott, knip, depcheck e altri strumenti simili.

Ecco un confronto delle prestazioni di attività specifiche tra rev-dep e le alternative:

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

Misurazioni: hyperfine -w 4 -r 8 (4 riscaldamenti + 8 esecuzioni misurate)

Progetto: 580k righe di codice, 6024 file di codice sorgente di un'app next.js

Confronto delle prestazioni del controllo circolare

La tabella seguente presenta un confronto delle prestazioni tra diversi strumenti che eseguono il rilevamento delle importazioni circolari.

Il controllo circolare di rev-dep è ~20 volte più veloce dell'alternativa più rapida.

* knip ignora sempre gli archi di importazione di soli tipi (type-only) e non offre alcuna opzione per includerli. Ogni ciclo in questo codebase ne contiene almeno uno, quindi knip segnala 0 cicli - i suoi 3 040 ms sono una vera analisi completa, solo di un grafo più piccolo. rev-dep circular -t, che applica la stessa regola, concorda esattamente (0 cicli) in 143.3 ms ± 10.3.

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

Misurazioni: hyperfine -w 4 -r 8 (4 riscaldamenti + 8 esecuzioni misurate)

Progetto: 580k righe di codice, 6024 file di codice sorgente di un'app next.js

Consulta le misurazioni dettagliate con il tempo medio e i comandi usati in PERFORMANCE.md.

Riferimento CLI 📖

rev-dep circular

Rileva le dipendenze circolari nel tuo progetto

Sinossi

Analizza il progetto per trovare dipendenze circolari tra i moduli. Le dipendenze circolari possono causare problemi difficili da debuggare e dovrebbero generalmente essere evitate.``` rev-dep circular [flags]

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

Opzioni```

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

Crea ed esegui file di configurazione rev-dep

#### Sinossi

Comandi per creare ed eseguire file di configurazione rev-dep.

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

rev-dep config run

Esegue tutti i controlli definiti in (.)rev-dep.config.json(c)

Sinossi

Elabora (.)rev-dep.config.json(c) ed esegue tutti i controlli abilitati (import circolari, file orfani, confini dei moduli, convenzioni di import, moduli node, export non utilizzati, import non risolti, import limitati e utilizzo limitato delle dipendenze di sviluppo) per ogni workspace.``` rev-dep config run [flags]

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

Inizializza un nuovo file rev-dep.config.json

Sinossi

Crea un nuovo file di configurazione rev-dep.config.json nella directory corrente con le impostazioni predefinite.``` rev-dep config init [flags]

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

rev-dep config lint

Segnala (e opzionalmente rimuove) i pattern glob/percorso di configurazione che non corrispondono a nulla

Sinossi

Esegue la scansione di un (.)rev-dep.config.json(c) per individuare i pattern glob e di percorso "morti" - pattern da ignorare, pattern di punti di ingresso, percorsi di workspace, esclusioni dal grafo, file/moduli negati e simili - che non corrispondono più ad alcun file o modulo scoperto. Con il tempo le configurazioni accumulano pattern per file che sono stati rinominati o eliminati; questo comando li fa emergere così la configurazione resta snella.

Con --fix, i pattern morti vengono rimossi sul posto, preservando tutti i commenti e la formattazione. Alcuni pattern vengono segnalati ma non vengono mai rimossi automaticamente, perché eliminarli potrebbe modificare il comportamento di un controllo o rendere la configurazione non valida: percorsi di workspace, punti di ingresso / file / moduli richiesti e selettori di confine di modulo. Questi sono contrassegnati come "non rimossi automaticamente"; risolvili a mano.``` rev-dep config lint [flags]

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

Aggiorna una configurazione v2 allo schema v3 (2.0)

Sinossi

Aggiorna un (.)rev-dep.config.json(c) dallo schema v2 al v3 (config version 2.0).

Applica le modifiche sicure e non ambigue sul posto (rinominando l'array 'rules' di primo livello in 'workspaces', portando 'configVersion' a 2.0 e rimuovendo l'opzione 'algorithm' non più supportata dai rilevatori circular-imports), preservando tutti i commenti e la formattazione. Rivedi la modifica con git prima di eseguire il commit.

Elenca quindi ciò che NON può modificare al posto tuo: i pattern glob il cui insieme di corrispondenze potrebbe essere cambiato con le regole più rigorose di v3, allineate a gitignore, e i cambiamenti di comportamento che nessuna modifica alla configurazione può affrontare. Rivedi questi manualmente - vedi la guida alle modifiche di rottura di v3.``` rev-dep config migrate [flags]

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

rev-dep debug

Strumenti di debug per ispezionare le componenti interne di parser e resolver

Sinossi

Strumenti di debug per ispezionare come rev-dep analizza i file e risolve le dipendenze. L'output non segue semver.

Opzioni```

-h, --help help for debug

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

Debug: mostra l'albero delle dipendenze completo per l'analisi

#### Sinossi

Strumento di debug per ispezionare l'albero delle dipendenze completo. L'output non segue semver.```
rev-dep debug get-tree-for-cwd [flags]

Opzioni```

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

Elenca tutti i file nella directory di lavoro corrente

#### Sinossi

Elenca ricorsivamente tutti i file nella directory specificata,
con opzioni per filtrare i risultati.```
rev-dep debug list-cwd-files [flags]

Esempi```

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

#### Opzioni```
      --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: Mostra le importazioni analizzate per un singolo file

Sinossi

Strumento di debug per ispezionare come il parser elabora un file specifico. L'output non segue semver.``` rev-dep debug parse-file [flags]

#### Opzioni```
      --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: Mostra gli alias di configurazione TypeScript analizzati

Sinossi

Strumento di debug per ispezionare come viene analizzata la configurazione TypeScript e quali alias vengono estratti. L'output non segue il semver.``` rev-dep debug parse-tsconfig [flags]

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

rev-dep duplicated-code

Trova codice duplicato tra (e all'interno di) i file del progetto.

Sinossi

Scansiona ogni file sorgente per individuare frammenti copiabili - blocchi tra parentesi graffe ed elementi JSX, a ogni livello di annidamento - e segnala quelli che compaiono più di una volta.

Il confronto ignora completamente formattazione e commenti, quindi copie con indentazione modificata vengono comunque rilevate.

Quattro filtri determinano cosa vale la pena segnalare. --min-tokens e --min-lines misurano la dimensione; --min-depth e --min-statements misurano la complessità, che è ciò che distingue un oggetto di configurazione duplicato con tre chiavi dalla logica duplicata - nessuna soglia minima di dimensione può farlo, perché le chiavi dell'oggetto e i valori stringa possono essere lunghi. --min-duplicates imposta quante copie servono per qualificarsi.

Per impostazione predefinita, il codice deve corrispondere così com'è scritto. Ogni flag --blind-* rimuove una categoria di token dal confronto e si combinano liberamente:

--blind-identifiers i nomi sono jolly, quindi una copia le cui variabili, funzioni o componenti sono stati rinominati viene comunque segnalata --blind-strings i contenuti di stringhe e template sono jolly --blind-numbers i letterali numerici sono jolly``` rev-dep duplicated-code [flags]

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

Opzioni```

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

Scopri ed elenca tutti i punti di ingresso nel progetto

#### Sintesi

Analizza la struttura del progetto per identificare tutti i potenziali punti di ingresso.
Utile per comprendere l'architettura e le dipendenze della tua applicazione.```
rev-dep entry-points [flags]

Esempi```

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

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

Elenca tutti i file nell'albero delle dipendenze di un punto di ingresso

Sinossi

Trova e elenca ricorsivamente tutti i file richiesti dal punto di ingresso specificato.``` rev-dep files [flags]

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

Opzioni```

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

Elenca tutti i file che importano direttamente il file specificato

#### Sinossi

Trova ed elenca tutti i file nel progetto che importano direttamente il file specificato.
Ciò è utile per comprendere l'impatto delle modifiche a un particolare file.```
rev-dep imported-by [flags]

Esempi```

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

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

Conta le righe di codice effettive nel progetto escludendo commenti e righe vuote.``` rev-dep lines-of-code [flags]

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

Opzioni```

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

### rev-dep list-cwd-files

Elenca tutti i file nella directory di lavoro corrente

#### Sinossi

Elenca ricorsivamente tutti i file nella directory specificata,
con opzioni per filtrare i risultati.```
rev-dep list-cwd-files [flags]

Esempi```

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

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

Elenca gli import non risolti nel progetto

Sinossi

Rileva ed elenca gli import che non è stato possibile risolvere durante la risoluzione degli import. Raggruppa gli import per file.``` rev-dep unresolved [flags]

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

Analizza e gestisci le dipendenze Node.js

Sinossi

Strumenti per analizzare e gestire le dipendenze dei moduli Node.js. Aiuta a identificare dipendenze inutilizzate, mancanti o duplicate nel tuo progetto.

Esempi```

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

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

rev-dep node-modules analyze-size

Analizza l'utilizzo del disco di node_modules

Sinossi

Fornisce un'analisi dettagliata della dimensione della directory node_modules. Aiuta a identificare le dipendenze che occupano più spazio.``` rev-dep node-modules analyze-size [flags]

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

Opzioni```

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

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

Calcola la dimensione cumulativa dei file nelle directory node_modules

#### Sinossi

Calcola e visualizza la dimensione delle cartelle node_modules
nella directory corrente e nelle sottodirectory. Le dimensioni saranno inferiori alla dimensione effettiva del file occupata su disco. Lo strumento calcola la dimensione effettiva del file piuttosto che la dimensione su disco (relativa all'uso dei blocchi del disco).```
rev-dep node-modules dirs-size [flags]

Esempi```

rev-dep node-modules dirs-size

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

rev-dep node-modules installed-duplicates

Trova e ottimizza le installazioni di pacchetti duplicati

Sinossi

Identifica i pacchetti installati più volte in node_modules. Può ottimizzare lo storage creando symlink tra i pacchetti duplicati.``` rev-dep node-modules installed-duplicates [flags]

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

Opzioni```

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

Elenca tutti i pacchetti npm installati nel progetto

#### Sinossi

Esegue una scansione ricorsiva delle directory node_modules per elencare tutti i pacchetti installati.
Utile per controllare le dipendenze nei monorepo.```
rev-dep node-modules installed [flags]

Esempi```

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

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

Trova i pacchetti importati non elencati in package.json

Sinossi

Identifica i pacchetti importati nel tuo codice ma non dichiarati nelle dipendenze del tuo package.json.``` rev-dep node-modules missing [flags]

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

Opzioni```

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

Rimuove i file simili a markdown/docs dai pacchetti node_modules installati

#### Sinossi

Rimuove i file dai pacchetti node_modules installati in base a pattern glob.
Utile per eliminare file README/LICENSE/docs per ridurre la dimensione delle dipendenze.```
rev-dep node-modules prune-docs [flags]

Esempi```

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"

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

Trova i pacchetti installati che non vengono importati nel tuo codice

Sinossi

Confronta le dipendenze package.json con gli import effettivi nella tua base di codice per identificare pacchetti potenzialmente inutilizzati.``` rev-dep node-modules unused [flags]

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

Opzioni```

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

Elenca tutti i pacchetti npm importati nel tuo codice

#### Sinossi

Analizza il tuo codice per identificare quali pacchetti npm sono realmente in uso.
Aiuta a tenere traccia delle dipendenze runtime del tuo progetto.```
rev-dep node-modules used [flags]

Esempi```

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

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

Traccia e mostra il percorso delle dipendenze tra i file del tuo progetto

Sinossi

Analizza e mostra la catena di dipendenze tra i file specificati. Aiuta a capire come le diverse parti del tuo codebase sono collegate.``` rev-dep resolve [flags]

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

Opzioni```

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


## Glossario 📚

Alcuni termini usati nello spazio del problema coperto da **rev-dep** possono creare confusione.
Ecco un piccolo glossario per aiutarti a orientarti tra i concetti.

### Dipendenza

Una *dipendenza* può essere intesa alla lettera. Nel contesto del grafo delle dipendenze di un progetto, può riferirsi a:

* un **modulo / pacchetto node** (un pacchetto è una dipendenza di un progetto o di un file), oppure
* un **file di codice sorgente** (un file è una dipendenza di un altro file se lo importa).

### Punto di ingresso

Un *punto di ingresso* è un file sorgente che **non viene importato da nessun altro file**.
Può rappresentare:

* il punto di ingresso principale dell'applicazione
* una singola pagina o funzionalità
* file di configurazione o bootstrap dei test

- a seconda della struttura del progetto.

### File inutilizzato / morto

Un file è considerato *inutilizzato* o *morto* quando:

* è un **punto di ingresso** (nulla lo importa), **e**
* eseguirlo **non produce alcun output significativo** né effetto collaterale.

In pratica, questi file possono spesso essere rimossi senza problemi.

### Dipendenza circolare

Una *dipendenza circolare* si verifica quando un file **importa sé stesso direttamente o indirettamente** attraverso una catena di import.

Questo può portare a comportamenti imprevedibili a runtime, valori non inizializzati o bug sottili.
Tuttavia, le dipendenze circolari tra **import di soli tipi TypeScript** sono generalmente innocue.

### Dipendenza inversa (o "dipendenti")

File che *importano* un determinato file.
Utili per rispondere alla domanda: "Cosa si rompe se modifico o elimino questo file?"

### Grafo di import / Grafo delle dipendenze

Una rappresentazione visiva di come file o moduli si importano a vicenda.

### Dipendenza mancante / modulo node non dichiarato

Un modulo che il tuo codice importa ma che **non è elencato in package.json**.

### Dipendenza inutilizzata / modulo node inutilizzato

Una dipendenza elencata in **package.json** che **non viene mai importata** nel codice sorgente.

### Directory root / Root del progetto

La directory di primo livello usata come punto di partenza per l'analisi delle dipendenze.

## Telemetria

Rev-Dep raccoglie un singolo evento **anonimo**, solo durante `rev-dep config run`. Leggi di più nella [documentazione sulla telemetria](https://rev-dep.com/docs/telemetry).

Per disattivarla completamente, imposta `REV_DEP_TELEMETRY_OFF=true`.

## Fatto in 🇵🇱 e 🇯🇵 con 🧠 da [@jayu](https://github.com/jayu)

Spero che questo piccolo software ti aiuti a scoprire e comprendere la complessità del tuo progetto e quindi ti renda più sicuro durante il refactoring. Se questo strumento ti è stato utile, non esitare a lasciare una ⭐!

### I miei altri progetti

- [CodeQue - Ricerca strutturale del codice](https://codeque.co)
- [Structural Code Search VSCode](https://marketplace.visualstudio.com/items?itemName=CodeQue.codeque)