Trova i pacchetti npm inutilizzati in package.json

Esiste un modo per determinare se nel file package.json sono presenti pacchetti che non sono più necessari?

Ad esempio, quando provo un pacchetto e successivamente commentando o eliminando il codice, ma dimenticandomi di disinstallarlo, finisco con un paio di pacchetti che potrebbero essere eliminati.

Quale sarebbe un modo efficace per determinare se un pacchetto potrebbe essere eliminato in modo sicuro?

È possibile utilizzare un modulo npm chiamato depcheck (richiede almeno la versione 10 di Node).

1. Installa il modulo:

   npm install depcheck -g
   
   or
   
   yarn global add depcheck

2. Eseguilo e trova le dipendenze non utilizzate:

   depcheck

La cosa buona di questo approccio è che non devi ricordare il comando findo grep.

Per eseguire senza installare utilizzare npx:

npx depcheck

C'è anche un pacchetto chiamato npm-check:

NPM-check

Verificare la presenza di dipendenze obsolete, errate e non utilizzate.

È abbastanza potente e sviluppato attivamente. Una delle sue caratteristiche è la verifica delle dipendenze non utilizzate - per questa parte utilizza ildepcheck modulo menzionato nell'altra risposta.

Se si utilizza un sistema operativo Unix come (Linux, OSX, ecc.), È possibile utilizzare una combinazione di finde egrepper cercare istruzioni obbligatorie contenenti il ​​nome del pacchetto:

find . -path ./node_modules -prune -o -name "*.js" -exec egrep -ni 'name-of-package' {} \;

Se cerchi l'intera require('name-of-package')istruzione, ricorda di utilizzare il tipo corretto di virgolette:

find . -path ./node_modules -prune -o -name "*.js" -exec egrep -ni 'require("name-of-package")' {} \;

o

find . -path ./node_modules -prune -o -name "*.js" -exec egrep -ni "require('name-of-package')" {} \;

Il rovescio della medaglia è che non è completamente automatico, cioè non estrae i nomi dei pacchetti da package.jsone li controlla. È necessario farlo da soli per ogni pacchetto. Dato che package.jsonè solo JSON, questo potrebbe essere risolto scrivendo un piccolo script che utilizza child_process.execper eseguire questo comando per ogni dipendenza. E trasformalo in un modulo. E aggiungilo al repository NPM ...

fiskeben ha scritto:

Il rovescio della medaglia è che non è completamente automatico, cioè non estrae i nomi dei pacchetti da package.json e li controlla. È necessario farlo da soli per ogni pacchetto.

Rendiamo automatizzata la risposta di Fiskeben se per qualsiasi motivo depcheck non funziona correttamente! (Ad esempio, l'ho provato con Typescript e ha dato errori di analisi non necessari)

Per l'analisi package.jsonpossiamo usare il software jq. Lo script di shell sottostante richiede un nome di directory da cui iniziare.

#!/bin/bash
DIRNAME=${1:-.}
cd $DIRNAME

FILES=$(mktemp)
PACKAGES=$(mktemp)

find . \
    -path ./node_modules -prune -or \
    -path ./build -prune -or \
    \( -name "*.ts" -or -name "*.js" -or -name "*.json" \) -print > $FILES

function check {
    cat package.json \
        | jq "{} + .$1 | keys" \
        | sed -n 's/.*"\(.*\)".*/\1/p' > $PACKAGES

    echo "--------------------------"
    echo "Checking $1..."
    while read PACKAGE
    do
        RES=$(cat $FILES | xargs -I {} egrep -i "(import|require).*['\"]$PACKAGE[\"']" '{}' | wc -l)
        if [ $RES = 0 ]
        then
            echo -e "UNUSED\t\t $PACKAGE"
        else
            echo -e "USED ($RES)\t $PACKAGE"
        fi
    done < $PACKAGES
}

check "dependencies"
check "devDependencies"
check "peerDependencies"

Innanzitutto crea due file temporanei in cui è possibile memorizzare nella cache nomi e file dei pacchetti.

Si inizia con il findcomando. La prima e la seconda riga lo fanno ignorare node_modulesebuild cartelle (o qualunque cosa tu voglia). La terza riga contiene estensioni consentite, puoi aggiungerne altre qui, ad es. File JSX o JSON.

Una funzione leggerà i tipi dipendenti.

Prima è catil package.json. Quindi, jqottiene il gruppo di dipendenze richiesto. ( {} +esiste in modo tale da non generare un errore se ad esempio non ci sono dipendenze tra pari nel file.)

Successivamente, sedestrae le parti tra virgolette, il nome del pacchetto. -ne gli .../pdice di stampare le parti corrispondenti e nient'altro jqdall'output JSON di. Quindi leggiamo questo elenco di nomi di pacchetti in un whileciclo.

RESè il numero di occorrenze del nome del pacchetto tra virgolette. In questo momento è import/ require... 'package'/"package" . Fa il lavoro per la maggior parte dei casi.

Quindi contiamo semplicemente il numero di righe del risultato, quindi stampiamo il risultato.

Avvertenze:

• Non troverai file in diverse importazioni, ad es. tsconfig.jsonFile (lib opzione)
• Devi grepmanualmente solo per ^USEDe UNUSEDfile.
• È lento per progetti di grandi dimensioni: gli script di shell spesso non si adattano bene. Ma spero che non correrai così tante volte.

A tale scopo possiamo utilizzare il modulo npm in basso:

https://www.npmjs.com/package/npm-check-unused

molte delle risposte qui sono come trovare oggetti inutilizzati.

Volevo rimuoverli automaticamente .

1. Installa questo progetto nodo.

   $ npm install -g typescript tslint tslint-etc

2. Nella directory principale, aggiungere un nuovo file tslint-imports.json

   { "extends": [ "tslint-etc" ], "rules": { "no-unused-declaration": true } }

3. Esegui questo a tuo rischio, fai un backup :)

   $ tslint --config tslint-imports.json --fix --project .