gtx-cli 2.1.5 → 2.1.7

package/dist/utils/localizeStaticUrls.js

@@ -21,19 +21,24 @@ const { isMatch } = micromatch;
  * - Support more file types
  * - Support more complex paths
  */
-export default async function localizeStaticUrls(settings) {
+export default async function localizeStaticUrls(settings, targetLocales) {
     if (!settings.files ||
         (Object.keys(settings.files.placeholderPaths).length === 1 &&
             settings.files.placeholderPaths.gt)) {
         return;
     }
     const { resolvedPaths: sourceFiles } = settings.files;
-    const fileMapping = createFileMapping(sourceFiles, settings.files.placeholderPaths, settings.files.transformPaths, settings.locales, settings.defaultLocale);
+    // Use filtered locales if provided, otherwise use all locales
+    const locales = targetLocales || settings.locales;
+    const fileMapping = createFileMapping(sourceFiles, settings.files.placeholderPaths, settings.files.transformPaths, settings.locales, // Always use all locales for mapping, filter later
+    settings.defaultLocale);
     // Process all file types at once with a single call
     const processPromises = [];
     // First, process default locale files (from source files)
     // This is needed because they might not be in the fileMapping if they're not being translated
-    if (!fileMapping[settings.defaultLocale]) {
+    // Only process default locale if it's in the target locales filter
+    if (!fileMapping[settings.defaultLocale] &&
+        locales.includes(settings.defaultLocale)) {
         const defaultLocaleFiles = [];
         // Collect all .md and .mdx files from sourceFiles
         if (sourceFiles.md) {
@@ -47,16 +52,20 @@ export default async function localizeStaticUrls(settings) {
                 // Get file content
                 const fileContent = await fs.promises.readFile(filePath, 'utf8');
                 // Localize the file using default locale
-                const localizedFile = localizeStaticUrlsForFile(fileContent, settings.defaultLocale, settings.defaultLocale, // Process as default locale
-                settings.experimentalHideDefaultLocale || false, settings.options?.docsUrlPattern, settings.options?.excludeStaticUrls);
-                // Write the localized file back to the same path
-                await fs.promises.writeFile(filePath, localizedFile);
+                const result = localizeStaticUrlsForFile(fileContent, settings.defaultLocale, settings.defaultLocale, // Process as default locale
+                settings.options?.experimentalHideDefaultLocale || false, settings.options?.docsUrlPattern, settings.options?.excludeStaticUrls, settings.options?.baseDomain);
+                // Only write the file if there were changes
+                if (result.hasChanges) {
+                    await fs.promises.writeFile(filePath, result.content);
+                }
             }));
             processPromises.push(defaultPromise);
         }
     }
     // Then process all other locales from fileMapping
-    const mappingPromises = Object.entries(fileMapping).map(async ([locale, filesMap]) => {
+    const mappingPromises = Object.entries(fileMapping)
+        .filter(([locale, filesMap]) => locales.includes(locale)) // Filter by target locales
+        .map(async ([locale, filesMap]) => {
         // Get all files that are md or mdx
         const targetFiles = Object.values(filesMap).filter((path) => path.endsWith('.md') || path.endsWith('.mdx'));
         // Replace the placeholder path with the target path
@@ -64,9 +73,11 @@ export default async function localizeStaticUrls(settings) {
             // Get file content
             const fileContent = await fs.promises.readFile(filePath, 'utf8');
             // Localize the file (handles both URLs and hrefs in single AST pass)
-            const localizedFile = localizeStaticUrlsForFile(fileContent, settings.defaultLocale, locale, settings.experimentalHideDefaultLocale || false, settings.options?.docsUrlPattern, settings.options?.excludeStaticUrls);
-            // Write the localized file to the target path
-            await fs.promises.writeFile(filePath, localizedFile);
+            const result = localizeStaticUrlsForFile(fileContent, settings.defaultLocale, locale, settings.options?.experimentalHideDefaultLocale || false, settings.options?.docsUrlPattern, settings.options?.excludeStaticUrls, settings.options?.baseDomain);
+            // Only write the file if there were changes
+            if (result.hasChanges) {
+                await fs.promises.writeFile(filePath, result.content);
+            }
         }));
     });
     processPromises.push(...mappingPromises);
@@ -75,21 +86,28 @@ export default async function localizeStaticUrls(settings) {
 /**
  * Determines if a URL should be processed based on pattern matching
  */
-function shouldProcessUrl(originalUrl, patternHead, targetLocale, defaultLocale) {
-    // Skip absolute URLs (http://, https://, //, etc.)
-    if (originalUrl.includes(':')) {
-        return false;
-    }
+function shouldProcessUrl(originalUrl, patternHead, targetLocale, defaultLocale, baseDomain) {
     const patternWithoutSlash = patternHead.replace(/\/$/, '');
+    // Handle absolute URLs with baseDomain
+    let urlToCheck = originalUrl;
+    if (baseDomain && originalUrl.startsWith(baseDomain)) {
+        urlToCheck = originalUrl.substring(baseDomain.length);
+    }
     if (targetLocale === defaultLocale) {
         // For default locale processing, check if URL contains the pattern
-        return originalUrl.includes(patternWithoutSlash);
+        return urlToCheck.includes(patternWithoutSlash);
     }
     else {
         // For non-default locales, check if URL starts with pattern
-        return originalUrl.startsWith(patternWithoutSlash);
+        return urlToCheck.startsWith(patternWithoutSlash);
     }
 }
+/**
+ * Determines if a URL should be processed based on the base domain
+ */
+function shouldProcessAbsoluteUrl(originalUrl, baseDomain) {
+    return originalUrl.startsWith(baseDomain);
+}
 /**
  * Checks if a URL should be excluded based on exclusion patterns
  */
@@ -98,102 +116,79 @@ function isUrlExcluded(originalUrl, exclude, defaultLocale) {
     return excludePatterns.some((pattern) => isMatch(originalUrl, pattern));
 }
 /**
- * Transforms URL for default locale processing
- */
-function transformDefaultLocaleUrl(originalUrl, patternHead, defaultLocale, hideDefaultLocale) {
-    if (hideDefaultLocale) {
-        // Remove locale from URLs that have it: '/docs/en/file' -> '/docs/file'
-        if (originalUrl.includes(`/${defaultLocale}/`)) {
-            return originalUrl.replace(`/${defaultLocale}/`, '/');
-        }
-        else if (originalUrl.endsWith(`/${defaultLocale}`)) {
-            return originalUrl.replace(`/${defaultLocale}`, '');
-        }
-        return null; // URL doesn't have default locale
-    }
-    else {
-        // Add locale to URLs that don't have it: '/docs/file' -> '/docs/en/file'
-        if (originalUrl.includes(`/${defaultLocale}/`) ||
-            originalUrl.endsWith(`/${defaultLocale}`)) {
-            return null; // Already has default locale
-        }
-        if (originalUrl.startsWith(patternHead)) {
-            const pathAfterHead = originalUrl.slice(patternHead.length);
-            if (pathAfterHead) {
-                return `${patternHead}${defaultLocale}/${pathAfterHead}`;
-            }
-            else {
-                return `${patternHead.replace(/\/$/, '')}/${defaultLocale}`;
-            }
-        }
-        return null; // URL doesn't match pattern
-    }
-}
-/**
- * Transforms URL for non-default locale processing with hideDefaultLocale=true
+ * Main URL transformation function that delegates to specific scenarios
  */
-function transformNonDefaultLocaleUrlWithHidden(originalUrl, patternHead, targetLocale, defaultLocale) {
-    // Check if already localized
-    if (originalUrl.startsWith(`${patternHead}${targetLocale}/`) ||
-        originalUrl === `${patternHead}${targetLocale}`) {
+export function transformUrlPath(originalUrl, patternHead, targetLocale, defaultLocale, hideDefaultLocale) {
+    const originalPathArray = originalUrl
+        .split('/')
+        .filter((path) => path !== '');
+    const patternHeadArray = patternHead.split('/').filter((path) => path !== '');
+    // check if the pattern head matches the original path
+    if (!checkIfPathMatchesPattern(originalPathArray, patternHeadArray)) {
         return null;
     }
-    // Replace default locale with target locale
-    const expectedPathWithDefaultLocale = `${patternHead}${defaultLocale}`;
-    if (originalUrl.startsWith(`${expectedPathWithDefaultLocale}/`) ||
-        originalUrl === expectedPathWithDefaultLocale) {
-        return originalUrl.replace(`${patternHead}${defaultLocale}`, `${patternHead}${targetLocale}`);
-    }
-    // Handle exact pattern match
-    if (originalUrl === patternHead.replace(/\/$/, '')) {
-        return `${patternHead.replace(/\/$/, '')}/${targetLocale}`;
+    if (patternHeadArray.length > originalPathArray.length) {
+        return null; // Pattern is longer than the URL path
     }
-    // Add target locale to URL without any locale
-    const pathAfterHead = originalUrl.slice(originalUrl.startsWith(patternHead) ? patternHead.length : 0);
-    return pathAfterHead
-        ? `${patternHead}${targetLocale}/${pathAfterHead}`
-        : `${patternHead}${targetLocale}`;
-}
-/**
- * Transforms URL for non-default locale processing with hideDefaultLocale=false
- */
-function transformNonDefaultLocaleUrl(originalUrl, patternHead, targetLocale, defaultLocale) {
-    const expectedPathWithLocale = `${patternHead}${defaultLocale}`;
-    if (originalUrl.startsWith(`${expectedPathWithLocale}/`) ||
-        originalUrl === expectedPathWithLocale) {
-        // Replace existing default locale with target locale
-        return originalUrl.replace(`${patternHead}${defaultLocale}`, `${patternHead}${targetLocale}`);
-    }
-    else if (originalUrl.startsWith(patternHead)) {
-        // Add target locale to URL that doesn't have any locale
-        const pathAfterHead = originalUrl.slice(patternHead.length);
-        if (pathAfterHead) {
-            return `${patternHead}${targetLocale}/${pathAfterHead}`;
+    let result = null;
+    if (targetLocale === defaultLocale) {
+        if (hideDefaultLocale) {
+            // check if default locale is already present
+            if (originalPathArray?.[patternHeadArray.length] !== defaultLocale) {
+                return null;
+            }
+            // remove default locale
+            const newPathArray = [
+                ...originalPathArray.slice(0, patternHeadArray.length),
+                ...originalPathArray.slice(patternHeadArray.length + 1),
+            ];
+            result = newPathArray.join('/');
         }
         else {
-            return `${patternHead.replace(/\/$/, '')}/${targetLocale}`;
+            // check if default locale is already present
+            if (originalPathArray?.[patternHeadArray.length] === defaultLocale) {
+                return null;
+            }
+            // insert default locale
+            const newPathArray = [
+                ...originalPathArray.slice(0, patternHeadArray.length),
+                defaultLocale,
+                ...originalPathArray.slice(patternHeadArray.length),
+            ];
+            result = newPathArray.join('/');
         }
     }
-    return null; // URL doesn't match pattern
-}
-/**
- * Main URL transformation function that delegates to specific scenarios
- */
-function transformUrlPath(originalUrl, patternHead, targetLocale, defaultLocale, hideDefaultLocale) {
-    if (targetLocale === defaultLocale) {
-        return transformDefaultLocaleUrl(originalUrl, patternHead, defaultLocale, hideDefaultLocale);
-    }
     else if (hideDefaultLocale) {
-        return transformNonDefaultLocaleUrlWithHidden(originalUrl, patternHead, targetLocale, defaultLocale);
+        const newPathArray = [
+            ...originalPathArray.slice(0, patternHeadArray.length),
+            targetLocale,
+            ...originalPathArray.slice(patternHeadArray.length),
+        ];
+        result = newPathArray.join('/');
     }
     else {
-        return transformNonDefaultLocaleUrl(originalUrl, patternHead, targetLocale, defaultLocale);
+        // check default locale
+        if (originalPathArray?.[patternHeadArray.length] !== defaultLocale) {
+            return null;
+        }
+        // replace default locale with target locale
+        const newPathArray = [...originalPathArray];
+        newPathArray[patternHeadArray.length] = targetLocale;
+        result = newPathArray.join('/');
     }
+    // check for leading and trailing slashes
+    if (originalUrl.startsWith('/')) {
+        result = '/' + result;
+    }
+    if (originalUrl.endsWith('/')) {
+        result = result + '/';
+    }
+    return result;
 }
 /**
  * AST-based transformation for MDX files using remark-mdx
  */
-function transformMdxUrls(mdxContent, defaultLocale, targetLocale, hideDefaultLocale, pattern = '/[locale]', exclude = []) {
+function transformMdxUrls(mdxContent, defaultLocale, targetLocale, hideDefaultLocale, pattern = '/[locale]', exclude = [], baseDomain) {
     const transformedUrls = [];
     if (!pattern.startsWith('/')) {
         pattern = '/' + pattern;
@@ -240,13 +235,32 @@ function transformMdxUrls(mdxContent, defaultLocale, targetLocale, hideDefaultLo
         return {
             content: mdxContent,
             hasChanges: false,
-            transformedUrls: [],
+            transformedUrls,
         };
     }
     // Helper function to transform URL based on pattern
     const transformUrl = (originalUrl, linkType) => {
         // Check if URL should be processed
-        if (!shouldProcessUrl(originalUrl, patternHead, targetLocale, defaultLocale)) {
+        if (!shouldProcessUrl(originalUrl, patternHead, targetLocale, defaultLocale, baseDomain)) {
+            return null;
+        }
+        // Skip absolute URLs (http://, https://, //, etc.)
+        if (baseDomain && shouldProcessAbsoluteUrl(originalUrl, baseDomain)) {
+            // Get everything after the base domain
+            const afterDomain = originalUrl.substring(baseDomain.length);
+            const transformedPath = transformUrlPath(afterDomain, patternHead, targetLocale, defaultLocale, hideDefaultLocale);
+            if (!transformedPath) {
+                return null;
+            }
+            transformedUrls.push({
+                originalPath: originalUrl,
+                newPath: transformedPath,
+                type: linkType,
+            });
+            return transformedPath ? baseDomain + transformedPath : null;
+        }
+        // Exclude colon-prefixed URLs (http://, https://, //, etc.)
+        if (originalUrl.split('?')[0].includes(':')) {
             return null;
         }
         // Transform the URL based on locale and configuration
@@ -381,8 +395,23 @@ function transformMdxUrls(mdxContent, defaultLocale, targetLocale, hideDefaultLo
 }
 // AST-based transformation for MDX files using remark
 function localizeStaticUrlsForFile(file, defaultLocale, targetLocale, hideDefaultLocale, pattern = '/[locale]', // eg /docs/[locale] or /[locale]
-exclude = []) {
+exclude = [], baseDomain) {
     // Use AST-based transformation for MDX files
-    const result = transformMdxUrls(file, defaultLocale, targetLocale, hideDefaultLocale, pattern, exclude);
-    return result.content;
+    return transformMdxUrls(file, defaultLocale, targetLocale, hideDefaultLocale, pattern, exclude, baseDomain || '');
+}
+function cleanPath(path) {
+    let cleanedPath = path.startsWith('/') ? path.slice(1) : path;
+    cleanedPath = cleanedPath.endsWith('/')
+        ? cleanedPath.slice(0, -1)
+        : cleanedPath;
+    return cleanedPath;
+}
+function checkIfPathMatchesPattern(originalUrlArray, patternHeadArray) {
+    // check if the pattern head matches the original path
+    for (let i = 0; i < patternHeadArray.length; i++) {
+        if (patternHeadArray[i] !== originalUrlArray?.[i]) {
+            return false;
+        }
+    }
+    return true;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gtx-cli",
-  "version": "2.1.5",
+  "version": "2.1.7",
   "main": "dist/index.js",
   "bin": "dist/main.js",
   "files": [
@@ -87,7 +87,7 @@
     "esbuild": "^0.25.4",
     "fast-glob": "^3.3.3",
     "form-data": "^4.0.4",
-    "generaltranslation": "^7.4.0",
+    "generaltranslation": "^7.4.1",
     "json-pointer": "^0.6.2",
     "jsonpath-plus": "^10.3.0",
     "jsonpointer": "^5.0.1",

package/dist/api/downloadFile.d.ts

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

@@ -1,74 +0,0 @@
-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/fetchTranslations.d.ts

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

@@ -1,18 +0,0 @@
-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/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');
-    }
-}