gtx-cli 2.0.15 → 2.0.17-alpha.1

package/CHANGELOG.md

@@ -1,5 +1,11 @@
 # gtx-cli
 
+## 2.0.16
+
+### Patch Changes
+
+- [#512](https://github.com/generaltranslation/gt/pull/512) [`7c01ee8`](https://github.com/generaltranslation/gt/commit/7c01ee8af1e882d222fc3b0224b17f459ec5243b) Thanks [@brian-lou](https://github.com/brian-lou)! - Add new CLI command 'upload', add additional transform options for file translations
+
 ## 2.0.15
 
 ### Patch Changes

package/dist/api/checkFileTranslations.js

@@ -180,6 +180,7 @@ async function checkTranslationDeployment(fileQueryData, downloadStatus, spinner
                 const outputPath = resolveOutputPath(fileName, locale);
                 return {
                     translationId,
+                    inputPath: fileName,
                     outputPath,
                     locale,
                     fileLocale: `${fileName}:${locale}`,
@@ -187,9 +188,10 @@ async function checkTranslationDeployment(fileQueryData, downloadStatus, spinner
             });
             // Use batch download if there are multiple files
             if (batchFiles.length > 1) {
-                const batchResult = await downloadFileBatch(batchFiles.map(({ translationId, outputPath, locale }) => ({
+                const batchResult = await downloadFileBatch(batchFiles.map(({ translationId, outputPath, inputPath, locale }) => ({
                     translationId,
                     outputPath,
+                    inputPath,
                     locale,
                 })), options);
                 // Process results
@@ -206,7 +208,7 @@ async function checkTranslationDeployment(fileQueryData, downloadStatus, spinner
             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.locale, options);
+                const result = await downloadFile(file.translationId, file.outputPath, file.inputPath, file.locale, options);
                 if (result) {
                     downloadStatus.downloaded.add(file.fileLocale);
                 }

package/dist/api/downloadFile.d.ts

@@ -6,4 +6,4 @@ import { Settings } from '../types/index.js';
  * @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, locale: string, options: Settings, maxRetries?: number, retryDelay?: number): Promise<boolean>;
+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

@@ -12,7 +12,7 @@ import { TextDecoder } from 'node:util';
  * @param maxRetries - The maximum number of retries to attempt
  * @param retryDelay - The delay between retries in milliseconds
  */
-export async function downloadFile(translationId, outputPath, locale, options, maxRetries = 3, retryDelay = 1000) {
+export async function downloadFile(translationId, outputPath, inputPath, locale, options, maxRetries = 3, retryDelay = 1000) {
     let retries = 0;
     while (retries <= maxRetries) {
         try {
@@ -29,7 +29,7 @@ export async function downloadFile(translationId, outputPath, locale, options, m
                 if (jsonSchema) {
                     const originalContent = fs.readFileSync(outputPath, 'utf8');
                     if (originalContent) {
-                        data = mergeJson(originalContent, outputPath, options.options, [
+                        data = mergeJson(originalContent, inputPath, options.options, [
                             {
                                 translatedContent: data,
                                 targetLocale: locale,

package/dist/api/downloadFileBatch.d.ts

@@ -2,6 +2,7 @@ import { Settings } from '../types/index.js';
 export type BatchedFiles = Array<{
     translationId: string;
     outputPath: string;
+    inputPath: string;
     locale: string;
 }>;
 export type DownloadFileBatchResult = {

package/dist/api/downloadFileBatch.js

@@ -17,6 +17,7 @@ export async function downloadFileBatch(files, options, maxRetries = 3, retryDel
     const result = { successful: [], failed: [] };
     // Create a map of translationId to outputPath for easier lookup
     const outputPathMap = new Map(files.map((file) => [file.translationId, file.outputPath]));
+    const inputPathMap = new Map(files.map((file) => [file.translationId, file.inputPath]));
     const localeMap = new Map(files.map((file) => [file.translationId, file.locale]));
     while (retries <= maxRetries) {
         try {
@@ -28,8 +29,9 @@ export async function downloadFileBatch(files, options, maxRetries = 3, retryDel
                 try {
                     const translationId = file.id;
                     const outputPath = outputPathMap.get(translationId);
+                    const inputPath = inputPathMap.get(translationId);
                     const locale = localeMap.get(translationId);
-                    if (!outputPath) {
+                    if (!outputPath || !inputPath) {
                         logWarning(`No output path found for file: ${translationId}`);
                         result.failed.push(translationId);
                         continue;
@@ -41,11 +43,11 @@ export async function downloadFileBatch(files, options, maxRetries = 3, retryDel
                     }
                     let data = file.data;
                     if (options.options?.jsonSchema && locale) {
-                        const jsonSchema = validateJsonSchema(options.options, outputPath);
+                        const jsonSchema = validateJsonSchema(options.options, inputPath);
                         if (jsonSchema) {
-                            const originalContent = fs.readFileSync(outputPath, 'utf8');
+                            const originalContent = fs.readFileSync(inputPath, 'utf8');
                             if (originalContent) {
-                                data = mergeJson(originalContent, outputPath, options.options, [
+                                data = mergeJson(originalContent, inputPath, options.options, [
                                     {
                                         translatedContent: file.data,
                                         targetLocale: locale,

package/dist/api/uploadFiles.d.ts

@@ -0,0 +1,26 @@
+import { Settings } from '../types/index.js';
+import { DataFormat, FileFormat } from '../types/data.js';
+export type FileUpload = {
+    content: string;
+    fileName: string;
+    fileFormat: FileFormat;
+    dataFormat?: DataFormat;
+    locale: string;
+};
+export type UploadData = {
+    data: {
+        source: FileUpload;
+        translations: FileUpload[];
+    }[];
+    sourceLocale: string;
+};
+/**
+ * Uploads multiple files to the API
+ * @param files - Array of file objects to upload
+ * @param options - The options for the API call
+ * @returns The uploaded content or version ID
+ */
+export declare function uploadFiles(files: {
+    source: FileUpload;
+    translations: FileUpload[];
+}[], options: Settings): Promise<Response>;

package/dist/api/uploadFiles.js

@@ -0,0 +1,46 @@
+import chalk from 'chalk';
+import { createSpinner, exit, logMessage } from '../console/logging.js';
+/**
+ * Uploads multiple files to the API
+ * @param files - Array of file objects to upload
+ * @param options - The options for the API call
+ * @returns The uploaded content or version ID
+ */
+export async function uploadFiles(files, options) {
+    logMessage(chalk.cyan('Files to upload:') +
+        '\n' +
+        files
+            .map((file) => `  - ${chalk.bold(file.source.fileName)} -> ${file.translations
+            .map((t) => t.locale)
+            .join(', ')}`)
+            .join('\n'));
+    const spinner = createSpinner('dots');
+    spinner.start(`Uploading ${files.length} file${files.length !== 1 ? 's' : ''} to General Translation...`);
+    const uploadData = {
+        data: files.map((file) => ({
+            source: file.source,
+            translations: file.translations,
+        })),
+        sourceLocale: options.defaultLocale,
+    };
+    try {
+        const response = await fetch(`${options.baseUrl}/v1/project/files/upload`, {
+            method: 'POST',
+            body: JSON.stringify(uploadData),
+            headers: {
+                'Content-Type': 'application/json',
+                'x-gt-api-key': options.apiKey,
+                'x-gt-project-id': options.projectId,
+            },
+        });
+        if (!response.ok) {
+            throw new Error(`Failed to upload files: ${response.statusText} (${response.status})`);
+        }
+        spinner.stop(chalk.green('Files uploaded successfully'));
+        return response;
+    }
+    catch (error) {
+        spinner.stop(chalk.red('An unexpected error occurred while uploading files'));
+        exit(1);
+    }
+}

package/dist/cli/base.d.ts

@@ -1,5 +1,11 @@
 import { Command } from 'commander';
 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;
@@ -23,10 +29,12 @@ export declare class BaseCLI {
     init(): void;
     execute(): 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>;

package/dist/cli/base.js

@@ -18,6 +18,7 @@ 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';
 export class BaseCLI {
     library;
     additionalModules;
@@ -30,6 +31,7 @@ export class BaseCLI {
         this.setupInitCommand();
         this.setupConfigureCommand();
         this.setupSetupCommand();
+        this.setupUploadCommand();
         this.setupLoginCommand();
     }
     // Init is never called in a child class
@@ -65,6 +67,22 @@ export class BaseCLI {
             endCommand('Done!');
         });
     }
+    setupUploadCommand() {
+        this.program
+            .command('upload')
+            .description('Upload source files and translations to the General Translation platform')
+            .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)')
+            .action(async (initOptions) => {
+            displayHeader('Starting upload...');
+            const settings = await generateSettings(initOptions);
+            const options = { ...initOptions, ...settings };
+            await this.handleUploadCommand(options);
+            endCommand('Done!');
+        });
+    }
     setupLoginCommand() {
         this.program
             .command('auth')
@@ -155,6 +173,30 @@ See the docs for more information: https://generaltranslation.com/docs/react/tut
             endCommand("Done! Take advantage of all of General Translation's features by signing up for a free account! https://generaltranslation.com/signup");
         });
     }
+    async handleUploadCommand(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) {
+            return;
+        }
+        const { resolvedPaths: sourceFiles, placeholderPaths, transformPaths, } = settings.files;
+        // 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;

package/dist/formats/files/fileMapping.d.ts

@@ -0,0 +1,10 @@
+import { ResolvedFiles, TransformFiles } from '../../types/index.js';
+/**
+ * Creates a mapping between source files and their translated counterparts for each locale
+ * @param filePaths - Resolved file paths for different file types
+ * @param placeholderPaths - Placeholder paths for translated files
+ * @param transformPaths - Transform paths for file naming
+ * @param locales - List of locales to create a mapping for
+ * @returns A mapping between source files and their translated counterparts for each locale, in the form of relative paths
+ */
+export declare function createFileMapping(filePaths: ResolvedFiles, placeholderPaths: ResolvedFiles, transformPaths: TransformFiles, targetLocales: string[], defaultLocale: string): Record<string, Record<string, string>>;

package/dist/formats/files/fileMapping.js

@@ -0,0 +1,76 @@
+import { SUPPORTED_FILE_EXTENSIONS } from '../files/supportedFiles.js';
+import { resolveLocaleFiles } from '../../fs/config/parseFilesConfig.js';
+import path from 'node:path';
+import { getRelative } from '../../fs/findFilepath.js';
+import { getLocaleProperties } from 'generaltranslation';
+import { replaceLocalePlaceholders } from '../utils.js';
+/**
+ * Creates a mapping between source files and their translated counterparts for each locale
+ * @param filePaths - Resolved file paths for different file types
+ * @param placeholderPaths - Placeholder paths for translated files
+ * @param transformPaths - Transform paths for file naming
+ * @param locales - List of locales to create a mapping for
+ * @returns A mapping between source files and their translated counterparts for each locale, in the form of relative paths
+ */
+export function createFileMapping(filePaths, placeholderPaths, transformPaths, targetLocales, defaultLocale) {
+    const fileMapping = {};
+    for (const locale of targetLocales) {
+        const translatedPaths = resolveLocaleFiles(placeholderPaths, locale);
+        const localeMapping = {};
+        // Process each file type
+        for (const typeIndex of SUPPORTED_FILE_EXTENSIONS) {
+            if (!filePaths[typeIndex] || !translatedPaths[typeIndex])
+                continue;
+            const sourcePaths = filePaths[typeIndex];
+            let translatedFiles = translatedPaths[typeIndex];
+            if (!translatedFiles)
+                continue;
+            const transformPath = transformPaths[typeIndex];
+            if (transformPath) {
+                if (typeof transformPath === 'string') {
+                    translatedFiles = translatedFiles.map((filePath) => {
+                        const directory = path.dirname(filePath);
+                        const fileName = path.basename(filePath);
+                        const baseName = fileName.split('.')[0];
+                        const transformedFileName = transformPath
+                            .replace('*', baseName)
+                            .replace('[locale]', locale);
+                        return path.join(directory, transformedFileName);
+                    });
+                }
+                else {
+                    // transformPath is an object
+                    const targetLocaleProperties = getLocaleProperties(locale);
+                    const defaultLocaleProperties = getLocaleProperties(defaultLocale);
+                    if (!transformPath.replace ||
+                        typeof transformPath.replace !== 'string') {
+                        continue;
+                    }
+                    // Replace all locale property placeholders
+                    const replaceString = replaceLocalePlaceholders(transformPath.replace, targetLocaleProperties);
+                    translatedFiles = translatedFiles.map((filePath) => {
+                        let relativePath = getRelative(filePath);
+                        if (transformPath.match &&
+                            typeof transformPath.match === 'string') {
+                            // Replace locale placeholders in the match string using defaultLocale properties
+                            let matchString = transformPath.match;
+                            matchString = replaceLocalePlaceholders(matchString, defaultLocaleProperties);
+                            relativePath = relativePath.replace(new RegExp(matchString, 'g'), replaceString);
+                        }
+                        else {
+                            relativePath = replaceString;
+                        }
+                        return path.resolve(relativePath);
+                    });
+                }
+            }
+            for (let i = 0; i < sourcePaths.length; i++) {
+                const sourceFile = getRelative(sourcePaths[i]);
+                const translatedFile = getRelative(translatedFiles[i]);
+                localeMapping[sourceFile] = translatedFile;
+            }
+        }
+        fileMapping[locale] = localeMapping;
+    }
+    return fileMapping;
+}

package/dist/formats/files/translate.d.ts

@@ -11,7 +11,3 @@ import { TranslateOptions } from '../../cli/base.js';
  * @returns Promise that resolves when translation is complete
  */
 export declare function translateFiles(filePaths: ResolvedFiles, placeholderPaths: ResolvedFiles, transformPaths: TransformFiles, dataFormat: DataFormat | undefined, options: Settings & TranslateOptions): Promise<void>;
-/**
- * Creates a mapping between source files and their translated counterparts for each locale
- */
-export declare function createFileMapping(filePaths: ResolvedFiles, placeholderPaths: ResolvedFiles, transformPaths: TransformFiles, locales: string[]): Record<string, Record<string, string>>;

package/dist/formats/files/translate.js

@@ -2,15 +2,14 @@ import { checkFileTranslations } from '../../api/checkFileTranslations.js';
 import { sendFiles } from '../../api/sendFiles.js';
 import { noSupportedFormatError, noLocalesError, noDefaultLocaleError, noApiKeyError, noProjectIdError, devApiKeyError, } from '../../console/index.js';
 import { logErrorAndExit, createSpinner, logError, logSuccess, } from '../../console/logging.js';
-import { resolveLocaleFiles } from '../../fs/config/parseFilesConfig.js';
 import { getRelative, readFile } from '../../fs/findFilepath.js';
-import path from 'node:path';
 import chalk from 'chalk';
 import { downloadFile } from '../../api/downloadFile.js';
 import { downloadFileBatch } from '../../api/downloadFileBatch.js';
 import { SUPPORTED_FILE_EXTENSIONS } from './supportedFiles.js';
 import sanitizeFileContent from '../../utils/sanitizeFileContent.js';
 import { parseJson } from '../json/parseJson.js';
+import { createFileMapping } from './fileMapping.js';
 const SUPPORTED_DATA_FORMATS = ['JSX', 'ICU', 'I18NEXT'];
 /**
  * Sends multiple files to the API for translation
@@ -95,7 +94,7 @@ export async function translateFiles(filePaths, placeholderPaths, transformPaths
         });
         const { data, locales, translations } = response;
         // Create file mapping for all file types
-        const fileMapping = createFileMapping(filePaths, placeholderPaths, transformPaths, locales);
+        const fileMapping = createFileMapping(filePaths, placeholderPaths, transformPaths, locales, options.defaultLocale);
         // Process any translations that were already completed and returned with the initial response
         const downloadStatus = await processInitialTranslations(translations, fileMapping, options);
         // Check for remaining translations
@@ -106,44 +105,6 @@ export async function translateFiles(filePaths, placeholderPaths, transformPaths
         logErrorAndExit(`Error translating files: ${error}`);
     }
 }
-/**
- * Creates a mapping between source files and their translated counterparts for each locale
- */
-export function createFileMapping(filePaths, placeholderPaths, transformPaths, locales) {
-    const fileMapping = {};
-    for (const locale of locales) {
-        const translatedPaths = resolveLocaleFiles(placeholderPaths, locale);
-        const localeMapping = {};
-        // Process each file type
-        for (const typeIndex of SUPPORTED_FILE_EXTENSIONS) {
-            if (!filePaths[typeIndex] || !translatedPaths[typeIndex])
-                continue;
-            const sourcePaths = filePaths[typeIndex];
-            let translatedFiles = translatedPaths[typeIndex];
-            if (!translatedFiles)
-                continue;
-            const transformPath = transformPaths[typeIndex];
-            if (transformPath) {
-                translatedFiles = translatedFiles.map((filePath) => {
-                    const directory = path.dirname(filePath);
-                    const fileName = path.basename(filePath);
-                    const baseName = fileName.split('.')[0];
-                    const transformedFileName = transformPath
-                        .replace('*', baseName)
-                        .replace('[locale]', locale);
-                    return path.join(directory, transformedFileName);
-                });
-            }
-            for (let i = 0; i < sourcePaths.length; i++) {
-                const sourceFile = getRelative(sourcePaths[i]);
-                const translatedFile = getRelative(translatedFiles[i]);
-                localeMapping[sourceFile] = translatedFile;
-            }
-        }
-        fileMapping[locale] = localeMapping;
-    }
-    return fileMapping;
-}
 /**
  * Processes translations that were already completed and returned with the initial API response
  * @returns Set of downloaded file+locale combinations
@@ -171,6 +132,7 @@ async function processInitialTranslations(translations = [], fileMapping, option
             }
             return {
                 translationId: id,
+                inputPath: fileName,
                 outputPath,
                 fileLocale: `${fileName}:${locale}`,
                 locale,
@@ -182,9 +144,10 @@ async function processInitialTranslations(translations = [], fileMapping, option
         }
         // Use batch download if there are multiple files
         if (batchFiles.length > 1) {
-            const batchResult = await downloadFileBatch(batchFiles.map(({ translationId, outputPath, locale }) => ({
+            const batchResult = await downloadFileBatch(batchFiles.map(({ translationId, outputPath, inputPath, locale }) => ({
                 translationId,
                 outputPath,
+                inputPath,
                 locale,
             })), options);
             // Process results
@@ -201,7 +164,7 @@ async function processInitialTranslations(translations = [], fileMapping, option
         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.locale, options);
+            const result = await downloadFile(file.translationId, file.outputPath, file.inputPath, file.locale, options);
             if (result) {
                 downloadStatus.downloaded.add(file.fileLocale);
             }

package/dist/formats/files/upload.d.ts

@@ -0,0 +1,13 @@
+import { ResolvedFiles, Settings, TransformFiles } from '../../types/index.js';
+import { DataFormat } from '../../types/data.js';
+import { UploadOptions } from '../../cli/base.js';
+/**
+ * Sends multiple files to the API for translation
+ * @param filePaths - Resolved file paths for different file types
+ * @param placeholderPaths - Placeholder paths for translated files
+ * @param transformPaths - Transform paths for file naming
+ * @param dataFormat - Format of the data within the files
+ * @param options - Translation options including API settings
+ * @returns Promise that resolves when translation is complete
+ */
+export declare function upload(filePaths: ResolvedFiles, placeholderPaths: ResolvedFiles, transformPaths: TransformFiles, dataFormat: DataFormat | undefined, options: Settings & UploadOptions): Promise<void>;

package/dist/formats/files/upload.js

@@ -0,0 +1,192 @@
+import { noSupportedFormatError, noDefaultLocaleError, noApiKeyError, noProjectIdError, devApiKeyError, } from '../../console/index.js';
+import { logErrorAndExit, createSpinner, logError, } from '../../console/logging.js';
+import { getRelative, readFile } from '../../fs/findFilepath.js';
+import chalk from 'chalk';
+import { downloadFile } from '../../api/downloadFile.js';
+import { downloadFileBatch } from '../../api/downloadFileBatch.js';
+import { SUPPORTED_FILE_EXTENSIONS } from './supportedFiles.js';
+import sanitizeFileContent from '../../utils/sanitizeFileContent.js';
+import { parseJson } from '../json/parseJson.js';
+import { uploadFiles } from '../../api/uploadFiles.js';
+import { existsSync, readFileSync } from 'node:fs';
+import { createFileMapping } from './fileMapping.js';
+const SUPPORTED_DATA_FORMATS = ['JSX', 'ICU', 'I18NEXT'];
+/**
+ * Sends multiple files to the API for translation
+ * @param filePaths - Resolved file paths for different file types
+ * @param placeholderPaths - Placeholder paths for translated files
+ * @param transformPaths - Transform paths for file naming
+ * @param dataFormat - Format of the data within the files
+ * @param options - Translation options including API settings
+ * @returns Promise that resolves when translation is complete
+ */
+export async function upload(filePaths, placeholderPaths, transformPaths, dataFormat = 'JSX', options) {
+    // Collect all files to translate
+    const allFiles = [];
+    const additionalOptions = options.options || {};
+    // Process JSON files
+    if (filePaths.json) {
+        if (!SUPPORTED_DATA_FORMATS.includes(dataFormat)) {
+            logErrorAndExit(noSupportedFormatError);
+        }
+        const jsonFiles = filePaths.json.map((filePath) => {
+            const content = readFile(filePath);
+            const parsedJson = parseJson(content, filePath, additionalOptions, options.defaultLocale);
+            const relativePath = getRelative(filePath);
+            return {
+                content: parsedJson,
+                fileName: relativePath,
+                fileFormat: 'JSON',
+                dataFormat,
+                locale: options.defaultLocale,
+            };
+        });
+        allFiles.push(...jsonFiles);
+    }
+    for (const fileType of SUPPORTED_FILE_EXTENSIONS) {
+        if (fileType === 'json')
+            continue;
+        if (filePaths[fileType]) {
+            const files = filePaths[fileType].map((filePath) => {
+                const content = readFile(filePath);
+                const sanitizedContent = sanitizeFileContent(content);
+                const relativePath = getRelative(filePath);
+                return {
+                    content: sanitizedContent,
+                    fileName: relativePath,
+                    fileFormat: fileType.toUpperCase(),
+                    dataFormat,
+                    locale: options.defaultLocale,
+                };
+            });
+            allFiles.push(...files);
+        }
+    }
+    if (allFiles.length === 0) {
+        logError('No files to upload were found. Please check your configuration and try again.');
+        return;
+    }
+    if (!options.defaultLocale) {
+        logErrorAndExit(noDefaultLocaleError);
+    }
+    if (!options.apiKey) {
+        logErrorAndExit(noApiKeyError);
+    }
+    if (options.apiKey.startsWith('gtx-dev-')) {
+        logErrorAndExit(devApiKeyError);
+    }
+    if (!options.projectId) {
+        logErrorAndExit(noProjectIdError);
+    }
+    const locales = options.locales || [];
+    // Create file mapping for all file types
+    const fileMapping = createFileMapping(filePaths, placeholderPaths, transformPaths, locales, options.defaultLocale);
+    // construct object
+    const uploadData = allFiles.map((file) => {
+        const encodedContent = Buffer.from(file.content).toString('base64');
+        const sourceFile = {
+            content: encodedContent,
+            fileName: file.fileName,
+            fileFormat: file.fileFormat,
+            dataFormat: file.dataFormat,
+            locale: file.locale,
+        };
+        const translations = [];
+        for (const locale of locales) {
+            const translatedFileName = fileMapping[locale][file.fileName];
+            if (translatedFileName && existsSync(translatedFileName)) {
+                const translatedContent = readFileSync(translatedFileName, 'utf8');
+                const encodedTranslatedContent = Buffer.from(translatedContent).toString('base64');
+                translations.push({
+                    content: encodedTranslatedContent,
+                    fileName: translatedFileName,
+                    fileFormat: file.fileFormat,
+                    dataFormat: file.dataFormat,
+                    locale,
+                });
+            }
+        }
+        return {
+            source: sourceFile,
+            translations,
+        };
+    });
+    try {
+        // Send all files in a single API call
+        const response = await uploadFiles(uploadData, options);
+    }
+    catch (error) {
+        logErrorAndExit(`Error uploading files: ${error}`);
+    }
+}
+/**
+ * Processes translations that were already completed and returned with the initial API response
+ * @returns Set of downloaded file+locale combinations
+ */
+async function processInitialTranslations(translations = [], fileMapping, options) {
+    const downloadStatus = {
+        downloaded: new Set(),
+        failed: new Set(),
+    };
+    if (!translations || translations.length === 0) {
+        return downloadStatus;
+    }
+    // Filter for ready translations
+    const readyTranslations = translations.filter((translation) => translation.isReady && translation.fileName);
+    if (readyTranslations.length > 0) {
+        const spinner = createSpinner('dots');
+        spinner.start('Downloading translations...');
+        // Prepare batch download data
+        const batchFiles = readyTranslations
+            .map((translation) => {
+            const { locale, fileName, id } = translation;
+            const outputPath = fileMapping[locale][fileName];
+            if (!outputPath) {
+                return null;
+            }
+            return {
+                translationId: id,
+                outputPath,
+                inputPath: fileName,
+                fileLocale: `${fileName}:${locale}`,
+                locale,
+            };
+        })
+            .filter(Boolean);
+        if (batchFiles.length === 0 || batchFiles[0] === null) {
+            return downloadStatus;
+        }
+        // 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 {
+                downloadStatus.failed.add(file.fileLocale);
+            }
+        }
+        spinner.stop(chalk.green('Downloaded cached translations'));
+    }
+    return downloadStatus;
+}

package/dist/formats/json/mergeJson.d.ts

@@ -1,5 +1,5 @@
 import { AdditionalOptions, SourceObjectOptions } from '../../types/index.js';
-export declare function mergeJson(originalContent: string, filePath: string, options: AdditionalOptions, targets: {
+export declare function mergeJson(originalContent: string, inputPath: string, options: AdditionalOptions, targets: {
     translatedContent: string;
     targetLocale: string;
 }[], defaultLocale: string): string[];

package/dist/formats/json/mergeJson.js

@@ -3,8 +3,9 @@ import { exit, logError, logWarning } from '../../console/logging.js';
 import { findMatchingItemArray, findMatchingItemObject, generateSourceObjectPointers, getSourceObjectOptionsArray, validateJsonSchema, } from './utils.js';
 import { JSONPath } from 'jsonpath-plus';
 import { getLocaleProperties } from 'generaltranslation';
-export function mergeJson(originalContent, filePath, options, targets, defaultLocale) {
-    const jsonSchema = validateJsonSchema(options, filePath);
+import { replaceLocalePlaceholders } from '../utils.js';
+export function mergeJson(originalContent, inputPath, options, targets, defaultLocale) {
+    const jsonSchema = validateJsonSchema(options, inputPath);
     if (!jsonSchema) {
         return targets.map((target) => target.translatedContent);
     }
@@ -13,7 +14,7 @@ export function mergeJson(originalContent, filePath, options, targets, defaultLo
         originalJson = JSON.parse(originalContent);
     }
     catch {
-        logError(`Invalid JSON file: ${filePath}`);
+        logError(`Invalid JSON file: ${inputPath}`);
         exit(1);
     }
     // Handle include
@@ -204,30 +205,6 @@ export function mergeJson(originalContent, filePath, options, targets, defaultLo
     }
     return [JSON.stringify(mergedJson, null, 2)];
 }
-// helper function to replace locale placeholders in a string
-// with the corresponding locale properties
-// ex: {locale} -> will be replaced with the locale code
-// ex: {localeName} -> will be replaced with the locale name
-function replaceLocalePlaceholders(string, localeProperties) {
-    return string.replace(/\{(\w+)\}/g, (match, property) => {
-        // Handle common aliases
-        if (property === 'locale' || property === 'localeCode') {
-            return localeProperties.code;
-        }
-        if (property === 'localeName') {
-            return localeProperties.name;
-        }
-        if (property === 'localeNativeName') {
-            return localeProperties.nativeName;
-        }
-        // Check if the property exists in localeProperties
-        if (property in localeProperties) {
-            return localeProperties[property];
-        }
-        // Return the original placeholder if property not found
-        return match;
-    });
-}
 /**
  * Apply transformations to the sourceItem in-place
  * @param sourceItem - The source item to apply transformations to

package/dist/formats/utils.d.ts

@@ -0,0 +1,2 @@
+import { LocaleProperties } from 'generaltranslation/types';
+export declare function replaceLocalePlaceholders(string: string, localeProperties: LocaleProperties): string;

package/dist/formats/utils.js

@@ -0,0 +1,24 @@
+// helper function to replace locale placeholders in a string
+// with the corresponding locale properties
+// ex: {locale} -> will be replaced with the locale code
+// ex: {localeName} -> will be replaced with the locale name
+export function replaceLocalePlaceholders(string, localeProperties) {
+    return string.replace(/\{(\w+)\}/g, (match, property) => {
+        // Handle common aliases
+        if (property === 'locale' || property === 'localeCode') {
+            return localeProperties.code;
+        }
+        if (property === 'localeName') {
+            return localeProperties.name;
+        }
+        if (property === 'localeNativeName') {
+            return localeProperties.nativeName;
+        }
+        // Check if the property exists in localeProperties
+        if (property in localeProperties) {
+            return localeProperties[property];
+        }
+        // Return the original placeholder if property not found
+        return match;
+    });
+}

package/dist/fs/config/parseFilesConfig.js

@@ -39,9 +39,11 @@ export function resolveFiles(files, locale, cwd) {
     }
     for (const fileType of SUPPORTED_FILE_EXTENSIONS) {
         // ==== TRANSFORMS ==== //
-        if (files[fileType]?.transform &&
-            !Array.isArray(files[fileType].transform)) {
-            transformPaths[fileType] = files[fileType].transform;
+        const transform = files[fileType]?.transform;
+        if (transform &&
+            !Array.isArray(transform) &&
+            (typeof transform === 'string' || typeof transform === 'object')) {
+            transformPaths[fileType] = transform;
         }
         // ==== PLACEHOLDERS ==== //
         if (files[fileType]?.include) {

package/dist/types/index.d.ts

@@ -60,8 +60,12 @@ export type ResolvedFiles = {
 } & {
     gt?: string;
 };
+export type TransformOption = {
+    match?: string;
+    replace: string;
+};
 export type TransformFiles = {
-    [K in SupportedFileExtension]?: string;
+    [K in SupportedFileExtension]?: TransformOption | string;
 };
 export type FilesOptions = {
     [K in SupportedFileExtension]?: {
@@ -119,8 +123,5 @@ export type SourceObjectOptions = {
     transform?: TransformOptions;
 };
 export type TransformOptions = {
-    [transformPath: string]: {
-        match?: string;
-        replace: string;
-    };
+    [transformPath: string]: TransformOption;
 };

package/dist/utils/flattenJsonFiles.js

@@ -1,4 +1,4 @@
-import { createFileMapping } from '../formats/files/translate.js';
+import { createFileMapping } from '../formats/files/fileMapping.js';
 import fs from 'node:fs';
 export default async function flattenJsonFiles(settings) {
     if (!settings.files ||
@@ -7,7 +7,7 @@ export default async function flattenJsonFiles(settings) {
         return;
     }
     const { resolvedPaths: sourceFiles } = settings.files;
-    const fileMapping = createFileMapping(sourceFiles, settings.files.placeholderPaths, settings.files.transformPaths, settings.locales);
+    const fileMapping = createFileMapping(sourceFiles, settings.files.placeholderPaths, settings.files.transformPaths, settings.locales, settings.defaultLocale);
     await Promise.all(Object.values(fileMapping).map(async (filesMap) => {
         const targetFiles = Object.values(filesMap).filter((path) => path.endsWith('.json'));
         await Promise.all(targetFiles.map(async (file) => {

package/dist/utils/localizeStaticImports.js

@@ -1,5 +1,5 @@
 import * as fs from 'fs';
-import { createFileMapping } from '../formats/files/translate.js';
+import { createFileMapping } from '../formats/files/fileMapping.js';
 import { logError } from '../console/logging.js';
 /**
  * Localizes static imports in content files.
@@ -21,7 +21,7 @@ export default async function localizeStaticImports(settings) {
         return;
     }
     const { resolvedPaths: sourceFiles } = settings.files;
-    const fileMapping = createFileMapping(sourceFiles, settings.files.placeholderPaths, settings.files.transformPaths, settings.locales);
+    const fileMapping = createFileMapping(sourceFiles, settings.files.placeholderPaths, settings.files.transformPaths, settings.locales, settings.defaultLocale);
     // Process all file types at once with a single call
     await Promise.all(Object.entries(fileMapping).map(async ([locale, filesMap]) => {
         // Get all files that are md or mdx

package/dist/utils/localizeStaticUrls.js

@@ -1,5 +1,5 @@
 import * as fs from 'fs';
-import { createFileMapping } from '../formats/files/translate.js';
+import { createFileMapping } from '../formats/files/fileMapping.js';
 /**
  * Localizes static urls in content files.
  * Currently only supported for md and mdx files. (/docs/ -> /[locale]/docs/)
@@ -20,7 +20,7 @@ export default async function localizeStaticUrls(settings) {
         return;
     }
     const { resolvedPaths: sourceFiles } = settings.files;
-    const fileMapping = createFileMapping(sourceFiles, settings.files.placeholderPaths, settings.files.transformPaths, settings.locales);
+    const fileMapping = createFileMapping(sourceFiles, settings.files.placeholderPaths, settings.files.transformPaths, settings.locales, settings.defaultLocale);
     // Process all file types at once with a single call
     await Promise.all(Object.entries(fileMapping).map(async ([locale, filesMap]) => {
         // Get all files that are md or mdx

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gtx-cli",
-  "version": "2.0.15",
+  "version": "2.0.17-alpha.1",
   "main": "dist/index.js",
   "bin": "dist/main.js",
   "files": [