Jutro Platform CLI-Befehle

Die Jutro Digital Platform CLI verwendet einen Basisbefehl jutro, mit optionalen Befehlen je nach Funktion:

Sie können den generate -Befehl zum Beispiel mit dem Argument themes verwenden, um eine .css-Datei zu erstellen, die für eine neue Themendefinition in einer Jutro-App verwendet werden kann.

jutro generate:themes

Auf dieser Seite machen Sie sich mit Folgendem vertraut:

Optionen und Befehle, die Jutro Digital Platform CLI bereitstellt
Wie Sie diese Befehle ausführen

Tip: Die cli-platform-Befehle von Jutro müssen ausgehend vom

Stammverzeichnis Ihrer Jutro-App ausgeführt werden.

Was stellt die Jutro Platform CLI bereit?

Um alle verfügbaren Befehle in der Jutro Platform CLI zu finden, führen Sie Folgendes aus:

jutro --help

Dies liefert eine Ausgabe ähnlich der folgenden:

The CLI tool for Jutro Digital Platform

VERSION
  @jutro/cli-platform/0.17.2-next.0 darwin-x64 node-v16.14.2

USAGE
  $ jutro [COMMAND]

TOPICS
  generate  Generates i18n translations for your Jutro app
  validate  Validates your Jutro app to ensure that it follows Guidewire standards

Sie können die Befehlsoptionen auch mit dem folgenden Befehl finden:

jutro generate --help

Der obige Befehl gibt eine Ausgabe zurück, die der folgenden ähnelt:

Generates i18n translations for your Jutro app

USAGE
  $ jutro generate:COMMAND

TOPICS
  generate:i18n      Generates i18n translations for your Jutro app
  generate:metadata

COMMANDS
  generate:changelog  Generates the changelog for git repository
  generate:themes     Generates a `.css` file that can be used for a new theme definition in a Jutro app

Um weitere Informationen zu den einzelnen Funktionsbefehlen zu erhalten, z. B themes, führen Sie den folgenden Befehl aus:

jutro generate:themes --help

Dies liefert eine Ausgabe ähnlich der folgenden:

`jutro generate:themes` generates a `.css` file that can be used for a new theme definition in a Jutro App

USAGE
  $ jutro generate:themes

OPTIONS
  -c, --configPath=configPath  Defines the path of the directory that contains the .themesConfig.json file
  -s, --encapsulateThemes      When the app is used as a micro frontend, generated themes will be scoped to this app, not the shell app. CSS
                               selector will include JUTRO_APP_ID value.
  --clearCache                 Clear cache. Use this to log in as a different user.
  --cliInfo                    Information about config and cache file location.
  --help                       show CLI help
  --reset                      Reset config to default and clear cache

EXAMPLE
  $ jutro generate:themes

Weitere Informationen zur JUTRO_APP_ID-Verwendung finden Sie im Abschnitt Micro-Frontend in eine Shell-App einbetten für Modulföderation.

Liste der Befehle

Die folgenden Befehle sind in der Jutro Platform CLI verfügbar:

Generierungsbefehle

Befehl	Beschreibung	Link
jutro generate:changelog	Generiert eine Änderungsprotokolldatei für die Jutro-App.	Link zum entsprechenden Abschnitt
jutro generate:i18n	Generiert Internationalisierungsübersetzungen für die Jutro-App.	Link zum entsprechenden Abschnitt
jutro generate:themes	Generiert eine Theme-Definitionsdatei für die Jutro-App.	Link zum entsprechenden Abschnitt

Validierungsbefehle

Befehl	Beschreibung	Link
jutro validate:dependencies	Validiert die Abhängigkeiten der Jutro-App.	Link zum entsprechenden Abschnitt
jutro validate:folders	Validiert die Ordnerstruktur der Jutro-App.	Link zum entsprechenden Abschnitt
jutro validate:i18n	Validiert die Internationalisierungsübersetzungen in der Jutro-App.	Link zum entsprechenden Abschnitt
jutro validate:linters	Validiert die Linter-Konfiguration in der Jutro-App.	Link zum entsprechenden Abschnitt
jutro validate:migrations	Validiert die Migrationen in der Jutro-App.	Link zum entsprechenden Abschnitt
jutro validate:tests	Validiert die in der Jutro-App definierten Tests.	Link zum entsprechenden Abschnitt
jutro validate:lighthouse	Generiert einen Lighthouse-Bericht in der Jutro-App.	Link zum entsprechenden Abschnitt

App-Befehle

Befehl	Beschreibung	Link
jutro app:tests	Führt die Komponententests der App aus.	Link zum entsprechenden Abschnitt
jutro app:start	Bündelt und startet die Jutro-App.	Link zum entsprechenden Abschnitt
jutro app:build	Erstellt einen Anwendungs-Build.	Link zum entsprechenden Abschnitt

generate-Befehle

Änderungsprotokoll generieren

Führen Sie zum Generieren einer Änderungsprotokolldatei den folgenden Befehl aus:

jutro generate:changelog

Sie werden aufgefordert, Folgendes einzugeben:

den Pfad des Verzeichnisses mit dem Git-Repository,
die Paketversion für das Änderungsprotokoll (standardmäßig ist dies die Version aus der Datei package.json im aktuellen Arbeitsverzeichnis),
durch Kommas getrennte Bereiche, die aus dem Änderungsprotokoll ausgeschlossen werden sollen (ignorieren Sie Commits, die mit <type>(<scope>) beginnen),
durch Kommas getrennte Präfixe für Probleme, die in das Änderungsprotokoll aufgenommen werden sollen (z. B. JUT-),
die Option zum Erzeugen aller Git-Tags.

Sobald Sie die oben genannten Angaben gemacht haben, wird eine CHANGELOG.md-Datei in Ihrem Anwendungsordner erstellt.

Sie können die Argumente auch direkt an einen Jutro Platform CLI-Befehl übergeben:

jutro generate:changelog --workDir=WORKING_DIRECTORY --issuePrefixes=LIST_OF_ISSUE_PREFIXES --ignoredScopes=LIST_OF_IGNORED_SCOPES --forVersion=FOR_VERSION

Sie können auch das --forAllTags-Flag setzen, um ein Änderungsprotokoll aller Git-Tags zu erzeugen.

Internationalisierungsübersetzungen generieren

Um Internationalisierungsübersetzungen (i18n) für die Jutro-App zu generieren, führen Sie den folgenden Befehl aus:

jutro generate:i18n

Dieser Befehl extrahiert die Meldungen aus allen JSX- und Metadaten-Dateien, die in der App gefunden wurden, und gruppiert sie standardmäßig in zwei Übersetzungsdateien: src/i18n/lang.json (Vorlagenübersetzungsdatei) und src/i18n/yy.json (Sherlock-Übersetzung).

Die Vorlagendatei lang.json sollte als Grundlage für die Übersetzung Ihrer Anwendung in andere Sprachen verwendet werden. Sie müssen für jede Sprache Übersetzungsdateien erstellen (en.json, de.json usw.) und diese in src/i18n in Ihrem Anwendungsordner ablegen, damit sie von Jutro aufgenommen werden können.

Note: Nehmen Sie keine Änderungen an der Datei lang.json vor, da diese bei jedem Build der Anwendung überschrieben werden würden.

Die Sherlock-Übersetzung wird verwendet, um nicht übersetzte Schlüssel in Ihrem Code zu identifizieren.

Die erzeugten Dateien haben die folgende Struktur:

lang.json:

{
  "jutro-app.Pages.Settings.header": "Settings",
  "jutro-app.Pages.Settings.title": "Settings",
  "jutro-app.app.commonAvatar.welcomePage": "Go to the Welcome Page"
}

yy.json:

{
  "jutro-app.Pages.Settings.header": "[2TbH15_Settings]",
  "jutro-app.Pages.Settings.title": "[2IeCt0_Settings]",
  "jutro-app.app.commonAvatar.welcomePage": "[3OqyfH_Go to the Welcome Page]"
}

Um weitere Informationen über den generate:i18n-Befehl und eine Liste aller CLI-Argumente zu erhalten, geben Sie Folgendes ein:

jutro generate:i18n --help

Die Ausgabe sieht ähnlich aus wie diese:

Generates i18n translations

USAGE
  $ jutro generate:i18n

OPTIONS
  -j, --jsxFileNamePattern=jsxFileNamePattern            [default: src/**/*.{ts,tsx,js,jsx}] Defines the file name pattern of your JSX files
  -m, --metadataFileNamePattern=metadataFileNamePattern  [default: src/**/*.{metadata,config}.json5] Defines the file name pattern for your metadata JSON files
  -o, --translationOutputDir=translationOutputDir        [default: src/i18n] Defines where the output messages combining default translations and extracted translations are stored
  -p, --pseudoType=(expansion|sherlock|both)             [default: SHERLOCK] Defines the pseudo type to use. Can be one of ['expansion', 'sherlock', 'both']
  --clearCache                                           Clear cache. Use this to log in as a different user.
  --cliInfo                                              Information about config and cache file location.
  --editorMessageOutputPath=editorMessageOutputPath      [default: i18n/editorTranslations.json] Defines the output directory for the extracted editor messages
  --editorProjectId=editorProjectId                      Defines the editor project ID and enables editor i18n translations
  --fileNameIgnorePattern=fileNameIgnorePattern          [default: **/__mocks__/**,**/__local_mocks__/**,**/basic.metadata.schema.json,**/dist/**,**/node_modules/**] Comma separated list of filename patterns to ignore
  --help                                                 show CLI help
  --jsxMessageOutputPath=jsxMessageOutputPath            [default: i18n/src/js-jsx-strings.json] Defines the output directory for the extracted jsx messages
  --mergeBizCompOutputDir=mergeBizCompOutputDir          [default: i18n/biz-comp-translations] Defines the output filename of merged translations
  --messagesFileNamePattern=messagesFileNamePattern      [default: i18n/src/**/*.json] Defines where the extracted messages have been stored
  --metadataMessageOutputDir=metadataMessageOutputDir    [default: i18n] Defines the output directory for the extracted metadata messages
  --pseudoOutputFileName=pseudoOutputFileName            [default: yy.json] Defines the output file name template
  --reset                                                Reset config to default and clear cache

Theme-Definitionen für Jutro-Apps generieren

Um eine CSS-Datei zu generieren, die für eine Theme-Definition in einer Jutro-App verwendet werden kann, führen Sie den folgenden Befehl aus:

jutro generate:themes

Mit diesem Befehl erzeugen Sie eine .css-Überschreibungsdatei basierend auf der Datei .themesConfig.json in der Konfigurationsdatei definierten Design-Token-Konfiguration.

Wenn keine .themesConfig.json-Datei vorhanden ist und Sie den Befehl ausführen, werden Sie aufgefordert, Folgendes anzugeben:

Name des Theme
Ausdruck, der den Eingabepfad des Theme-Tokens angibt (Standardpfad ist src/tokens/**/*.json)
Name der Ausgabedatei
Pfad für die optionale Zuordnung von benutzerdefinierten Variablen zu Token
Pfad für die optionale benutzerdefinierte Transformation
Möglichkeit, ein weiteres Design hinzuzufügen

Um weitere Informationen über den Befehl generate:themes zu erhalten oder um eine Liste aller verfügbaren CLI-Argumente zu erhalten, führen Sie den folgenden Befehl aus:

jutro generate:themes --help

Die Ausgabe sieht ähnlich aus wie diese:

USAGE
  $ @jutro/cli-generate generate:themes

OPTIONS
  -c, --configPath=configPath  Defines the path of the directory that contains the .themesConfig.json file
  -s, --encapsulateThemes      When the app is used as a micro frontend, generated themes will be scoped to this app, not the shell app. CSS
                               selector will include JUTRO_APP_ID value.
  --clearCache                 Clear cache. Use this to log in as a different user.
  --cliInfo                    Information about config and cache file location.
  --help                       show CLI help
  --reset                      Reset config to default and clear cache

EXAMPLE
  $ @jutro/cli-generate generate:themes

--encapsulateThemes ist eine boolesche Option, die nur für Micro Frontends relevant ist, wenn der Modus Modulföderation verwendet wird. Wenn diese Option angegeben ist, verfügen die generierten Designs über einen CSS-Selektor, der scopeName der App enthält, sodass diese Designs nur für das jeweilige Micro Frontend und nicht für die Shell-App gelten. scopeName wird durch die Umgebungsvariable JUTRO_APP_ID bestimmt. Standardmäßig ist diese Option auf false eingestellt.

Digital SDK generieren

Einzelheiten zum Erzeugen des Digital SDK mit der Jutro Platform CLI finden Sie unter SDK-Erzeugung und -Einrichtung

validate-Befehle

Abhängigkeiten validieren

Um die Abhängigkeiten der App zu validieren, führen Sie den folgenden Befehl aus:

jutro validate:dependencies

Dieser Befehl validiert die Abhängigkeiten für ein bestimmtes Projekt, indem er die Projektdatei package.json und die vom Projekt verwendeten Module vergleicht. Er gibt eine Liste aller nicht verwendeten, fehlenden und nicht strikt versionierten Abhängigkeiten aus. Sie müssen eine .depcheckrc.js-Datei im Stammverzeichnis des Projekts hinzufügen, in der die zu ignorierenden Module aufgeführt sind.

Die Datei .depcheckrc.js hat folgende Struktur:

const options = {
  ignoreMatches: [
    '@jutro/auth',
    '@jutro/cli-snapshot-tools',
    '@jutro/cli-snapshots',
    '@jutro/components',
    '@jutro/platform',
    '@jutro/prop-types',
    'jest-extended',
    'src',
    'jest-teamcity-reporter',
    'json5-jest',
    'lerna',
    'lint-staged',
    'prop-types',
    'ts-jest',
  ],
};

module.exports = { options };

Sie können die folgenden Argumente auch direkt in einem Jutro Platform CLI-Befehl angeben:

Eine durch Kommas getrennte Liste von Ignoriermustern, die bei der Erkennung von Paketen verwendet werden (Standardwert ist **/__mocks__/**,**/__local_mocks__/**,**/basic.metadata.schema.json,**/dist/**,**/node_modules/**).
Das Dateinamensmuster für zu validierende Pakete (Standardwert ist **/package.json).

Sie können diese direkt in einem Jutro Platform CLI-Befehl wie folgt festlegen:

jutro validate:dependencies --globIgnorePatterns=GLOB_IGNORE_PATTERNS --packageFileNamePattern=PACKAGE_FILENAME_PATTERN

Ordnerstruktur der Jutro-App validieren

Um die Ordnerstruktur der Jutro-App zu validieren, führen Sie den folgenden Befehl aus:

jutro validate:folders

Dieser Befehl validiert die erforderlichen Dateien und die Struktur der App anhand einer Standardstruktur der Jutro-App. Wenn Dateien oder Ordner fehlen, erhalten Sie einen Hinweis in den Protokollen.

Parameter für benutzerdefinierte Pakete

Sie können den --custom-packages-Parameter hinzufügen, um eine Struktur basierend auf Pipelines für Ihr benutzerdefiniertes Paket-Repository zu validieren. Eine validierte Struktur sieht wie folgt aus:

.
├── package.json
└── packages/
    └── {package-name}/
        ├── package.json
        └── src/
            └── index.ts

Die CLI wird in den folgenden Situationen mit einem Fehler beendet:

Es gibt kein /packages-Verzeichnis im Stammverzeichnis.
Es gibt keine package.json-Datei im Stammverzeichnis.
Nicht alle /packages/{package-name}-Verzeichnisse enthalten eine package.json- und eine /src/index.js-Datei.

i18n-Übersetzungen in der Jutro-App validieren

Um die i18n-Übersetzungen in der Jutro-App zu validieren, führen Sie den folgenden Befehl aus:

jutro validate:i18n

Dieser Befehl erzeugt die aktuelle Übersetzung in lang.json und prüft, ob die im --translationFileName-Flag übergebene Übersetzungsdatei (Standardwert ist en.json) mit der erzeugten Datei übereinstimmt. Um alle Flags zu prüfen, die dem jutro validate:i18n-Befehl übergeben werden können, geben Sie jutro validate:i18n --help in Ihrem Terminal ein:

Verifies i18n translations

USAGE
  $ jutro validate:i18n

OPTIONS
  -j, --jsxFileNamePattern=jsxFileNamePattern            [default: src/**/*.{ts,tsx,js,jsx}] Defines the file name pattern of your JSX files
  -m, --metadataFileNamePattern=metadataFileNamePattern  [default: src/**/*.{metadata,config}.json5] Defines the file name pattern for your metadata JSON files
  -o, --translationOutputDir=translationOutputDir        [default: src/i18n] Defines where the output messages combining default translations and extracted translations are stored
  --clearCache                                           Clear cache. Use this to log in as a different user.
  --cliInfo                                              Information about config and cache file location.
  --fileNameIgnorePattern=fileNameIgnorePattern          [default: **/__mocks__/**,**/__local_mocks__/**,**/basic.metadata.schema.json,**/dist/**,**/node_modules/**] Comma separated list of filename patterns to ignore
  --help                                                 show CLI help
  --reset                                                Reset config to default and clear cache
  --translationFileName=translationFileName              [default: en.json] Translation file to be checked against lang.json

EXAMPLE
  $ jutro validate:i18n

Linters in der Jutro-App validieren

Um die Linters in der Jutro-App zu validieren, führen Sie den folgenden Befehl aus:

jutro validate:linters

Dieser Befehl führt eslint, stylelint und prettier in der App aus und benachrichtigt Sie, falls in der App Probleme auftreten. Sie können mithilfe dieses Befehls auch eslint-, stylelint- und prettier-Flags übergeben, indem Sie die Flags eslintFlags, stylelintFlags und prettierFlags wie folgt verwenden:

jutro validate:linters --eslintFlags="**/*.{ts,tsx,js}" --stylelintFlags="**/*.scss" --prettierFlags="--check '**/*.{ts,tsx,js,json,scss,mdx}'"

Migrationspakete in der Jutro-App validieren

Um die Migrationen in der Jutro-App zu validieren, führen Sie den folgenden Befehl aus:

jutro validate:migrations

Dieser Befehl prüft, ob Ihr Migrationspaket richtig geschrieben ist, indem er seine Ordnerstruktur validiert und ob alle erforderlichen Migrationen (CSS, JS, Metadaten, Paket und Assets) richtig eingestellt sind und die richtigen Typen verwenden. Stellen Sie sicher, dass Sie den Pfad des Migrationsordners mit dem --migrationsDir-Flag wie folgt angeben:

jutro validate:migrations --migrationsDir=PATH_TO_THE_MIGRATION_FOLDER

Tests in der Jutro-App validieren

Um die in der Jutro-App definierten Tests zu validieren, führen Sie den folgenden Befehl aus:

jutro validate:tests

Warning: jutro validate:tests wurde verworfen. Verwenden Sie stattdessen den Befehl jutro app:tests, um die Komponententests der App auszuführen.

Mit diesem Befehl werden automatisch alle in der App definierten Tests ausgeführt und die erfolgreichen oder fehlgeschlagenen Protokolle angezeigt. Wie im Befehl validate:linters ist es möglich, jest-bezogene Flags direkt an diesen Befehl zu übergeben. So können --jestHelp verwenden, um Informationen darüber erhalten, welche Parameter Sie mit dem --jestFlags-Flag verwenden können, zum Beispiel:

jutro validate:tests --jestFlags="--testPathPattern=*-test.js --watchAll=false --passWithNoTests"

Lighthouse-Bericht für die Jutro-App generieren

Um einen Lighthouse-Bericht in der Jutro-App zu generieren, führen Sie den folgenden Befehl aus:

jutro validate:lighthouse

-u – URL, unter der die Anwendung ausgeführt wird
-c – Pfad der benutzerdefinierten Konfigurationsdatei

Der Pfad sollte absolut oder relativ zum Stammverzeichnis des Projekts sein. Wenn der Parameter nicht angegeben ist, wird der Pfad standardmäßig auf die Datei .lighthouserc im Stammverzeichnis des Projekts festgelegt, sofern diese vorhanden ist. Andernfalls wird die Standardkonfiguration verwendet.

Die Konfigurationsdatei kann eine JSON-, JS- oder YML-Datei sein.

Informationen zum Konfigurationsformat finden Sie hier: https://github.com/GoogleChrome/lighthouse/blob/master/docs/configuration.md
-o – Ausgabeordner für den Lighthouse-Bericht
-m – Ausgabemodi des Berichts

Unterstützte Modi sind 'html', 'json' oder 'csv'. Der Standardwert ist 'html'.

Verwenden Sie bei mehreren Modi ein Komma, um sie zu trennen. Zum Beispiel -m html,csv.

jutro validate:lighthouse -u http://localhost:3001 -o ./lighthouse -m html,json -c ./customconfig.js

Wenn in Ihrer App die Authentifizierung aktiviert ist, können Sie außerdem Ihr eigenes Puppeteer-Skript angeben, um die Anmeldung vor der Erzeugung des Berichts durchzuführen.

-p – Pfad zu Ihrem Anmeldeskript (siehe Beispiel unten)
-l – Benutzername für die Anmeldung
-p – Verwendetes Kennwort für die Anmeldung

jutro validate:lighthouse -u http://localhost:3001 -o ./lighthouse -p pathToLoginScript.js -l username -p password

Das Anmeldeskript erhält die Browser-Instanz und, falls angegeben, die in den Befehlsargumenten übergebene Kombination aus Anmeldename und Kennwort.

Das Anmeldeskript sollte in etwa so aussehen:

const page = await browser.newPage();
await page.goto('http://localhost:3001'); // Application URL matching the one you give from the command
const usernameInput = 'input[name="username"]';
const passwordInput = 'input[name="password"]';
await page.waitForSelector(usernameInput);
await page.type(usernameInput, username); // username from the -l in the command
await page.keyboard.press('Enter');
await page.waitForSelector(passwordInput);
await page.type(usernameInput, username);
await page.type(passwordInput, password); // password from the -p in the command
await page.keyboard.press('Enter');

Note: Sie können Variablen mit dem Namen browser, username oder password nicht umdefinieren, da sie über die CLI an das Skript übergeben werden.

Es gibt ein standardmäßiges Anmeldeskript für unsere Standard-Okta-Anmeldeseite, so dass Sie den Befehl ausführen können, indem Sie lediglich den Benutzernamen und das Kennwort übergeben:

jutro validate:lighthouse -u http://localhost:3001 -o ./lighthouse -l username -p password

App-Befehle

Befehl zum Ausführen der Komponententests der App

Um die Komponententests der App auszuführen, führen Sie den folgenden Befehl aus:

jutro app:tests

Dieser Befehl führt automatisch alle in Ihrer App definierten Unit-Tests aus und protokolliert die erfolgreichen und fehlgeschlagenen Tests (falls vorhanden). Sie können die Pfade jest.config.js und overrides.config.js direkt an den Befehl übergeben, zum Beispiel:

jutro app:tests --jestConfigPath="/path/to/config/my.custom.jest.config.js" --overridesPath="/path/to/overrides/my.custom.overrides.config.js"

Wenn sie nicht gesetzt sind, sucht der Befehl nach jest.config.js und overrides.config.js im gleichen Verzeichnis, in dem der Befehl ausgeführt wird. Wenn die Suche erfolglos ist, wird der Befehl trotzdem mit einer Standardkonfiguration ausgeführt.

Es ist auch möglich, jest-bezogene Flags direkt an diesen Befehl zu übergeben:

jutro app:tests --testPathPattern=*-test.js --watchAll=false --passWithNoTests --collectCoverage

Befehl zum Starten der App

Um die Jutro-App zu bündeln und zu starten, führen Sie den folgenden Befehl aus:

jutro app:start

Mit diesem Befehl wird die App gebündelt und auf Ihrem lokalen Server gestartet (standardmäßig localhost:3000). Er kann entweder im development- (Standard) oder im production-Modus ausgeführt werden. mode wird verwendet, um die globalen Variablen process.env.NODE_ENV und process.env.BABEL_ENV zu setzen und um React in den richtigen Modus zu versetzen. Sobald Ihre App gebündelt ist, wird ein neues Browserfenster geöffnet, in dem Ihre App ausgeführt wird.

jutro app:start --mode=production

Befehl für App-Build

Führen Sie zum Erstellen eines Anwendungs-Builds den folgenden Befehl aus:

jutro app:build

Dieser Befehl erstellt den Anwendungs-Build und speichert ihn im dist-Ordner. Sie können den App-Build-Modus mit dem mode-Flag, das development akzeptiert (Standard) und production als optionalen Wert an den Befehl übergeben. Sie können die Build-Metadaten mit dem writeBuildStatsToFile-Flag erstellen, das vom Typ Boolean ist. Wenn Sie dieses Flag an den Build-Befehl übergeben, wird eine Datei mit dem Namen bundle-stats.json im Ordner dist erstellt. Wenn Sie die Build-Metadaten nicht in die Datei schreiben möchten, können Sie das --no-writeBuildStatsToFile-Flag übergeben.

jutro app:build --mode=production --writeBuildStatsToFile

Um weitere Informationen über den Befehl app:build und eine Liste aller CLI-Argumente zu erhalten, geben Sie Folgendes im Terminal ein:

app:build  --help

Die Ausgabe sieht ähnlich aus wie diese:

USAGE
  $ jutro app:build

OPTIONS
  -m, --mode=development|production  [default: production] Mode for app build
  -s, --[no-]showProgress            Flag to show the progress of the build
  -w, --[no-]writeBuildStatsToFile   Flag to enable writing build stats to a file
  --clearCache                       Clear cache. Use this to log in as a different user.
  --cliInfo                          Information about config and cache file location.
  --help                             Show CLI help
  --reset                            Reset config to default and clear cache
  --[no-]verify                      Verify app installation before building it

EXAMPLE
  $ jutro app:build

Was stellt die Jutro Platform CLI bereit?​

Liste der Befehle​

Generierungsbefehle​

Validierungsbefehle​

App-Befehle​

generate-Befehle​

Änderungsprotokoll generieren​

Internationalisierungsübersetzungen generieren​

Theme-Definitionen für Jutro-Apps generieren​

Digital SDK generieren​

validate-Befehle​

Abhängigkeiten validieren​

Ordnerstruktur der Jutro-App validieren​

Parameter für benutzerdefinierte Pakete​

i18n-Übersetzungen in der Jutro-App validieren​

Linters in der Jutro-App validieren​

Migrationspakete in der Jutro-App validieren​

Tests in der Jutro-App validieren​

Lighthouse-Bericht für die Jutro-App generieren​

App-Befehle​

Befehl zum Ausführen der Komponententests der App​

Befehl zum Starten der App​

Befehl für App-Build​

Was stellt die Jutro Platform CLI bereit?

Liste der Befehle

Generierungsbefehle

Validierungsbefehle

App-Befehle

generate-Befehle

Änderungsprotokoll generieren

Internationalisierungsübersetzungen generieren

Theme-Definitionen für Jutro-Apps generieren

Digital SDK generieren

validate-Befehle

Abhängigkeiten validieren

Ordnerstruktur der Jutro-App validieren

Parameter für benutzerdefinierte Pakete

i18n-Übersetzungen in der Jutro-App validieren

Linters in der Jutro-App validieren

Migrationspakete in der Jutro-App validieren

Tests in der Jutro-App validieren

Lighthouse-Bericht für die Jutro-App generieren

App-Befehle

Befehl zum Ausführen der Komponententests der App

Befehl zum Starten der App

Befehl für App-Build