un instrument pentru gestionarea proiectelor JavaScript cu mai multe pachete.

  • Despre
  • Noțiuni De Bază
  • Cum Funcționează
  • Depanare
  • Comenzi
  • Diverse
  • Lerna.JSON
  • steaguri

despre

divizarea codebases mari în pachete separate, independent versionate este extrem de util pentru partajarea de cod. Cu toate acestea, efectuarea de modificări în multe depozite este dezordonată și dificil de urmărit, iar testarea în depozite se complică foarte repede.

pentru a rezolva aceste (și multe alte) probleme, unele proiecte își vor organiza bazele de cod în depozite cu mai multe pachete (uneori numite monorepos). Proiecte precum Babel, React, Angular, Ember, Meteor, Jest și multe altele își dezvoltă toate pachetele într-un singur depozit.

Lerna este un instrument care optimizează fluxul de lucru în jurul gestionarea arhive multi-pachet cu git și npm.

Lerna poate reduce, de asemenea, cerințele de timp și spațiu pentru numeroase copii ale pachetelor în medii de dezvoltare și construire – în mod normal, un dezavantaj al împărțirii unui proiect în mai multe pachete NPM separate. Consultați documentația de ridicare pentru detalii.

cum arată un repo Lerna?

există de fapt foarte puțin. Aveți un sistem de fișiere care arată astfel:

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

ce poate face Lerna?

cele două comenzi primare din Lerna sunt lerna bootstrapși lerna publish.

bootstrap va lega dependențele în repo împreună. publish va ajuta la publicarea oricăror pachete actualizate.

Noțiuni de bază

instrucțiunile de mai jos sunt pentru Lerna 2.x. vă recomandăm să-l utilizați în loc de 1.x pentru un nou proiect Lerna. Verificați wiki dacă aveți nevoie pentru a vedea 1.X README.

să începem prin instalarea Lerna la nivel global cu npm.

$ npm install --global lerna

în continuare vom crea un nou depozit git:

$ git init lerna-repo$ cd lerna-repo

și acum să o transformăm într-un repo Lerna:

$ lerna init

depozitul dvs. ar trebui să arate acum astfel:

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

aceasta va crea un fișier de configurare lerna.json, precum și un folder packages.

cum funcționează

Lerna vă permite să gestionați proiectul folosind unul din cele două moduri: fixe sau independente.

mod fix/blocat (implicit)

mod fix proiectele Lerna funcționează pe o singură linie de versiune. Versiunea este păstrată în fișierul lerna.json la rădăcina proiectului dvs. sub tasta version. Când executați lerna publish , dacă un modul a fost actualizat de la ultima dată când a fost făcută o versiune, acesta va fi actualizat la noua versiune pe care o eliberați. Aceasta înseamnă că publicați o nouă versiune a unui pachet numai atunci când aveți nevoie.

acesta este modul pe care Babel îl folosește în prezent. Utilizați acest lucru dacă doriți să legați automat toate versiunile de pachete. O problemă cu această abordare este că o schimbare majoră în orice pachet va duce la toate pachetele având o nouă versiune majoră.

mod Independent (–independent)

mod independent proiecte Lerna permite întreținătorilor să incrementeze versiunile de pachete independent unul de celălalt. De fiecare dată când publicați, veți primi o solicitare pentru fiecare pachet care s-a modificat pentru a specifica dacă este o modificare patch, minoră, majoră sau personalizată.

modul Independent vă permite să actualizați mai precis versiunile pentru fiecare pachet și are sens pentru un grup de componente. Combinarea acestui mod cu ceva de genul eliberării semantice ar face mai puțin dureros. (Se lucrează la acest lucru deja la atlassian/Lerna-semantic-release).

tasta version din lerna.json este ignorată în modul independent.

depanarea

Dacă întâmpinați probleme în timp ce utilizați Lerna, consultați documentul nostru de depanare unde puteți găsi răspunsul la problema dvs.

Întrebări frecvente

vezi FAQ.md.

comenzi

init

$ lerna init

creați un nou repo Lerna sau actualizați un repo existent la versiunea curentă a Lerna.

Lerna presupune că repo-ul a fost deja inițializat cu git init.

când executați, această comandă va:

  1. adăugați lerna ca devDependency în package.json dacă nu există deja.
  2. creați un fișier de configurare lerna.json pentru a stoca numărul version.

exemplu de ieșire pe un nou repo git:

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

–independent, – i

$ lerna init --independent

acest steag îi spune lui Lerna să utilizeze modul independent de versionare.

–exact

$ lerna init --exact

în mod implicit, lerna init va utiliza un interval de îngrijire atunci când adăugați sau actualizați versiunea locală a lerna, la fel ca npm install --save-dev lerna.

pentru a păstra lerna 1.x comportament de comparație „exactă”, trece acest steag. Se va configura lerna.json pentru a impune potrivirea exactă pentru toate execuțiile ulterioare.

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

bootstrap

$ lerna bootstrap

Bootstrap pachetele din repo curent Lerna. Instalează toate dependențele lor și leagă orice dependențe încrucișate.

când executați, această comandă va:

  1. npm install toate dependențele externe ale fiecărui pachet.
  2. Symlink împreună toate Lerna packages care sunt dependențe de fiecare alte.
  3. npm prepublish toate pachetele bootstrapped.

lerna bootstrap respectă steagurile --ignore, --scope și --include-filtered-dependencies (a se vedea steaguri).

treceți argumente suplimentare clientului npm plasându-le după --:

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

poate fi, de asemenea, configurat în lerna.json:

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

cum funcționeazăbootstrap

să folosim babel ca exemplu.

  • babel-generator și source-map (printre altele) sunt dependențe de babel-core.
  • babel-core‘s package.json listează ambele pachete ca chei în dependencies, după cum se arată mai jos.
// babel-core package.json{ "name": "babel-core", ... "dependencies": { ... "babel-generator": "^6.9.0", ... "source-map": "^0.5.0" }}
  • Lerna verifică dacă fiecare dependență face parte și din Lerna repo.
    • în acest exemplu, babel-generator poate fi o dependență internă, în timp ce source-map este întotdeauna o dependență externă.
    • versiunea babel-generator din package.json din babel-core este satisfăcută de packages/babel-generator, trecând pentru o dependență internă.
    • source-mapeste npm installed (sau yarn ed) ca în mod normal.
  • packages/babel-core/node_modules/babel-generator legături simbolice la packages/babel-generator
  • acest lucru permite importurile de directoare imbricate

Note:

  • când o versiune de dependență dintr-un pachet nu este satisfăcută de un pachet cu același nume din repo, acesta va fi npm installed (sau yarned) ca normal.
  • dist-tag-uri, cum ar fi latest, nu satisfac intervalele semver.
  • dependențele circulare au ca rezultat legături simbolice circulare care pot afecta editorul/IDE.

Webstorm se blochează atunci când sunt prezente legături simbolice circulare. Pentru a preveni acest lucru, adăugați node_modules la lista de fișiere și foldere ignorate în Preferences | Editor | File Types | Ignored files and folders.

publicați

$ lerna publish

publicați pachete în actualul proiect Lerna. Când executați, această comandă face următoarele:

creează o nouă versiune a pachetelor care au fost actualizate. Solicită o nouă versiune. Creează un nou git comite / tag-ul în procesul de publicare la npm.

mai precis, această comandă va:

  1. rulați echivalentul lerna updated pentru a determina ce pachete trebuie publicate.
  2. dacă este necesar, incrementați tasta version în lerna.json.
  3. actualizați package.json tuturor pachetelor actualizate la noile lor versiuni.
  4. actualizați toate dependențele pachetelor actualizate cu noile versiuni, specificate cu un caret (^).
  5. creați un nou git comite și tag-ul pentru noua versiune.
  6. publica pachete actualizate la npm.

Lerna nu va publica pachete marcate ca private ("private": true în package.json).

–exact

$ lerna publish --exact

când rulați cu acest steag, publishva specifica dependențele actualizate în pachetele actualizate exact (fără punctuație), în loc de compatibil semver (cu un ^).

pentru mai multe informații, consultați pachetul.JSON dependențe documentație.

–NPM-tag

$ lerna publish --npm-tag=next

când executați cu acest steag, publishva publica la npm cu NPM dat dist-tag (implicit la latest).

această opțiune poate fi utilizată pentru a publica o versiune prerelease sau beta.

notă: eticheta latest este cea utilizată atunci când un utilizator rulează npm install my-package. Pentru a instala o etichetă diferită, un utilizator poate rula npm install [email protected].

–canary, – c

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

când rulați cu acest steag, publish publică pachete într-un mod mai granular (pe comitere). Înainte de a publica în npm, creează noua etichetă version luând actualul version, trecând-o la următoarea versiune minoră, adăugând sufixul meta furnizat (implicit la alpha) și adăugând actualul git sha (ex: 1.0.0devine 1.1.0-alpha.81e3b443).

cazul de utilizare prevăzut pentru acest flag este o eliberare per commit level sau o eliberare nocturnă.

–convențional-commits

$ lerna publish --conventional-commits

când rulați cu acest steag, publish va folosi specificația Commits convenționale pentru a determina cucui versiune și pentru a genera CHANGELOG

–git-remote

$ lerna publish --git-remote upstream

când rulați cu acest steag, publishva împinge modificările git la telecomanda specificată în loc de origin.

–skip-git

$ lerna publish --skip-git

când rulați cu acest steag, publish va publica la npm fără a rula oricare dintre comenzile git.

publicați numai în npm; săriți comiterea, etichetarea și împingerea modificărilor git (acest lucru afectează numai publicarea).

–skip-npm

$ lerna publish --skip-npm

când rulați cu acest steag, publish va actualiza toate package.json versiunile de pachete și versiunile de dependență, dar nu va publica efectiv pachetele în npm.

acest lucru a fost util ca soluție pentru o problemă npm care a fost rezolvată de atunci. Când publicați cu modificările README, utilizați --skip-npm și faceți finala npm publish manual pentru fiecare pachet.

acest steag poate fi combinat cu --skip-git pentru a actualiza doar versiunile și dependențele, fără a comite, eticheta, împingerea sau publicarea.

actualizează doar versiunile și dependențele; nu publicați efectiv (acest lucru afectează doar publicarea).

–force-publish

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

când rulați cu acest steag, publishva forța publicarea pachetelor specificate (separate prin virgulă) sau a tuturor pachetelor folosind *.

aceasta va sări peste verificarea lerna updated pentru pachetele modificate și forțează actualizarea unui pachet care nu avea o modificare git diff.

–da

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

când rulați cu acest steag, publish va sări peste toate solicitările de confirmare. Util în Integrare Continuă (CI) pentru a răspunde automat la promptul de confirmare a publicării.

–cd-version

când rulați cu acest steag, publish va sări peste promptul de selectare a versiunii (în modul independent) și va folosi următoarea versiune semantică specificată. Trebuie să utilizați în continuare steagul --yes pentru a evita toate solicitările. Acest lucru este util atunci când sistemele de construire trebuie să publice fără instrucțiuni de comandă. Funcționează atât în moduri normale, cât și independente.

–pre-id

–repo-version

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

când rulați cu acest steag, publish va sări peste promptul de selectare a versiunii și va folosi versiunea specificată. Util pentru ocolirea solicitării de introducere a utilizatorului dacă știți deja ce Versiune să publicați.

–message, -m

când rulați cu acest steag, publish va utiliza mesajul furnizat la comiterea actualizărilor versiunii pentru publicare. Util pentru integrarea lerna în proiecte care se așteaptă să se angajeze mesaje să adere la anumite linii directoare, cum ar fi proiectele care utilizează commitizen și/sau semantic-release.

dacă mesajul conține %s, acesta va fi înlocuit cu noul număr de versiune Global version prefixat cu un „v”. Rețineți că acest lucru se aplică numai atunci când utilizați modul de versiune implicit „fix”, deoarece nu există o versiune „globală” atunci când utilizați --independent.

actualizat

$ lerna updated

verificați care packages S-au schimbat de la ultima versiune (ultima etichetă git).

Lerna determină ultima etichetă git creată și rulează git diff --name-only v6.8.1 pentru a modifica toate fișierele de la acea etichetă. Apoi returnează o serie de pachete care au un fișier actualizat.

rețineți că configurația pentru comanda publish afectează și comanda updated. De exemplu config.publish.ignore

–json

$ lerna updated --json

când executați cu acest steag, updated va returna o serie de obiecte în următorul format:

curățați

$ lerna clean

eliminați directorul node_modules din toate pachetele.

lerna clean respectă steagurile --ignore, --scope și --yes.

dif

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

dif toate pachetele sau un singur pachet de la ultima versiune.

Similar cu lerna updated. Această comandă rulează git diff.

ls

$ lerna ls

listează toate pachetele publice din repo-ul Lerna curent.

lerna ls respectă steagurile --ignore și --scope (a se vedea steagurile).

— json

$ lerna ls --json

când executați cu acest steag, ls va returna o serie de obiecte în următorul format:

rulați

rulați un script npm în fiecare pachet care conține acel script. O liniuță dublă (--) este necesară pentru a trece argumentele punctate la execuția scriptului.

lerna run respectă --concurrency, --scope, --ignore, --stream, și --parallel steaguri (a se vedea steaguri).

$ lerna run --scope my-component test

notă: se recomandă să restricționați domeniul de aplicare al acestei comenzi (și lerna exec, mai jos) atunci când utilizați steagul --parallel, deoarece zeci de subprocese pot fi dăunătoare echanimității shell-ului dvs. (sau limita maximă a descriptorului de fișiere, de exemplu). YMMV

exec

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

rulați o comandă arbitrară în fiecare pachet. O linie dublă (--) este necesară pentru a trece steagurile punctate la comanda spawned, dar nu este necesară atunci când toate argumentele sunt poziționale.

lerna exec respectă --concurrency, --scope, --ignore, și --parallel steaguri (a se vedea steaguri).

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

pentru a genera procese de lungă durată, treceți steagul --parallel :

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

puteți obține, de asemenea, numele pachetului curent prin variabila de mediuLERNA_PACKAGE_NAME:

$ lerna exec -- npm view $LERNA_PACKAGE_NAME

puteți rula, de asemenea, un script situat în rădăcină dir, într-o structură complicată dir prin variabila de mediuLERNA_ROOT_PATH:

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

sugestie: comenzile sunt generate în paralel, folosind concurența dată (cu excepția --parallel). Ieșirea este prin conducte, deci nu determinist. Dacă doriți să rulați comanda într-un pachet după altul, utilizați-o astfel:

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

–cauțiune

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

acest steag semnifică dacă comanda exec ar trebui sau nu să oprească executarea la întâmpinarea unei erori aruncate de una dintre subprocesele generate. Valoarea implicită este true.

import

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

importați pachetul la <path-to-external-repository>, cu istoricul comiterii, în packages/<directory-name>. Autorii originali, datele și mesajele sunt păstrate. Angajamentele se aplică sucursalei curente.

acest lucru este util pentru Colectarea pachetelor independente preexistente într-un repo Lerna. Fiecare comitere este modificată pentru a face modificări în raport cu directorul de pachete. Deci, de exemplu, comiterea care a adăugat package.json va adăuga în schimb packages/<directory-name>/package.json.

diverse

Lerna se va conecta la un fișier lerna-debug.log (la fel ca npm-debug.log) atunci când întâlnește o eroare la rularea unei comenzi.

Lerna are, de asemenea, suport pentru pachetele scoped.

rularea lerna fără argumente va afișa toate comenzile/opțiunile.

lerna.json

{ "lerna": "2.0.0", "version": "1.1.3", "commands": { "publish": { "ignore": }, "bootstrap": { "ignore": "component-*" } }, "packages": }
  • lerna: versiunea actuală a Lerna fiind utilizat.
  • version: versiunea curentă a depozitului.
  • commands.publish.ignore: o serie de globuri care nu vor fi incluse în lerna updated/publish. Utilizați acest lucru pentru a preveni publicarea inutilă a unei noi versiuni pentru modificări, cum ar fi remedierea unei greșeli README.md.
  • commands.bootstrap.ignore: o serie de globuri care nu vor fi bootstrapped atunci când rulează comanda lerna bootstrap.
  • commands.bootstrap.scope: o serie de globuri care restricționează pachetele care vor fi bootstrapate atunci când rulează comanda lerna bootstrap.
  • packages: matrice de globuri de utilizat ca locații de pachete.

devDependencies comune

cele mai multe devDependencies poate fi tras până la rădăcina unui repo Lerna.

acest lucru are câteva beneficii:

  • toate pachetele folosesc aceeași versiune a unei dependențe date
  • pot menține dependențele la rădăcină actualizate cu un instrument automat, cum ar fi GreenKeeper
  • timpul de instalare a dependenței este redus
  • este nevoie de mai puțin spațiu de stocare

rețineți că devDependencies furnizarea de executabile „binare” care sunt folosite de script-uri npm încă mai trebuie să fie instalate direct în fiecare pachet în cazul în care acestea sunt utilizate.

de exemplu, dependența nsp este necesară în acest caz pentru ca lerna run nsp (și npm run nsp din Directorul pachetului) să funcționeze corect:

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

steaguri

opțiuni pentru a Lerna poate veni de la configurare (lerna.json) sau pe linia de comandă. În plus, opțiunile din config pot trăi la nivelul superior sau pot fi aplicate unor comenzi specifice.

exemplu:

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

în acest caz exampleOption va fi „foo” pentru toate comenzile, cu excepția init, unde va fi „bar”. În toate cazurile, poate fi înlocuită cu „baz” pe linia de comandă cu --example-option=baz.

— concurrency

câte fire de utilizat atunci când Lerna paralelizează sarcinile (implicit la 4)

$ lerna publish --concurrency 1

–domeniu de aplicare

domenii o comandă la un subset de pachete.

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

–deoarece

când executați un script sau o comandă, aplicați operația la pachetele care au fost actualizate de la ref specificat. Dacă ref nu este specificat, acesta este implicit la cea mai recentă etichetă.

enumerați conținutul pachetelor care s-au modificat de la ultima etichetă:

$ lerna exec --since -- ls -la

rulați testele pentru toate pachetele care s-au schimbat de la master:

$ lerna run test --since master

listează toate pachetele care s-au schimbat de atunci some-branch:

$ lerna ls --since some-branch

acest lucru poate fi deosebit de util atunci când este utilizat în CI, dacă puteți obține ramura țintă în care va intra un PR, deoarece o puteți utiliza ca opțiune ref la --since. Acest lucru funcționează bine pentru PRs merge în master, precum și ramuri de caracteristici.

–ignore

exclude un subset de pachete atunci când rulează o comandă.

$ lerna bootstrap --ignore component-*

steagul ignore, atunci când este utilizat cu comanda bootstrap, poate fi setat și în lerna.json sub tasta commands.bootstrap. Steagul liniei de comandă va prelua precendența față de această opțiune.

exemplu

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

sugestie: glob este potrivit cu numele pachetului definit în package.json, nu numele directorului pachetul trăiește în.

–includeți dependențele filtrate

Notă: Aceasta va înlocui steagurile --scope și --ignore.

adică un pachet potrivit cu steagul --ignore va fi în continuare bootstrapped dacă depinde de un alt pachet care este bootstrapped.

acest lucru este util pentru situațiile în care doriți să „configurați” un singur pachet care se bazează pe configurarea altor pachete.

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

–loglevel

ce nivel de jurnale pentru a raporta. La eșec, toate jurnalele sunt scrise la Lerna-debug.conectați-vă la directorul de lucru curent.

sunt afișate toate jurnalele de nivel superior setării. Implicit este „info”.

–max-buffer

setați o lungime maximă a buffer-ului pentru fiecare apel de proces subiacent. Util, de exemplu, atunci când cineva dorește să importe un repo cu o cantitate mai mare de comiteri în timp ce rulează lerna import. În acest caz, lungimea tamponului încorporat ar putea să nu fie suficientă.

–no-sort

în mod implicit, toate taskurile se execută pe pachete în ordine sortată topologic pentru a respecta relațiile de dependență ale pachetelor în cauză. Ciclurile sunt rupte pe o bază de cel mai bun efort într-un mod care nu este garantat să fie consecvent în invocațiile Lerna.

sortarea topologică poate provoca blocaje de concurență dacă există un număr mic de pachete cu mulți dependenți sau dacă unele pachete necesită un timp disproporționat de lung pentru a fi executate. Opțiunea --no-sort dezactivează sortarea, executând în schimb sarcini într-o ordine arbitrară cu concurență maximă.

această opțiune poate ajuta, de asemenea, dacă executați mai multe comenzi „watch”. Deoarece lerna run va executa comenzi în ordine sortată topologic, poate ajunge să aștepte o comandă înainte de a trece mai departe. Acest lucru va bloca executarea atunci când executați comenzi „watch”, deoarece de obicei nu se termină niciodată. Un exemplu de comandă” watch ” rulează babel cu steagul CLI --watch.

–ridicare

instalați dependențe externe care se potrivesc glob la rădăcina repo, astfel încât acestea să fie disponibile pentru toate pachetele. Orice binare din aceste dependențe vor fi legate în pachetul dependent node_modules/.bin/ directoare astfel încât acestea sunt disponibile pentru script-uri npm. Dacă opțiunea este prezentă, dar nu este dată glob, valoarea implicită este **(ridicați totul). Această opțiune afectează numai comanda bootstrap.

$ lerna bootstrap --hoist

pentru informații generale despre --hoist, consultați documentația palanului.

Notă: Dacă pachetele depind de versiuni diferite ale unei dependențe externe, versiunea cea mai frecvent utilizată va fi ridicată și va fi emis un avertisment.

–nohoist

nu instalați dependențe externe care se potrivesc glob la rădăcina repo. Acest lucru poate fi folosit pentru a renunța la ridicare pentru anumite dependențe.

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

–NPM-client

instalați dependențe externe folosind install. Trebuie să fie un executabil care știe cum să instaleze dependențe npm.

$ lerna bootstrap --npm-client=yarn

poate fi, de asemenea, configurat în lerna.json:

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

–utilizare-spații de lucru

permite integrarea cu spații de lucru Fire (disponibil din [email protected]+).
valorile din matrice sunt comenzile în care Lerna va delega operațiunea către fire (în prezent doar bootstrapping).
dacă --use-workspaces este adevărat, atunci packages va fi înlocuită de valoarea de la package.json/workspaces.
poate fi, de asemenea, configurată în lerna.json:

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

–stream

ieșire flux de procese copil imediat, prefixat cu numele pachetului de origine. Acest lucru permite ca ieșirea din diferite pachete să fie intercalată.

$ lerna run watch --stream

–paralel

Similar cu --stream, dar ignoră complet concurența și sortarea topologică, rulând imediat o comandă sau un script dat în toate pachetele potrivite cu ieșire de streaming prefixată. Acesta este steagul preferat pentru procesele de lungă durată, cum ar fi babel src -d lib -w rulate pe mai multe pachete.

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

–registry

când executați cu acest steag, comenzile NPM redirecționate vor utiliza registrul specificat pentru pachetele dvs.

acest lucru este util dacă nu doriți să configurați în mod explicit configurația registry în tot pachetul.JSON fișiere individual atunci când, de exemplu, folosind registre private.

–temp-tag

când a trecut, acest steag va modifica implicit publica procesul de prima publicare toate pachetele modificate la un temporar dist-tag (lerna-temp) și apoi se deplasează noua versiune(e) la implicit dist-tag (latest).

acest lucru nu este în general necesar, deoarece Lerna va publica pachete în ordine topologică (toate dependențele înaintea dependenților) în mod implicit.

Wizard

dacă preferați câteva îndrumări pentru cli (în cazul în care sunteți pe cale să începeți să utilizați lerna sau să o introduceți unei noi Echipe), s-ar putea să vă placă Lerna-wizard. Vă va conduce printr-o serie de pași bine definiți:

etichete curente

Lasă un răspuns

Adresa ta de email nu va fi publicată.