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

package/dist/api/checkFileTranslations.d.ts

@@ -20,4 +20,7 @@ export declare function checkFileTranslations(data: {
         versionId: string;
         fileName: string;
     };
-}, locales: string[], timeoutDuration: number, resolveOutputPath: (sourcePath: string, locale: string) => string | null, options: Settings): Promise<boolean>;
+}, locales: string[], timeoutDuration: number, resolveOutputPath: (sourcePath: string, locale: string) => string, downloadStatus: {
+    downloaded: Set<string>;
+    failed: Set<string>;
+}, 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,18 +14,13 @@ import { TEMPLATE_FILE_NAME } from '../cli/commands/stage.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, options) {
+export async function checkFileTranslations(data, locales, timeoutDuration, resolveOutputPath, downloadStatus, 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) {
@@ -151,8 +146,7 @@ function generateStatusSuffixText(downloadStatus, fileQueryData) {
             localeStatuses.push(chalk.yellow(`${pendingCodes}`));
         }
         // Format the line
-        const prettyFileName = fileName === TEMPLATE_FILE_NAME ? '<React Elements>' : fileName;
-        newSuffixText.push(`${chalk.bold(prettyFileName)} [${localeStatuses.join(', ')}]`);
+        newSuffixText.push(`${chalk.bold(fileName)} [${localeStatuses.join(', ')}]`);
     }
     // If we couldn't show all files, add an indicator
     if (filesArray.length > maxFilesToShow) {
@@ -167,8 +161,7 @@ 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.skipped.has(`${item.fileName}:${item.locale}`));
+            !downloadStatus.failed.has(`${item.fileName}:${item.locale}`));
         // If all files have been downloaded, we're done
         if (currentQueryData.length === 0) {
             return true;
@@ -180,17 +173,11 @@ 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,
@@ -198,28 +185,44 @@ async function checkTranslationDeployment(fileQueryData, downloadStatus, spinner
                     locale,
                     fileLocale: `${fileName}:${locale}`,
                 };
-            })
-                .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);
+            });
+            // 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);
                 }
-                else if (batchResult.failed.includes(translationId)) {
-                    downloadStatus.failed.add(fileLocale);
+                else {
+                    downloadStatus.failed.add(file.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 +
-            downloadStatus.skipped.size ===
+        if (downloadStatus.downloaded.size + downloadStatus.failed.size ===
             fileQueryData.length) {
             return true;
         }

package/dist/api/downloadFile.d.ts

@@ -0,0 +1,9 @@
+import { Settings } from '../types/index.js';
+/**
+ * Downloads a file from the API and saves it to a local directory
+ * @param translationId - The ID of the translation to download
+ * @param outputPath - The path to save the file to
+ * @param maxRetries - The maximum number of retries to attempt
+ * @param retryDelay - The delay between retries in milliseconds
+ */
+export declare function downloadFile(translationId: string, outputPath: string, inputPath: string, locale: string, options: Settings, maxRetries?: number, retryDelay?: number): Promise<boolean>;

package/dist/api/downloadFile.js

@@ -0,0 +1,74 @@
+import * as fs from 'fs';
+import * as path from 'path';
+import { logError } from '../console/logging.js';
+import { gt } from '../utils/gt.js';
+import { validateJsonSchema } from '../formats/json/utils.js';
+import { mergeJson } from '../formats/json/mergeJson.js';
+import { TextDecoder } from 'node:util';
+import mergeYaml from '../formats/yaml/mergeYaml.js';
+import { validateYamlSchema } from '../formats/yaml/utils.js';
+/**
+ * Downloads a file from the API and saves it to a local directory
+ * @param translationId - The ID of the translation to download
+ * @param outputPath - The path to save the file to
+ * @param maxRetries - The maximum number of retries to attempt
+ * @param retryDelay - The delay between retries in milliseconds
+ */
+export async function downloadFile(translationId, outputPath, inputPath, locale, options, maxRetries = 3, retryDelay = 1000) {
+    let retries = 0;
+    while (retries <= maxRetries) {
+        try {
+            // Get the file data as an ArrayBuffer
+            const fileData = await gt.downloadFile(translationId);
+            // Ensure the directory exists
+            const dir = path.dirname(outputPath);
+            if (!fs.existsSync(dir)) {
+                fs.mkdirSync(dir, { recursive: true });
+            }
+            let data = new TextDecoder().decode(fileData);
+            if (options.options?.jsonSchema && locale) {
+                const jsonSchema = validateJsonSchema(options.options, inputPath);
+                if (jsonSchema) {
+                    const originalContent = fs.readFileSync(inputPath, 'utf8');
+                    if (originalContent) {
+                        data = mergeJson(originalContent, inputPath, options.options, [
+                            {
+                                translatedContent: data,
+                                targetLocale: locale,
+                            },
+                        ], options.defaultLocale)[0];
+                    }
+                }
+            }
+            if (options.options?.yamlSchema && locale) {
+                const yamlSchema = validateYamlSchema(options.options, inputPath);
+                if (yamlSchema) {
+                    const originalContent = fs.readFileSync(inputPath, 'utf8');
+                    if (originalContent) {
+                        data = mergeYaml(originalContent, inputPath, options.options, [
+                            {
+                                translatedContent: data,
+                                targetLocale: locale,
+                            },
+                        ])[0];
+                    }
+                }
+            }
+            // Write the file to disk
+            await fs.promises.writeFile(outputPath, data);
+            return true;
+        }
+        catch (error) {
+            // If we've retried too many times, log an error and return false
+            if (retries >= maxRetries) {
+                logError(`Error downloading file ${outputPath} after ${maxRetries + 1} attempts: ` +
+                    error);
+                return false;
+            }
+            // Increment retry counter and wait before next attempt
+            retries++;
+            await new Promise((resolve) => setTimeout(resolve, retryDelay));
+        }
+    }
+    return false;
+}

package/dist/api/downloadFileBatch.d.ts

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

package/dist/api/fetchTranslations.d.ts

@@ -0,0 +1,7 @@
+import { RetrievedTranslations } from 'generaltranslation/types';
+/**
+ * Fetches translations from the API and saves them to a local directory
+ * @param translationsDir - The directory to save the translations to
+ * @param fileType - The file type to save the translations as (file extension)
+ */
+export declare function fetchTranslations(versionId: string): Promise<RetrievedTranslations>;

package/dist/api/fetchTranslations.js

@@ -0,0 +1,18 @@
+import chalk from 'chalk';
+import { logError } from '../console/logging.js';
+import { gt } from '../utils/gt.js';
+/**
+ * Fetches translations from the API and saves them to a local directory
+ * @param translationsDir - The directory to save the translations to
+ * @param fileType - The file type to save the translations as (file extension)
+ */
+export async function fetchTranslations(versionId) {
+    try {
+        const result = await gt.fetchTranslations(versionId);
+        return result.translations;
+    }
+    catch {
+        logError(chalk.red('Failed to fetch translations'));
+        return [];
+    }
+}

package/dist/api/sendFiles.d.ts

@@ -1,5 +1,9 @@
-import { Settings, TranslateFlags } from '../types/index.js';
+import { Settings } 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;
@@ -14,4 +18,11 @@ 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: TranslateFlags, settings: Settings): Promise<SendFilesResult>;
+export declare function sendFiles(files: FileToTranslate[], options: ApiOptions): Promise<{
+    data: Record<string, {
+        fileName: string;
+        versionId: string;
+    }>;
+    locales: string[];
+    translations: CompletedFileTranslationData[];
+}>;

package/dist/api/sendFiles.js

@@ -1,34 +1,27 @@
 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, settings) {
+export async function sendFiles(files, options) {
     logMessage(chalk.cyan('Files to translate:') +
         '\n' +
-        files
-            .map((file) => {
-            if (file.fileName === TEMPLATE_FILE_NAME) {
-                return `- <React Elements>`;
-            }
-            return `- ${file.fileName}`;
-        })
-            .join('\n'));
+        files.map((file) => `  - ${chalk.bold(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: settings.publish,
-            sourceLocale: settings.defaultLocale,
-            targetLocales: settings.locales,
-            version: settings.version, // not set ATM
-            modelProvider: settings.modelProvider,
+            publish: options.publish,
+            description: options.description,
+            sourceLocale: options.defaultLocale,
+            targetLocales: options.locales,
+            _versionId: options._versionId,
+            modelProvider: options.modelProvider,
         });
         // Handle version ID response (for async processing)
         const { data, message, locales, translations } = responseData;

package/dist/api/sendUpdates.d.ts

@@ -0,0 +1,19 @@
+import { Settings, SupportedLibraries, Updates } from '../types/index.js';
+import { DataFormat } from '../types/data.js';
+export type ApiOptions = Settings & {
+    timeout: string;
+    dataFormat: DataFormat;
+    description?: string;
+    requireApproval?: boolean;
+};
+export type SendUpdatesResult = {
+    versionId: string;
+    locales: string[];
+};
+/**
+ * Sends updates to the API
+ * @param updates - The updates to send
+ * @param options - The options for the API call
+ * @returns The versionId of the updated project
+ */
+export declare function sendUpdates(updates: Updates, options: ApiOptions, library: SupportedLibraries): Promise<SendUpdatesResult>;

package/dist/api/sendUpdates.js

@@ -0,0 +1,48 @@
+import chalk from 'chalk';
+import { createSpinner, logSuccess, logWarning, } from '../console/logging.js';
+import updateConfig from '../fs/config/updateConfig.js';
+import { isUsingLocalTranslations } from '../config/utils.js';
+import { gt } from '../utils/gt.js';
+/**
+ * Sends updates to the API
+ * @param updates - The updates to send
+ * @param options - The options for the API call
+ * @returns The versionId of the updated project
+ */
+export async function sendUpdates(updates, options, library) {
+    const spinner = createSpinner('dots');
+    spinner.start(`Sending ${library} updates to General Translation API...`);
+    try {
+        const responseData = await gt.enqueueEntries(updates, {
+            sourceLocale: options.defaultLocale,
+            targetLocales: options.locales,
+            dataFormat: options.dataFormat,
+            version: options.version,
+            description: options.description,
+            requireApproval: options.requireApproval,
+            modelProvider: options.modelProvider,
+        });
+        const { versionId, message, locales, projectSettings } = responseData;
+        spinner.stop(chalk.green('Sent updates'));
+        logSuccess(message);
+        if (isUsingLocalTranslations(options) && projectSettings.cdnEnabled) {
+            logWarning(chalk.yellow('Your project is configured to use the CDN, but you are also using local translations. Please disable one or the other.'));
+        }
+        else if (!isUsingLocalTranslations(options) &&
+            !projectSettings.cdnEnabled) {
+            logWarning(chalk.yellow('Your project is not using the CDN, nor are you using local translations. Please enable one or the other.'));
+        }
+        if (options.config) {
+            await updateConfig({
+                configFilepath: options.config,
+                _versionId: versionId,
+                locales,
+            });
+        }
+        return { versionId, locales };
+    }
+    catch (error) {
+        spinner.stop(chalk.red('Failed to send updates'));
+        throw error;
+    }
+}

package/dist/api/waitForUpdates.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Waits for translations to be deployed to the General Translation API
+ * @param versionId - The version ID of the project
+ * @param locales - The locales to wait for
+ * @param startTime - The start time of the wait
+ * @param timeoutDuration - The timeout duration for the wait
+ * @returns True if all translations are deployed, false otherwise
+ */
+export declare const waitForUpdates: (versionId: string, startTime: number, timeoutDuration: number) => Promise<boolean>;

package/dist/api/waitForUpdates.js

@@ -0,0 +1,89 @@
+import chalk from 'chalk';
+import { createOraSpinner, logErrorAndExit, } from '../console/logging.js';
+import { getLocaleProperties } from 'generaltranslation';
+import { gt } from '../utils/gt.js';
+/**
+ * Waits for translations to be deployed to the General Translation API
+ * @param versionId - The version ID of the project
+ * @param locales - The locales to wait for
+ * @param startTime - The start time of the wait
+ * @param timeoutDuration - The timeout duration for the wait
+ * @returns True if all translations are deployed, false otherwise
+ */
+export const waitForUpdates = async (versionId, startTime, timeoutDuration) => {
+    console.log();
+    const spinner = await createOraSpinner();
+    spinner.start('Waiting for translation...');
+    const checkDeployment = async () => {
+        let data;
+        try {
+            // get translation status
+            data = await gt.checkTranslationStatus(versionId);
+        }
+        catch {
+            return false;
+        }
+        // check if any locales are waiting for approval
+        const { availableLocales, locales, localesWaitingForApproval } = data;
+        if (localesWaitingForApproval.length > 0) {
+            spinner.stop();
+            logErrorAndExit(`Error! ${localesWaitingForApproval.length} translations are waiting for approval:\n${localesWaitingForApproval
+                .map((locale) => {
+                const localeProperties = getLocaleProperties(locale);
+                return `${localeProperties.name} (${localeProperties.code})`;
+            })
+                .join('\n')}\nPlease approve these locales in the General Translation dashboard, then re-run the command.`);
+        }
+        // check if all locales are available
+        if (availableLocales) {
+            availableLocales.forEach((locale) => {
+                if (!availableLocales.includes(locale)) {
+                    availableLocales.push(locale);
+                }
+            });
+            const newSuffixText = [
+                chalk.green(`[${availableLocales.length}/${locales.length}]`) +
+                    ` translations completed`,
+                ...availableLocales.map((locale) => {
+                    const localeProperties = getLocaleProperties(locale);
+                    return `Translation completed for ${chalk.green(localeProperties.name)} (${chalk.green(localeProperties.code)})`;
+                }),
+            ];
+            spinner.text = newSuffixText.join('\n');
+        }
+        // check if all locales are available
+        if (locales.every((locale) => availableLocales.includes(locale))) {
+            return true;
+        }
+        return false;
+    };
+    // Calculate time until next 5-second interval since startTime
+    const msUntilNextInterval = Math.max(0, 5000 - ((Date.now() - startTime) % 5000));
+    // Do first check immediately
+    const initialCheck = await checkDeployment();
+    if (initialCheck) {
+        spinner.succeed(chalk.green('All translations are live!'));
+        return true;
+    }
+    return new Promise((resolve) => {
+        let intervalCheck;
+        // Start the interval aligned with the original request time
+        setTimeout(() => {
+            intervalCheck = setInterval(async () => {
+                const isDeployed = await checkDeployment();
+                const elapsed = Date.now() - startTime;
+                if (isDeployed || elapsed >= timeoutDuration) {
+                    clearInterval(intervalCheck);
+                    if (isDeployed) {
+                        spinner.succeed(chalk.green('All translations are live!'));
+                        resolve(true);
+                    }
+                    else {
+                        spinner.fail(chalk.red('Timed out waiting for translations'));
+                        resolve(false);
+                    }
+                }
+            }, 5000);
+        }, msUntilNextInterval);
+    });
+};

package/dist/cli/base.d.ts

@@ -1,11 +1,25 @@
 import { Command } from 'commander';
-import { Settings, SupportedLibraries, SetupOptions, TranslateFlags } from '../types/index.js';
+import { Settings, SupportedLibraries, SetupOptions } 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';
 };
@@ -16,16 +30,14 @@ export declare class BaseCLI {
     constructor(program: Command, library: SupportedLibraries, additionalModules?: SupportedLibraries[]);
     init(): void;
     execute(): void;
-    protected setupStageCommand(): void;
-    protected setupTranslateCommand(): void;
-    protected handleStage(initOptions: TranslateFlags): Promise<void>;
-    protected handleTranslate(initOptions: TranslateFlags): Promise<void>;
+    protected setupGTCommand(): 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>;