Uno strumento per la gestione di progetti JavaScript con più pacchetti.

  • Informazioni su
  • Guida introduttiva
  • Come funziona
  • Risoluzione dei problemi
  • Comandi
  • Varie
  • Lerna.json
  • Flags

About

Suddividere grandi basi di codice in pacchetti separati con versioni indipendenti è estremamente utile per la condivisione del codice. Tuttavia, apportare modifiche a molti repository è disordinato e difficile da monitorare, e il test tra i repository diventa complicato molto velocemente.

Per risolvere questi (e molti altri) problemi, alcuni progetti organizzeranno le loro basi di codice in repository multi-pacchetto (a volte chiamati monorepos). Progetti come Babel, React, Angular, Ember, Meteor, Jest e molti altri sviluppano tutti i loro pacchetti all’interno di un singolo repository.

Lerna è uno strumento che ottimizza il flusso di lavoro intorno alla gestione di repository multi-pacchetto con git e npm.

Lerna può anche ridurre i requisiti di tempo e spazio per numerose copie di pacchetti negli ambienti di sviluppo e compilazione – normalmente uno svantaggio di dividere un progetto in molti pacchetti NPM separati. Vedere la documentazione hoist per i dettagli.

Che aspetto ha un repository Lerna?

In realtà c’è molto poco da fare. Hai un file system che assomiglia a questo:

my-lerna-repo/ package.json packages/ package-1/ package.json package-2/ package.json

Cosa può fare Lerna?

I due comandi principali in Lerna sono lerna bootstrape lerna publish.

bootstrap collegherà le dipendenze nel repository insieme. publish aiuterà a pubblicare tutti i pacchetti aggiornati.

Guida introduttiva

Le istruzioni riportate di seguito sono per Lerna 2.x. Si consiglia di utilizzare al posto di 1.x per un nuovo progetto Lerna. Controlla il wiki se hai bisogno di vedere il 1.x LEGGIMI.

Iniziamo installando Lerna globalmente con npm.

$ npm install --global lerna

Successivamente creeremo un nuovo repository git:

$ git init lerna-repo$ cd lerna-repo

E ora trasformiamolo in un repo di Lerna:

$ lerna init

Il tuo repository dovrebbe ora assomigliare a questo:

lerna-repo/ packages/ package.json lerna.json

Questo creerà un file di configurazione lerna.json e una cartella packages.

Come funziona

Lerna consente di gestire il progetto utilizzando una delle due modalità: Fissa o Indipendente.

Modalità fissa/bloccata (default)

Modalità fissa I progetti Lerna operano su una singola riga di versione. La versione è conservata nel file lerna.json alla radice del progetto sotto la chiave version. Quando esegui lerna publish, se un modulo è stato aggiornato dall’ultima volta che è stata effettuata una versione, verrà aggiornato alla nuova versione che stai rilasciando. Ciò significa che si pubblica solo una nuova versione di un pacchetto quando è necessario.

Questa è la modalità che Babel sta attualmente utilizzando. Usalo se vuoi legare automaticamente tutte le versioni del pacchetto. Un problema con questo approccio è che un cambiamento importante in qualsiasi pacchetto comporterà che tutti i pacchetti abbiano una nuova versione principale.

Modalità indipendente (independent indipendente)

Modalità indipendente Lerna projects consente ai manutentori di incrementare le versioni dei pacchetti indipendentemente l’una dall’altra. Ogni volta che pubblichi, riceverai un prompt per ogni pacchetto che è stato modificato per specificare se si tratta di una modifica patch, minore, maggiore o personalizzata.

La modalità indipendente consente di aggiornare in modo più specifico le versioni per ciascun pacchetto e ha senso per un gruppo di componenti. La combinazione di questa modalità con qualcosa come il rilascio semantico lo renderebbe meno doloroso. (C’è lavoro su questo già su atlassian / lerna-semantic-release).

Il tasto version in lerna.json viene ignorato in modalità indipendente.

Risoluzione dei problemi

Se si riscontrano problemi durante l’utilizzo di Lerna, consultare il nostro documento di risoluzione dei problemi in cui è possibile trovare la risposta al problema.

Domande frequenti

Vedi FAQ.md.

Comandi

init

$ lerna init

Crea un nuovo repository Lerna o aggiorna un repository esistente alla versione corrente di Lerna.

Lerna presuppone che il repository sia già stato inizializzato con git init.

Quando viene eseguito, questo comando:

  1. Aggiungi lerna come devDependency in package.json se non esiste già.
  2. Crea un file di configurazione lerna.json per memorizzare il numero version.

Esempio di output su un nuovo repository git:

$ lerna initlerna info version v2.0.0lerna info Updating package.jsonlerna info Creating lerna.jsonlerna success Initialized Lerna files

–indipendente, – i

$ lerna init --independent

Questo flag indica a Lerna di utilizzare la modalità di versioning indipendente.

exact exact

$ lerna init --exact

Per impostazione predefinita, lerna init utilizzerà un intervallo di cursore quando si aggiunge o si aggiorna la versione locale di lerna, proprio come npm install --save-dev lerna.

Per mantenere il lerna 1.x comportamento di confronto “esatto”, passare questa bandiera. Configurerà lerna.json per applicare la corrispondenza esatta per tutte le esecuzioni successive.

{ "lerna": "2.0.0", "command": { "init": { "exact": true } }, "version": "0.0.0"}

bootstrap

$ lerna bootstrap

Bootstrap i pacchetti nel repository Lerna corrente. Installa tutte le loro dipendenze e collega eventuali dipendenze incrociate.

Quando viene eseguito, questo comando:

  1. npm install tutte le dipendenze esterne di ciascun pacchetto.
  2. Collega simbolicamente tutte le Lerna packages che sono dipendenze l’una dall’altra.
  3. npm prepublish tutti i pacchetti bootstrap.

lerna bootstrap rispetta i flag --ignore, --scope e --include-filtered-dependencies (vedi Flag).

Passa argomenti extra al client npm posizionandoli dopo --:

$ lerna bootstrap -- --production --no-optional

Può anche essere configurato in lerna.json:

{ ... "npmClient": "yarn", "npmClientArgs": }

Come funziona bootstrap

Usiamo babel come esempio.

  • babel-generator e source-map(tra gli altri) sono dipendenze di babel-core.
  • babel-core‘s package.json elenca entrambi questi pacchetti come chiavi in dependencies, come mostrato di seguito.
// babel-core package.json{ "name": "babel-core", ... "dependencies": { ... "babel-generator": "^6.9.0", ... "source-map": "^0.5.0" }}
  • Lerna controlla se ogni dipendenza è anche parte del repository Lerna.
    • In questo esempio, babel-generator può essere una dipendenza interna, mentre source-map è sempre una dipendenza esterna.
    • La versione di babel-generator in package.json di babel-core è soddisfatta da packages/babel-generator, passando per una dipendenza interna.
    • source-mapè npm installed (o yarn ed) come normale.
  • packages/babel-core/node_modules/babel-generator collegamenti simbolici a packages/babel-generator
  • Ciò consente l’importazione di directory nidificate

Note:

  • Quando una versione di dipendenza in un pacchetto non è soddisfatta da un pacchetto con lo stesso nome nel repository, sarà npm installed (o yarned) come normale.
  • Dist-tag, come latest, non soddisfano gli intervalli di semver.
  • Le dipendenze circolari generano collegamenti simbolici circolari che possono influire sul tuo editor/IDE.

Webstorm si blocca quando sono presenti collegamenti simbolici circolari. Per evitare ciò, aggiungere node_modules all’elenco di file e cartelle ignorati in Preferences | Editor | File Types | Ignored files and folders.

pubblica

$ lerna publish

Pubblica i pacchetti nel progetto Lerna corrente. Quando viene eseguito, questo comando esegue le seguenti operazioni:

Crea una nuova versione dei pacchetti che sono stati aggiornati. Richiede una nuova versione. Crea un nuovo commit / tag git nel processo di pubblicazione su npm.

Più specificamente, questo comando:

  1. Eseguire l’equivalente di lerna updated per determinare quali pacchetti devono essere pubblicati.
  2. Se necessario, incrementare la chiave version in lerna.json.
  3. Aggiorna il package.json di tutti i pacchetti aggiornati alle loro nuove versioni.
  4. Aggiorna tutte le dipendenze dei pacchetti aggiornati con le nuove versioni, specificate con un cursore (^).
  5. Crea un nuovo commit e tag git per la nuova versione.
  6. Pubblica pacchetti aggiornati su npm.

Lerna non pubblicherà pacchetti contrassegnati come privati ("private": true in package.json).

–esatto

$ lerna publish --exact

Quando viene eseguito con questo flag, publishspecificherà esattamente le dipendenze aggiornate nei pacchetti aggiornati (senza punteggiatura), anziché come compatibili con semver (con un ^).

Per ulteriori informazioni, vedere il pacchetto.documentazione delle dipendenze json.

tag npm-tag

$ lerna publish --npm-tag=next

Quando viene eseguito con questo flag, publishpubblicherà su npm con il tag dist npm specificato (il valore predefinito è latest).

Questa opzione può essere utilizzata per pubblicare una versione prerelease o beta.

Nota: il tag latestè quello che viene utilizzato quando un utente esegue npm install my-package. Per installare un tag diverso, un utente può eseguire npm install [email protected].

–canary, – c

$ lerna publish --canary$ lerna publish --canary=beta

Quando viene eseguito con questo flag, publish pubblica i pacchetti in modo più granulare (per commit). Prima di pubblicare su npm, crea il nuovo tag version prendendo l’attuale version, portandolo alla versione secondaria successiva, aggiungendo il meta suffisso fornito (il valore predefinito è alpha) e aggiungendo l’attuale git sha (es: 1.0.0diventa 1.1.0-alpha.81e3b443).

Il caso d’uso previsto per questo flag è una versione a livello di commit o una versione notturna.

–commit convenzionali

$ lerna publish --conventional-commits

Quando viene eseguito con questo flag, publish userà la specifica Commit convenzionali per determinare il bump di versione e generare CHANGELOG

g git-remote

$ lerna publish --git-remote upstream

Quando viene eseguito con questo flag, publish spingerà le modifiche git al telecomando specificato anziché origin.

skip skip-git

$ lerna publish --skip-git

Quando viene eseguito con questo flag, publish pubblicherà su npm senza eseguire nessuno dei comandi git.

Pubblica solo su npm; salta il commit, la codifica e la spinta delle modifiche git (questo riguarda solo la pubblicazione).

–skip-npm

$ lerna publish --skip-npm

Quando viene eseguito con questo flag, publish aggiornerà tutte le versioni dei pacchetti e delle dipendenze package.json, ma in realtà non pubblicherà i pacchetti su npm.

Questo è stato utile come soluzione per un problema di npm che è stato risolto. Quando pubblichi con le modifiche README, usa --skip-npm e fai il npm publish finale a mano per ogni pacchetto.

Questo flag può essere combinato con --skip-git per aggiornare solo versioni e dipendenze, senza commettere, taggare, spingere o pubblicare.

Aggiorna solo le versioni e le dipendenze; in realtà non pubblicare (questo riguarda solo la pubblicazione).

–force-publish

$ lerna publish --force-publish=package-2,package-4# force publish all packages$ lerna publish --force-publish=*

Quando viene eseguito con questo flag, publishforzerà la pubblicazione dei pacchetti specificati (separati da virgole) o di tutti i pacchetti usando *.

Questo salta il controllo lerna updated per i pacchetti modificati e costringe un pacchetto che non ha avuto una modifica git diff da aggiornare.

–sì

$ lerna publish --canary --yes# skips `Are you sure you want to publish the above changes?`

Quando viene eseguito con questo flag, publish salta tutte le richieste di conferma. Utile in Continuous Integration (CI) per rispondere automaticamente al prompt di conferma pubblicazione.

version cd-version

Quando viene eseguito con questo flag, publish salta il prompt di selezione della versione (in modalità indipendente) e usa la successiva versione semantica specificata. È comunque necessario utilizzare il flag --yes per evitare tutti i prompt. Ciò è utile quando i sistemi di compilazione devono pubblicare senza prompt dei comandi. Funziona in modalità normale e indipendente.

pre pre-id

version repo-version

$ lerna publish --repo-version 1.0.1# applies version and skips `Select a new version for...` prompt

Quando viene eseguito con questo flag, publish salta il prompt di selezione della versione e usa la versione specificata. Utile per bypassare il prompt di input dell’utente se si conosce già quale versione pubblicare.

message message, -m

Quando viene eseguito con questo flag, publish utilizzerà il messaggio fornito durante il commit degli aggiornamenti di versione per la pubblicazione. Utile per integrare lerna in progetti che prevedono che i messaggi di commit aderiscano a determinate linee guida, come i progetti che utilizzano commitizen e/o semantic-release.

Se il messaggio contiene %s, verrà sostituito con il nuovo numero di versione della versione globale preceduto da una “v”. Si noti che questo si applica solo quando si utilizza la modalità di versioning “fissa” predefinita, poiché non esiste una versione “globale” quando si utilizza --independent.

aggiornato

$ lerna updated

Controlla quali packages sono cambiati dall’ultima release (l’ultimo tag git).

Lerna determina l’ultimo tag git creato ed esegue git diff --name-only v6.8.1 per ottenere tutti i file modificati da quel tag. Restituisce quindi una serie di pacchetti che hanno un file aggiornato.

Si noti che la configurazione per il comando publish influisce anche sul comando updated. Ad esempio config.publish.ignore

–json

$ lerna updated --json

Quando viene eseguito con questo flag, updated restituirà una matrice di oggetti nel seguente formato:

pulisci

$ lerna clean

Rimuovi la directory node_modules da tutti i pacchetti.

lerna clean rispetta i flag --ignore, --scope e --yes (vedere Flag).

diff

$ lerna diff $ lerna diff# diff a specific package$ lerna diff package-name

Diff tutti i pacchetti o un singolo pacchetto dall’ultima release.

Simile a lerna updated. Questo comando esegue git diff.

ls

$ lerna ls

Elenca tutti i pacchetti pubblici nel repository Lerna corrente.

lerna ls rispetta i flag --ignore e --scope (vedi Flag).

j json

$ lerna ls --json

Quando viene eseguito con questo flag, ls restituirà un array di oggetti nel seguente formato:

esegui

Esegui uno script npm in ogni pacchetto che contiene tale script. È necessario un doppio trattino (--) per passare argomenti tratteggiati all’esecuzione dello script.

lerna run rispetta il --concurrency, --scope, --ignore, --stream, e --parallel bandiere (vedi Bandiere).

$ lerna run --scope my-component test

Nota: si consiglia di limitare l’ambito di questo comando (e lerna exec, sotto) quando si utilizza il flag --parallel, poiché la generazione di dozzine di sottoprocessi potrebbe essere dannosa per l’equanimità della shell (o il limite massimo del descrittore di file, ad esempio). YMMV

exec

$ lerna exec -- <command> # runs the command in all packages$ lerna exec -- rm -rf ./node_modules$ lerna exec -- protractor conf.js

Esegui un comando arbitrario in ogni pacchetto. Un doppio trattino (--) è necessario per passare i flag tratteggiati al comando generato, ma non è necessario quando tutti gli argomenti sono posizionali.

lerna exec rispetta il --concurrency, --scope, --ignore, e --parallel bandiere (vedi Bandiere).

$ lerna exec --scope my-component -- ls -la

Per deporre le uova lungo i processi in esecuzione, passare il --parallel flag:

# transpile all modules as they change in every package$ lerna exec --parallel -- babel src -d lib -w

Si può anche ottenere il nome del pacchetto corrente attraverso la variabile di ambiente LERNA_PACKAGE_NAME:

$ lerna exec -- npm view $LERNA_PACKAGE_NAME

Si può anche eseguire uno script che si trova nella root dir, in un complicato dir struttura attraverso la variabile di ambiente LERNA_ROOT_PATH:

$ lerna exec -- node $LERNA_ROOT_PATH/scripts/some-script.js

Suggerimento: I comandi sono distribuiti in parallelo, utilizzando la concorrenza dato (fatta eccezione per --parallel). L’output viene convogliato, quindi non deterministico. Se vuoi eseguire il comando in un pacchetto dopo l’altro, usalo in questo modo:

$ lerna exec --concurrency 1 -- ls -la

–bail

$ lerna exec --bail=<boolean> <command>

Questo flag indica se il comando exec deve interrompere l’esecuzione dopo aver riscontrato un errore generato da uno dei sottoprocessi generati. Il suo valore predefinito è true.

importa

$ lerna import <path-to-external-repository>

Importa il pacchetto in <path-to-external-repository>, con cronologia di commit, in packages/<directory-name>. Autori di commit originali, date e messaggi sono conservati. I commit vengono applicati al ramo corrente.

Questo è utile per raccogliere pacchetti standalone preesistenti in un repository Lerna. Ogni commit viene modificato per apportare modifiche relative alla directory del pacchetto. Quindi, ad esempio, il commit che ha aggiunto package.json aggiungerà invece packages/<directory-name>/package.json.

Varie

Lerna si collegherà a un file lerna-debug.log (come npm-debug.log) quando incontra un errore durante l’esecuzione di un comando.

Lerna ha anche il supporto per i pacchetti con ambito.

L’esecuzione di lerna senza argomenti mostrerà tutti i comandi/opzioni.

lerna.json

{ "lerna": "2.0.0", "version": "1.1.3", "commands": { "publish": { "ignore": }, "bootstrap": { "ignore": "component-*" } }, "packages": }
  • lerna: la versione corrente di Lerna in uso.
  • version: la versione corrente del repository.
  • commands.publish.ignore: un array di glob che non sarà incluso in lerna updated/publish. Utilizzare questo per impedire la pubblicazione di una nuova versione inutilmente per le modifiche, ad esempio la correzione di un errore di battitura README.md.
  • commands.bootstrap.ignore: un array di glob che non verrà avviato durante l’esecuzione del comando lerna bootstrap.
  • commands.bootstrap.scope: un array di glob che limita i pacchetti che verranno bootstrap durante l’esecuzione del comando lerna bootstrap.
  • packages: Array di glob da utilizzare come posizioni dei pacchetti.

devDependencies comuni

Most devDependencies può essere tirato fino alla radice di un repository Lerna.

Questo ha alcuni vantaggi:

  • Tutti i pacchetti di utilizzare la stessa versione di una determinata dipendenza
  • Può mantenere le dipendenze alla radice up-to-date con uno strumento automatico come GreenKeeper
  • Dipendenza il tempo di installazione è ridotto
  • Meno spazio di archiviazione è necessario

Nota che devDependencies fornitura di “binario” i file eseguibili, che sono utilizzati da npm script ancora bisogno di essere installato direttamente in ogni pacchetto in cui sono utilizzati.

Ad esempio la dipendenza nsp è necessaria in questo caso perché lerna run nsp (e npm run nsp all’interno della directory del pacchetto) funzioni correttamente:

{ "scripts": { "nsp": "nsp" }, "devDependencies": { "nsp": "^2.3.3" }}

Flag

Le opzioni di Lerna possono provenire dalla configurazione (lerna.json) o dalla riga di comando. Inoltre le opzioni in config possono vivere al livello superiore o possono essere applicate a comandi specifici.

Esempio:

{ "lerna": "x.x.x", "version": "1.2.0", "exampleOption": "foo", "command": { "init": { "exampleOption": "bar", } },}

In questo caso exampleOption sarà ” foo “per tutti i comandi tranne init, dove sarà”bar”. In tutti i casi può essere sovrascritto a ” baz ” sulla riga di comando con --example-option=baz.

concurren concorrenza

Quanti thread usare quando Lerna parallelizza le attività (il valore predefinito è 4)

$ lerna publish --concurrency 1

–ambito

Ambiti un comando a un sottoinsieme di pacchetti.

$ lerna exec --scope my-component -- ls -la
$ lerna run --scope toolbar-* test

–da

Quando si esegue uno script o un comando, eseguire l’operazione sui pacchetti che sono stati aggiornati dal refspecificato. Se ref non è specificato, il valore predefinito è il tag più recente.

Elenca il contenuto dei pacchetti che sono stati modificati dall’ultimo tag:

$ lerna exec --since -- ls -la

Eseguire i test per tutti i pacchetti che sono stati modificati da master:

$ lerna run test --since master

Elenca tutti i pacchetti che sono cambiati da allora some-branch:

$ lerna ls --since some-branch

Questo può essere particolarmente utile se usato in CI, se è possibile ottenere il ramo di destinazione in cui andrà un PR, perché è possibile utilizzarlo come opzione ref per --since. Questo funziona bene per i PR che vanno in master e rami di funzionalità.

ignore ignora

Esclude un sottoinsieme di pacchetti durante l’esecuzione di un comando.

$ lerna bootstrap --ignore component-*

Il flag ignore, se usato con il comando bootstrap, può anche essere impostato in lerna.json sotto il tasto commands.bootstrap. Il flag della riga di comando avrà la precedenza su questa opzione.

Esempio

{ "lerna": "2.0.0", "version": "0.0.0", "commands": { "bootstrap": { "ignore": "component-*" } }}

Suggerimento: il glob è abbinato al nome del pacchetto definito in package.json, non al nome della directory in cui vive il pacchetto.

–include-filtered-dependencies

Nota: questo sovrascriverà i flag --scope e --ignore.

cioè Un pacchetto abbinato al flag --ignore verrà comunque avviato se dipende da un altro pacchetto che viene avviato.

Questo è utile per le situazioni in cui si desidera “impostare” un singolo pacchetto che si basa su altri pacchetti in fase di configurazione.

$ lerna bootstrap --scope my-component --include-filtered-dependencies# my-component and all of its dependencies will be bootstrapped

–loglevel

Quale livello di log da segnalare. In caso di errore, tutti i registri vengono scritti su lerna-debug.accedere alla directory di lavoro corrente.

Vengono visualizzati tutti i registri di livello superiore rispetto all’impostazione. Il valore predefinito è “info”.

max max-buffer

Imposta una lunghezza massima del buffer per ogni chiamata di processo sottostante. Utile ad esempio quando qualcuno vuole importare un repository con una quantità maggiore di commit durante l’esecuzione di lerna import. In tal caso la lunghezza del buffer incorporata potrebbe non essere sufficiente.

no no-sort

Per impostazione predefinita, tutte le attività vengono eseguite sui pacchetti in ordine topologicamente ordinato per rispettare le relazioni di dipendenza dei pacchetti in questione. I cicli sono interrotti su base best-effort in un modo non garantito per essere coerente tra le invocazioni di Lerna.

L’ordinamento topologico può causare colli di bottiglia di concorrenza se vi è un numero limitato di pacchetti con molte dipendenze o se alcuni pacchetti richiedono un tempo sproporzionatamente lungo per l’esecuzione. L’opzione --no-sort disabilita l’ordinamento, eseguendo invece le attività in un ordine arbitrario con la massima concorrenza.

Questa opzione può essere utile anche se si eseguono più comandi “watch”. Poiché lerna run eseguirà i comandi in ordine topologicamente ordinato, può finire per aspettare un comando prima di passare. Ciò bloccherà l’esecuzione quando si eseguono i comandi “watch”, poiché in genere non finiscono mai. Un esempio di comando” watch ” è in esecuzione babel con il flag CLI --watch.

ho hoist

Installa le dipendenze esterne corrispondenti a glob nella radice del repository in modo che siano disponibili per tutti i pacchetti. Tutti i binari da queste dipendenze saranno collegati nelle directory dependent package node_modules/.bin/ in modo che siano disponibili per gli script npm. Se l’opzione è presente ma non viene fornito glob, il valore predefinito è ** (sollevare tutto). Questa opzione riguarda solo il comando bootstrap.

$ lerna bootstrap --hoist

Per lo sfondo su --hoist, vedere la documentazione di hoist.

Nota: Se i pacchetti dipendono da versioni diverse di una dipendenza esterna, verrà issata la versione più comunemente utilizzata e verrà emesso un avviso.

no nohoist

Non installare dipendenze esterne corrispondenti a glob nella radice del repository. Questo può essere usato per disattivare il sollevamento per determinate dipendenze.

$ lerna bootstrap --hoist --nohoist=babel-*

–npm-client

Installa dipendenze esterne usando install. Deve essere un eseguibile che sappia come installare le dipendenze npm.

$ lerna bootstrap --npm-client=yarn

Può anche essere configurato in lerna.json:

{ ... "npmClient": "yarn"}

–use-workspaces

Consente l’integrazione con Yarn Workspaces (disponibile da [email protected]+).
I valori nell’array sono i comandi in cui Lerna delegherà l’operazione a Yarn (attualmente solo bootstrap).
Se --use-workspaces è true, packages verrà sovrascritto dal valore da package.json/workspaces.
Può anche essere configurato in lerna.json:

{ ... "npmClient": "yarn", "useWorkspaces": true}

–stream

Stream output dai processi figlio immediatamente, preceduto dal nome del pacchetto di origine. Ciò consente di interlacciare l’output da pacchetti diversi.

$ lerna run watch --stream

–parallel

Simile a --stream, ma ignora completamente la concorrenza e l’ordinamento topologico, eseguendo immediatamente un determinato comando o script in tutti i pacchetti corrispondenti con output di streaming prefissato. Questo è il flag preferito per processi di lunga durata come babel src -d lib -w eseguiti su molti pacchetti.

$ lerna exec --parallel -- babel src -d lib -w

–registry

Quando viene eseguito con questo flag, i comandi npm inoltrati utilizzeranno il registro specificato per i pacchetti.

Questo è utile se non si desidera impostare esplicitamente la configurazione del registro di sistema in tutto il pacchetto.file json singolarmente quando ad esempio utilizzando registri privati.

temp temp-tag

Quando viene passato, questo flag altererà il processo di pubblicazione predefinito pubblicando prima tutti i pacchetti modificati in un dist-tag temporaneo (lerna-temp) e quindi spostando le nuove versioni sul dist-tag predefinito (latest).

Questo non è generalmente necessario, poiché Lerna pubblicherà i pacchetti in ordine topologico (tutte le dipendenze prima dei dipendenti) per impostazione predefinita.

Wizard

Se preferisci qualche guida per la cli (nel caso in cui stai per iniziare a usare lerna o introdurlo in un nuovo team), potresti piacerti lerna-wizard. Ti condurrà attraverso una serie di passaggi ben definiti:

Tag correnti

Lascia un commento

Il tuo indirizzo email non sarà pubblicato.