gtx-cli 2.1.3 → 2.1.5-alpha.1

package/dist/api/sendUpdates.d.ts

@@ -1,19 +0,0 @@
-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

@@ -1,48 +0,0 @@
-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

@@ -1,9 +0,0 @@
-/**
- * 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

@@ -1,89 +0,0 @@
-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/translation/translate.d.ts

@@ -1,2 +0,0 @@
-import { Options, Settings } from '../types/index.js';
-export declare function translate(settings: Options & Settings, versionId: string): Promise<void>;

package/dist/translation/translate.js

@@ -1,18 +0,0 @@
-import { fetchTranslations } from '../api/fetchTranslations.js';
-import { waitForUpdates } from '../api/waitForUpdates.js';
-import { saveTranslations } from '../formats/gt/save.js';
-import { isUsingLocalTranslations } from '../config/utils.js';
-export async function translate(settings, versionId) {
-    // timeout was validated earlier
-    const startTime = Date.now();
-    const timeout = parseInt(settings.timeout) * 1000;
-    const result = await waitForUpdates(versionId, startTime, timeout);
-    if (!result) {
-        process.exit(1);
-    }
-    const translations = await fetchTranslations(versionId);
-    // Save translations to local directory if files.gt.output is provided
-    if (settings.files && isUsingLocalTranslations(settings)) {
-        await saveTranslations(translations, settings.files.placeholderPaths, 'JSX');
-    }
-}