gtx-cli 2.1.5-alpha.5 → 2.1.5-alpha.6

package/dist/api/checkFileTranslations.d.ts

@@ -20,7 +20,4 @@ export declare function checkFileTranslations(data: {
         versionId: string;
         fileName: string;
     };
-}, locales: string[], timeoutDuration: number, resolveOutputPath: (sourcePath: string, locale: string) => string, downloadStatus: {
-    downloaded: Set<string>;
-    failed: Set<string>;
-}, options: Settings): Promise<boolean>;
+}, locales: string[], timeoutDuration: number, resolveOutputPath: (sourcePath: string, locale: string) => string | null, options: Settings): Promise<boolean>;

package/dist/api/checkFileTranslations.js

@@ -1,9 +1,9 @@
 import chalk from 'chalk';
 import { createOraSpinner, logError } from '../console/logging.js';
 import { getLocaleProperties } from 'generaltranslation';
-import { downloadFile } from './downloadFile.js';
 import { downloadFileBatch } from './downloadFileBatch.js';
 import { gt } from '../utils/gt.js';
+import { TEMPLATE_FILE_NAME } from '../cli/commands/stage.js';
 /**
  * Checks the status of translations for a given version ID
  * @param apiKey - The API key for the General Translation API
@@ -14,13 +14,18 @@ import { gt } from '../utils/gt.js';
  * @param timeoutDuration - The timeout duration for the wait in seconds
  * @returns True if all translations are deployed, false otherwise
  */
-export async function checkFileTranslations(data, locales, timeoutDuration, resolveOutputPath, downloadStatus, options) {
+export async function checkFileTranslations(data, locales, timeoutDuration, resolveOutputPath, options) {
     const startTime = Date.now();
     console.log();
     const spinner = await createOraSpinner();
     spinner.start('Waiting for translation...');
     // Initialize the query data
     const fileQueryData = prepareFileQueryData(data, locales);
+    const downloadStatus = {
+        downloaded: new Set(),
+        failed: new Set(),
+        skipped: new Set(),
+    };
     // Do first check immediately
     const initialCheck = await checkTranslationDeployment(fileQueryData, downloadStatus, spinner, resolveOutputPath, options);
     if (initialCheck) {
@@ -146,7 +151,8 @@ function generateStatusSuffixText(downloadStatus, fileQueryData) {
             localeStatuses.push(chalk.yellow(`${pendingCodes}`));
         }
         // Format the line
-        newSuffixText.push(`${chalk.bold(fileName)} [${localeStatuses.join(', ')}]`);
+        const prettyFileName = fileName === TEMPLATE_FILE_NAME ? '<React Elements>' : fileName;
+        newSuffixText.push(`${chalk.bold(prettyFileName)} [${localeStatuses.join(', ')}]`);
     }
     // If we couldn't show all files, add an indicator
     if (filesArray.length > maxFilesToShow) {
@@ -161,7 +167,8 @@ async function checkTranslationDeployment(fileQueryData, downloadStatus, spinner
     try {
         // Only query for files that haven't been downloaded yet
         const currentQueryData = fileQueryData.filter((item) => !downloadStatus.downloaded.has(`${item.fileName}:${item.locale}`) &&
-            !downloadStatus.failed.has(`${item.fileName}:${item.locale}`));
+            !downloadStatus.failed.has(`${item.fileName}:${item.locale}`) &&
+            !downloadStatus.skipped.has(`${item.fileName}:${item.locale}`));
         // If all files have been downloaded, we're done
         if (currentQueryData.length === 0) {
             return true;
@@ -173,11 +180,17 @@ async function checkTranslationDeployment(fileQueryData, downloadStatus, spinner
         const readyTranslations = translations.filter((translation) => translation.isReady && translation.fileName);
         if (readyTranslations.length > 0) {
             // Prepare batch download data
-            const batchFiles = readyTranslations.map((translation) => {
+            const batchFiles = readyTranslations
+                .map((translation) => {
                 const locale = translation.locale;
                 const fileName = translation.fileName;
                 const translationId = translation.id;
                 const outputPath = resolveOutputPath(fileName, locale);
+                // Skip downloading GTJSON files that are not in the files configuration
+                if (outputPath === null) {
+                    downloadStatus.skipped.add(`${fileName}:${locale}`);
+                    return null;
+                }
                 return {
                     translationId,
                     inputPath: fileName,
@@ -185,44 +198,28 @@ async function checkTranslationDeployment(fileQueryData, downloadStatus, spinner
                     locale,
                     fileLocale: `${fileName}:${locale}`,
                 };
-            });
-            // Use batch download if there are multiple files
-            if (batchFiles.length > 1) {
-                const batchResult = await downloadFileBatch(batchFiles.map(({ translationId, outputPath, inputPath, locale }) => ({
-                    translationId,
-                    outputPath,
-                    inputPath,
-                    locale,
-                })), options);
-                // Process results
-                batchFiles.forEach((file) => {
-                    const { translationId, fileLocale } = file;
-                    if (batchResult.successful.includes(translationId)) {
-                        downloadStatus.downloaded.add(fileLocale);
-                    }
-                    else if (batchResult.failed.includes(translationId)) {
-                        downloadStatus.failed.add(fileLocale);
-                    }
-                });
-            }
-            else if (batchFiles.length === 1) {
-                // For a single file, use the original downloadFile method
-                const file = batchFiles[0];
-                const result = await downloadFile(file.translationId, file.outputPath, file.inputPath, file.locale, options);
-                if (result) {
-                    downloadStatus.downloaded.add(file.fileLocale);
+            })
+                .filter((file) => file !== null);
+            const batchResult = await downloadFileBatch(batchFiles, options);
+            // Process results
+            batchFiles.forEach((file) => {
+                const { translationId, fileLocale } = file;
+                if (batchResult.successful.includes(translationId)) {
+                    downloadStatus.downloaded.add(fileLocale);
                 }
-                else {
-                    downloadStatus.failed.add(file.fileLocale);
+                else if (batchResult.failed.includes(translationId)) {
+                    downloadStatus.failed.add(fileLocale);
                 }
-            }
+            });
         }
         // Force a refresh of the spinner display
         const statusText = generateStatusSuffixText(downloadStatus, fileQueryData);
         // Clear and reapply the suffix to force a refresh
         spinner.text = statusText;
         // If all files have been downloaded, we're done
-        if (downloadStatus.downloaded.size + downloadStatus.failed.size ===
+        if (downloadStatus.downloaded.size +
+            downloadStatus.failed.size +
+            downloadStatus.skipped.size ===
             fileQueryData.length) {
             return true;
         }

package/dist/api/downloadFileBatch.d.ts

@@ -4,6 +4,7 @@ export type BatchedFiles = Array<{
     outputPath: string;
     inputPath: string;
     locale: string;
+    fileLocale: string;
 }>;
 export type DownloadFileBatchResult = {
     successful: string[];

package/dist/api/sendFiles.d.ts

@@ -1,9 +1,5 @@
-import { Settings } from '../types/index.js';
+import { Settings, TranslateFlags } from '../types/index.js';
 import { CompletedFileTranslationData, FileToTranslate } from 'generaltranslation/types';
-export type ApiOptions = Settings & {
-    publish: boolean;
-    wait: boolean;
-};
 export type SendFilesResult = {
     data: Record<string, {
         fileName: string;
@@ -18,11 +14,4 @@ export type SendFilesResult = {
  * @param options - The options for the API call
  * @returns The translated content or version ID
  */
-export declare function sendFiles(files: FileToTranslate[], options: ApiOptions): Promise<{
-    data: Record<string, {
-        fileName: string;
-        versionId: string;
-    }>;
-    locales: string[];
-    translations: CompletedFileTranslationData[];
-}>;
+export declare function sendFiles(files: FileToTranslate[], options: TranslateFlags, settings: Settings): Promise<SendFilesResult>;

package/dist/api/sendFiles.js

@@ -1,27 +1,34 @@
 import chalk from 'chalk';
 import { createSpinner, logMessage, logSuccess } from '../console/logging.js';
 import { gt } from '../utils/gt.js';
+import { TEMPLATE_FILE_NAME } from '../cli/commands/stage.js';
 /**
  * Sends multiple files for translation to the API
  * @param files - Array of file objects to translate
  * @param options - The options for the API call
  * @returns The translated content or version ID
  */
-export async function sendFiles(files, options) {
+export async function sendFiles(files, options, settings) {
     logMessage(chalk.cyan('Files to translate:') +
         '\n' +
-        files.map((file) => `  - ${chalk.bold(file.fileName)}`).join('\n'));
+        files
+            .map((file) => {
+            if (file.fileName === TEMPLATE_FILE_NAME) {
+                return `- <React Elements>`;
+            }
+            return `- ${file.fileName}`;
+        })
+            .join('\n'));
     const spinner = createSpinner('dots');
     spinner.start(`Sending ${files.length} file${files.length !== 1 ? 's' : ''} to General Translation API...`);
     try {
         // Send the files to the API
         const responseData = await gt.enqueueFiles(files, {
-            publish: options.publish,
-            description: options.description,
-            sourceLocale: options.defaultLocale,
-            targetLocales: options.locales,
-            _versionId: options._versionId,
-            modelProvider: options.modelProvider,
+            publish: settings.publish,
+            sourceLocale: settings.defaultLocale,
+            targetLocales: settings.locales,
+            version: settings.version, // not set ATM
+            modelProvider: settings.modelProvider,
         });
         // Handle version ID response (for async processing)
         const { data, message, locales, translations } = responseData;

package/dist/cli/base.d.ts

@@ -1,25 +1,11 @@
 import { Command } from 'commander';
-import { Settings, SupportedLibraries, SetupOptions } from '../types/index.js';
+import { Settings, SupportedLibraries, SetupOptions, TranslateFlags } from '../types/index.js';
 export type UploadOptions = {
     config?: string;
     apiKey?: string;
     projectId?: string;
     defaultLocale?: string;
 };
-export type TranslateOptions = {
-    config?: string;
-    defaultLocale?: string;
-    locales?: string[];
-    apiKey?: string;
-    projectId?: string;
-    dryRun: boolean;
-    experimentalLocalizeStaticUrls?: boolean;
-    experimentalHideDefaultLocale?: boolean;
-    experimentalFlattenJsonFiles?: boolean;
-    experimentalLocalizeStaticImports?: boolean;
-    excludeStaticUrls?: string[];
-    excludeStaticImports?: string[];
-};
 export type LoginOptions = {
     keyType?: 'development' | 'production';
 };
@@ -30,14 +16,16 @@ export declare class BaseCLI {
     constructor(program: Command, library: SupportedLibraries, additionalModules?: SupportedLibraries[]);
     init(): void;
     execute(): void;
-    protected setupGTCommand(): void;
+    protected setupStageCommand(): void;
+    protected setupTranslateCommand(): void;
+    protected handleStage(initOptions: TranslateFlags): Promise<void>;
+    protected handleTranslate(initOptions: TranslateFlags): Promise<void>;
     protected setupUploadCommand(): void;
     protected setupLoginCommand(): void;
     protected setupInitCommand(): void;
     protected setupConfigureCommand(): void;
     protected setupSetupCommand(): void;
     protected handleUploadCommand(settings: Settings & UploadOptions): Promise<void>;
-    protected handleGenericTranslate(settings: Settings & TranslateOptions): Promise<void>;
     protected handleSetupReactCommand(options: SetupOptions): Promise<void>;
     protected handleInitCommand(ranReactSetup: boolean): Promise<void>;
     protected handleLoginCommand(options: LoginOptions): Promise<void>;

package/dist/cli/base.js

@@ -5,7 +5,6 @@ import path from 'node:path';
 import fs from 'node:fs';
 import { generateSettings } from '../config/generateSettings.js';
 import chalk from 'chalk';
-import { translateFiles } from '../formats/files/translate.js';
 import { FILE_EXT_TO_EXT_LABEL } from '../formats/files/supportedFiles.js';
 import { handleSetupReactCommand } from '../setup/wizard.js';
 import { isPackageInstalled, searchForPackageJson, } from '../utils/packageJson.js';
@@ -14,11 +13,12 @@ import { installPackage } from '../utils/installPackage.js';
 import { getPackageManager } from '../utils/packageManager.js';
 import { retrieveCredentials, setCredentials } from '../utils/credentials.js';
 import { areCredentialsSet } from '../utils/credentials.js';
-import localizeStaticUrls from '../utils/localizeStaticUrls.js';
-import flattenJsonFiles from '../utils/flattenJsonFiles.js';
-import localizeStaticImports from '../utils/localizeStaticImports.js';
-import copyFile from '../fs/copyFile.js';
 import { upload } from '../formats/files/upload.js';
+import { attachTranslateFlags } from './flags.js';
+import { handleStage } from './commands/stage.js';
+import { handleDownload, handleTranslate, postProcessTranslations, } from './commands/translate.js';
+import localizeStaticUrls from '../utils/localizeStaticUrls.js';
+import updateConfig from '../fs/config/updateConfig.js';
 export class BaseCLI {
     library;
     additionalModules;
@@ -36,7 +36,7 @@ export class BaseCLI {
     }
     // Init is never called in a child class
     init() {
-        this.setupGTCommand();
+        this.setupTranslateCommand();
     }
     // Execute is called by the main program
     execute() {
@@ -45,28 +45,57 @@ export class BaseCLI {
             process.argv.push('init');
         }
     }
-    setupGTCommand() {
-        this.program
+    setupStageCommand() {
+        attachTranslateFlags(this.program
+            .command('stage')
+            .description('Submits the project to the General Translation API for translation. Translations created using this command will require human approval.')).action(async (initOptions) => {
+            displayHeader('Staging project for translation with approval required...');
+            await this.handleStage(initOptions);
+            endCommand('Done!');
+        });
+    }
+    setupTranslateCommand() {
+        attachTranslateFlags(this.program
             .command('translate')
-            .description('Translate your project using General Translation')
-            .option('-c, --config <path>', 'Filepath to config file, by default gt.config.json', findFilepath(['gt.config.json']))
-            .option('--api-key <key>', 'API key for General Translation cloud service')
-            .option('--project-id <id>', 'Project ID for the translation service')
-            .option('--default-language, --default-locale <locale>', 'Default locale (e.g., en)')
-            .option('--new, --locales <locales...>', 'Space-separated list of locales (e.g., en fr es)')
-            .option('--dry-run', 'Dry run, does not send updates to General Translation API', false)
-            .option('--experimental-localize-static-urls', 'Triggering this will run a script after the cli tool that localizes all urls in content files. Currently only supported for md and mdx files.', false)
-            .option('--experimental-hide-default-locale', 'When localizing static locales, hide the default locale from the path', false)
-            .option('--experimental-flatten-json-files', 'Triggering this will flatten the json files into a single file. This is useful for projects that have a lot of json files.', false)
-            .option('--experimental-localize-static-imports', 'Triggering this will run a script after the cli tool that localizes all static imports in content files. Currently only supported for md and mdx files.', false)
-            .action(async (initOptions) => {
+            .description('Translate your project using General Translation')).action(async (initOptions) => {
             displayHeader('Starting translation...');
-            const settings = await generateSettings(initOptions);
-            const options = { ...initOptions, ...settings };
-            await this.handleGenericTranslate(options);
+            await this.handleTranslate(initOptions);
             endCommand('Done!');
         });
     }
+    async handleStage(initOptions) {
+        const settings = await generateSettings(initOptions);
+        if (!settings.stageTranslations) {
+            // Update settings.stageTranslations to true
+            settings.stageTranslations = true;
+            await updateConfig({
+                configFilepath: settings.config,
+                stageTranslations: true,
+            });
+        }
+        await handleStage(initOptions, settings, this.library, true);
+    }
+    async handleTranslate(initOptions) {
+        const settings = await generateSettings(initOptions);
+        if (!settings.stageTranslations) {
+            const results = await handleStage(initOptions, settings, this.library, false);
+            // Process default locale static URLs first, before translations
+            if (settings.options?.experimentalLocalizeStaticUrls) {
+                await localizeStaticUrls(settings, [settings.defaultLocale]);
+            }
+            if (results) {
+                await handleTranslate(initOptions, settings, results);
+            }
+        }
+        else {
+            // Process default locale static URLs first, before downloading translations
+            if (settings.options?.experimentalLocalizeStaticUrls) {
+                await localizeStaticUrls(settings, [settings.defaultLocale]);
+            }
+            await handleDownload(initOptions, settings);
+        }
+        await postProcessTranslations(settings);
+    }
     setupUploadCommand() {
         this.program
             .command('upload')
@@ -197,55 +226,6 @@ See the docs for more information: https://generaltranslation.com/docs/react/tut
         // Process all file types at once with a single call
         await upload(sourceFiles, placeholderPaths, transformPaths, dataFormat, settings);
     }
-    async handleGenericTranslate(settings) {
-        // dataFormat for JSONs
-        let dataFormat;
-        if (this.library === 'next-intl') {
-            dataFormat = 'ICU';
-        }
-        else if (this.library === 'i18next') {
-            if (this.additionalModules.includes('i18next-icu')) {
-                dataFormat = 'ICU';
-            }
-            else {
-                dataFormat = 'I18NEXT';
-            }
-        }
-        else {
-            dataFormat = 'JSX';
-        }
-        if (!settings.files ||
-            (Object.keys(settings.files.placeholderPaths).length === 1 &&
-                settings.files.placeholderPaths.gt)) {
-            return;
-        }
-        const { resolvedPaths: sourceFiles, placeholderPaths, transformPaths, } = settings.files;
-        // Localize static urls in default locale BEFORE translation
-        if (settings.experimentalLocalizeStaticUrls) {
-            await localizeStaticUrls(settings, [settings.defaultLocale]);
-        }
-        // Process all file types at once with a single call
-        await translateFiles(sourceFiles, placeholderPaths, transformPaths, dataFormat, settings);
-        // Localize static urls in other locales AFTER translation
-        if (settings.experimentalLocalizeStaticUrls) {
-            const otherLocales = settings.locales.filter((locale) => locale !== settings.defaultLocale);
-            if (otherLocales.length > 0) {
-                await localizeStaticUrls(settings, otherLocales);
-            }
-        }
-        // Localize static imports (/docs -> /[locale]/docs)
-        if (settings.experimentalLocalizeStaticImports) {
-            await localizeStaticImports(settings);
-        }
-        // Flatten json files into a single file
-        if (settings.experimentalFlattenJsonFiles) {
-            await flattenJsonFiles(settings);
-        }
-        // Copy files to the target locale
-        if (settings.options?.copyFiles) {
-            await copyFile(settings);
-        }
-    }
     async handleSetupReactCommand(options) {
         await handleSetupReactCommand(options);
     }
@@ -265,13 +245,14 @@ See the docs for more information: https://generaltranslation.com/docs/react/tut
         const usingCDN = isUsingGT
             ? await promptConfirm({
                 message: `Auto-detected that you're using gt-next or gt-react. Would you like to use the General Translation CDN to store your translations?\nSee ${isUsingGTNext
-                    ? 'https://generaltranslation.com/docs/next/reference/local-tx'
-                    : 'https://generaltranslation.com/docs/react/reference/local-tx'} for more information.\nIf you answer no, we'll configure the CLI tool to download completed translations.`,
+                    ? 'https://generaltranslation.com/en/docs/next/guides/local-tx'
+                    : 'https://generaltranslation.com/en/docs/react/guides/local-tx'} for more information.\nIf you answer no, we'll configure the CLI tool to download completed translations.`,
                 defaultValue: true,
             })
             : false;
         if (isUsingGT && !usingCDN) {
-            logMessage(`To prevent translations from being published, please disable the project setting on the dashboard: ${chalk.cyan('https://dash.generaltranslation.com/settings/project')}`);
+            logMessage(`Make sure to add a loadTranslations function to your app configuration to correctly use local translations.
+See https://generaltranslation.com/en/docs/next/guides/local-tx`);
         }
         // Ask where the translations are stored
         const translationsDir = isUsingGT && !usingCDN
@@ -320,6 +301,7 @@ See the docs for more information: https://generaltranslation.com/docs/react/tut
             defaultLocale,
             locales,
             files: Object.keys(files).length > 0 ? files : undefined,
+            publish: isUsingGT && usingCDN,
         });
         logSuccess(`Feel free to edit ${chalk.cyan(configFilepath)} to customize your translation setup. Docs: https://generaltranslation.com/docs/cli/reference/config`);
         // Install gtx-cli if not installed

package/dist/cli/commands/stage.d.ts

@@ -0,0 +1,5 @@
+import { Settings, SupportedLibraries, TranslateFlags } from '../../types/index.js';
+import { SendFilesResult } from '../../api/sendFiles.js';
+export declare const TEMPLATE_FILE_NAME = "__INTERNAL_GT_TEMPLATE_NAME__";
+export declare const TEMPLATE_FILE_ID: string;
+export declare function handleStage(options: TranslateFlags, settings: Settings, library: SupportedLibraries, stage: boolean): Promise<SendFilesResult | undefined>;

package/dist/cli/commands/stage.js

@@ -0,0 +1,100 @@
+import { logErrorAndExit, logSuccess } from '../../console/logging.js';
+import { noLocalesError, noDefaultLocaleError, noApiKeyError, noProjectIdError, devApiKeyError, invalidConfigurationError, } from '../../console/index.js';
+import { aggregateFiles } from '../../formats/files/translate.js';
+import { aggregateReactTranslations } from '../../translation/stage.js';
+import { sendFiles } from '../../api/sendFiles.js';
+import { updateVersions } from '../../fs/config/updateVersions.js';
+import updateConfig from '../../fs/config/updateConfig.js';
+import { hashStringSync } from '../../utils/hash.js';
+export const TEMPLATE_FILE_NAME = '__INTERNAL_GT_TEMPLATE_NAME__';
+export const TEMPLATE_FILE_ID = hashStringSync(TEMPLATE_FILE_NAME);
+export async function handleStage(options, settings, library, stage) {
+    // Validate required settings are present if not in dry run
+    if (!options.dryRun) {
+        if (!settings.locales) {
+            logErrorAndExit(noLocalesError);
+        }
+        if (!settings.defaultLocale) {
+            logErrorAndExit(noDefaultLocaleError);
+        }
+        if (!settings.apiKey) {
+            logErrorAndExit(noApiKeyError);
+        }
+        if (settings.apiKey.startsWith('gtx-dev-')) {
+            logErrorAndExit(devApiKeyError);
+        }
+        if (!settings.projectId) {
+            logErrorAndExit(noProjectIdError);
+        }
+    }
+    // Aggregate files
+    const allFiles = await aggregateFiles(settings);
+    // Parse for React components
+    let reactComponents = 0;
+    if (library === 'gt-react' || library === 'gt-next') {
+        const updates = await aggregateReactTranslations(options, settings, library);
+        if (updates.length > 0) {
+            if (!options.dryRun &&
+                !settings.publish &&
+                !settings.files?.placeholderPaths.gt) {
+                logErrorAndExit(invalidConfigurationError);
+            }
+            reactComponents = updates.length;
+            // Convert updates to a file object
+            const fileData = {};
+            const fileMetadata = {};
+            // Convert updates to the proper data format
+            for (const update of updates) {
+                const { source, metadata, dataFormat } = update;
+                metadata.dataFormat = dataFormat; // add the data format to the metadata
+                const { hash, id } = metadata;
+                if (id) {
+                    fileData[id] = source;
+                    fileMetadata[id] = metadata;
+                }
+                else {
+                    fileData[hash] = source;
+                    fileMetadata[hash] = metadata;
+                }
+            }
+            allFiles.push({
+                fileName: TEMPLATE_FILE_NAME,
+                content: JSON.stringify(fileData),
+                fileFormat: 'GTJSON',
+                formatMetadata: fileMetadata,
+            });
+        }
+    }
+    // Dry run
+    if (options.dryRun) {
+        const fileNames = allFiles
+            .map((file) => {
+            if (file.fileName === TEMPLATE_FILE_NAME) {
+                return `- <React Elements> (${reactComponents})`;
+            }
+            return `- ${file.fileName}`;
+        })
+            .join('\n');
+        logSuccess(`Dry run: No files were sent to General Translation. Found files:\n${fileNames}`);
+        return undefined;
+    }
+    // Send translations to General Translation
+    let filesTranslationResponse;
+    if (allFiles.length > 0) {
+        filesTranslationResponse = await sendFiles(allFiles, options, settings);
+        if (stage) {
+            await updateVersions({
+                configDirectory: settings.configDirectory,
+                versionData: filesTranslationResponse.data,
+            });
+        }
+        const templateData = filesTranslationResponse.data[TEMPLATE_FILE_ID];
+        if (templateData?.versionId) {
+            await updateConfig({
+                configFilepath: settings.config,
+                _versionId: templateData.versionId,
+            });
+        }
+    }
+    return filesTranslationResponse;
+}

package/dist/cli/commands/translate.d.ts

@@ -0,0 +1,6 @@
+import { SendFilesResult } from '../../api/sendFiles.js';
+import { TranslateFlags } from '../../types/index.js';
+import { Settings } from '../../types/index.js';
+export declare function handleTranslate(options: TranslateFlags, settings: Settings, filesTranslationResponse: SendFilesResult | undefined): Promise<void>;
+export declare function handleDownload(options: TranslateFlags, settings: Settings): Promise<void>;
+export declare function postProcessTranslations(settings: Settings): Promise<void>;

package/dist/cli/commands/translate.js

@@ -0,0 +1,58 @@
+import { checkFileTranslations } from '../../api/checkFileTranslations.js';
+import { createFileMapping } from '../../formats/files/fileMapping.js';
+import { logError } from '../../console/logging.js';
+import { getStagedVersions } from '../../fs/config/updateVersions.js';
+import copyFile from '../../fs/copyFile.js';
+import localizeStaticImports from '../../utils/localizeStaticImports.js';
+import flattenJsonFiles from '../../utils/flattenJsonFiles.js';
+import localizeStaticUrls from '../../utils/localizeStaticUrls.js';
+import { noFilesError, noVersionIdError } from '../../console/index.js';
+// Downloads translations that were completed
+export async function handleTranslate(options, settings, filesTranslationResponse) {
+    if (filesTranslationResponse && settings.files) {
+        const { resolvedPaths, placeholderPaths, transformPaths } = settings.files;
+        const fileMapping = createFileMapping(resolvedPaths, placeholderPaths, transformPaths, settings.locales, settings.defaultLocale);
+        const { data } = filesTranslationResponse;
+        // Check for remaining translations
+        await checkFileTranslations(data, settings.locales, options.timeout, (sourcePath, locale) => fileMapping[locale][sourcePath] ?? null, settings);
+    }
+}
+// Downloads translations that were originally staged
+export async function handleDownload(options, settings) {
+    if (!settings._versionId) {
+        logError(noVersionIdError);
+        process.exit(1);
+    }
+    if (!settings.files) {
+        logError(noFilesError);
+        process.exit(1);
+    }
+    // Files
+    const { resolvedPaths, placeholderPaths, transformPaths } = settings.files;
+    const fileMapping = createFileMapping(resolvedPaths, placeholderPaths, transformPaths, settings.locales, settings.defaultLocale);
+    const stagedVersionData = await getStagedVersions(settings.configDirectory);
+    // Check for remaining translations
+    await checkFileTranslations(stagedVersionData, settings.locales, options.timeout, (sourcePath, locale) => fileMapping[locale][sourcePath] ?? null, settings);
+}
+export async function postProcessTranslations(settings) {
+    // Localize static urls (/docs -> /[locale]/docs) for non-default locales only
+    // Default locale is processed earlier in the flow in base.ts
+    if (settings.options?.experimentalLocalizeStaticUrls) {
+        const nonDefaultLocales = settings.locales.filter(locale => locale !== settings.defaultLocale);
+        if (nonDefaultLocales.length > 0) {
+            await localizeStaticUrls(settings, nonDefaultLocales);
+        }
+    }
+    // Localize static imports (/docs -> /[locale]/docs)
+    if (settings.options?.experimentalLocalizeStaticImports) {
+        await localizeStaticImports(settings);
+    }
+    // Flatten json files into a single file
+    if (settings.options?.experimentalFlattenJsonFiles) {
+        await flattenJsonFiles(settings);
+    }
+    // Copy files to the target locale
+    if (settings.options?.copyFiles) {
+        await copyFile(settings);
+    }
+}

package/dist/cli/flags.d.ts

@@ -0,0 +1,3 @@
+import { Command } from 'commander';
+export declare function attachTranslateFlags(command: Command): Command;
+export declare function attachAdditionalReactTranslateFlags(command: Command): Command;