gtx-cli 2.5.36 → 2.5.37

package/CHANGELOG.md

@@ -1,5 +1,16 @@
 # gtx-cli
 
+## 2.5.37
+
+### Patch Changes
+
+- [#911](https://github.com/generaltranslation/gt/pull/911) [`6af64c0`](https://github.com/generaltranslation/gt/commit/6af64c04fa6e3d6332a206d9b68fa1a46de1c002) Thanks [@fernando-aviles](https://github.com/fernando-aviles)! - Adding `experimentalCanonicalLocaleKeys` option to `gt.config.json`. It overrides alias configurations when setting keys in a JSON schema
+
+- [#908](https://github.com/generaltranslation/gt/pull/908) [`1e7e52f`](https://github.com/generaltranslation/gt/commit/1e7e52f3a77835887ff187ffeb99d6e3dc2a9e6c) Thanks [@brian-lou](https://github.com/brian-lou)! - Fix timeout logic; Refactor upload command
+
+- Updated dependencies [[`1e7e52f`](https://github.com/generaltranslation/gt/commit/1e7e52f3a77835887ff187ffeb99d6e3dc2a9e6c)]:
+  - generaltranslation@8.1.5
+
 ## 2.5.36
 
 ### Patch Changes

package/dist/cli/base.js

@@ -130,14 +130,9 @@ export class BaseCLI {
         clearDownloaded();
     }
     setupUploadCommand() {
-        this.program
+        attachTranslateFlags(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) => {
+            .description('Upload source files and translations to the General Translation platform')).action(async (initOptions) => {
             displayHeader('Starting upload...');
             const settings = await generateSettings(initOptions);
             const options = { ...initOptions, ...settings };

package/dist/formats/files/collectFiles.js

@@ -40,6 +40,7 @@ export async function collectFiles(options, settings, library) {
                 formatMetadata: fileMetadata,
                 fileId: TEMPLATE_FILE_ID,
                 versionId: hashStringSync(JSON.stringify({ data: fileData, metadata: fileMetadata })),
+                locale: settings.defaultLocale,
             });
         }
     }

package/dist/formats/files/translate.js

@@ -57,6 +57,7 @@ export async function aggregateFiles(settings) {
                 fileName: relativePath,
                 fileFormat: 'JSON',
                 dataFormat,
+                locale: settings.defaultLocale,
             };
         })
             .filter((file) => {
@@ -91,6 +92,7 @@ export async function aggregateFiles(settings) {
                 fileFormat,
                 fileId: hashStringSync(relativePath),
                 versionId: hashStringSync(parsedYaml),
+                locale: settings.defaultLocale,
             };
         })
             .filter((file) => {
@@ -124,6 +126,7 @@ export async function aggregateFiles(settings) {
                     fileFormat: fileType.toUpperCase(),
                     fileId: hashStringSync(relativePath),
                     versionId: hashStringSync(content),
+                    locale: settings.defaultLocale,
                 };
             })
                 .filter((file) => {

package/dist/formats/files/upload.js

@@ -5,10 +5,11 @@ import { getRelative, readFile } from '../../fs/findFilepath.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 { uploadFiles } from '../../workflow/upload.js';
 import { existsSync, readFileSync } from 'node:fs';
 import { createFileMapping } from './fileMapping.js';
 import parseYaml from '../yaml/parseYaml.js';
+import { hashStringSync } from '../../utils/hash.js';
 const SUPPORTED_DATA_FORMATS = ['JSX', 'ICU', 'I18NEXT'];
 /**
  * Sends multiple files to the API for translation
@@ -38,6 +39,8 @@ export async function upload(filePaths, placeholderPaths, transformPaths, dataFo
                 fileFormat: 'JSON',
                 dataFormat,
                 locale: options.defaultLocale,
+                fileId: hashStringSync(relativePath),
+                versionId: hashStringSync(parsedJson),
             };
         });
         allFiles.push(...jsonFiles);
@@ -57,6 +60,8 @@ export async function upload(filePaths, placeholderPaths, transformPaths, dataFo
                 fileFormat,
                 dataFormat,
                 locale: options.defaultLocale,
+                fileId: hashStringSync(relativePath),
+                versionId: hashStringSync(parsedYaml),
             };
         });
         allFiles.push(...yamlFiles);
@@ -75,6 +80,8 @@ export async function upload(filePaths, placeholderPaths, transformPaths, dataFo
                     fileFormat: fileType.toUpperCase(),
                     dataFormat,
                     locale: options.defaultLocale,
+                    fileId: hashStringSync(relativePath),
+                    versionId: hashStringSync(sanitizedContent),
                 };
             });
             allFiles.push(...files);
@@ -107,6 +114,8 @@ export async function upload(filePaths, placeholderPaths, transformPaths, dataFo
             fileFormat: file.fileFormat,
             dataFormat: file.dataFormat,
             locale: file.locale,
+            fileId: file.fileId,
+            versionId: file.versionId,
         };
         const translations = [];
         for (const locale of locales) {
@@ -115,10 +124,12 @@ export async function upload(filePaths, placeholderPaths, transformPaths, dataFo
                 const translatedContent = readFileSync(translatedFileName, 'utf8');
                 translations.push({
                     content: translatedContent,
-                    fileName: translatedFileName,
+                    fileName: file.fileName,
                     fileFormat: file.fileFormat,
                     dataFormat: file.dataFormat,
                     locale,
+                    fileId: file.fileId,
+                    versionId: file.versionId,
                 });
             }
         }

package/dist/formats/json/mergeJson.js

@@ -5,6 +5,7 @@ import { findMatchingItemArray, findMatchingItemObject, generateSourceObjectPoin
 import { JSONPath } from 'jsonpath-plus';
 import { getLocaleProperties } from 'generaltranslation';
 import { replaceLocalePlaceholders } from '../utils.js';
+import { gt } from '../../utils/gt.js';
 export function mergeJson(originalContent, inputPath, options, targets, defaultLocale, localeOrder = []) {
     const jsonSchema = validateJsonSchema(options, inputPath);
     if (!jsonSchema) {
@@ -18,6 +19,13 @@ export function mergeJson(originalContent, inputPath, options, targets, defaultL
         logger.error(`Invalid JSON file: ${inputPath}`);
         return exitSync(1);
     }
+    const useCanonicalLocaleKeys = options?.experimentalCanonicalLocaleKeys ?? false;
+    const canonicalDefaultLocale = useCanonicalLocaleKeys
+        ? gt.resolveCanonicalLocale(defaultLocale)
+        : defaultLocale;
+    const canonicalLocaleOrder = useCanonicalLocaleKeys
+        ? localeOrder.map((locale) => gt.resolveCanonicalLocale(locale))
+        : localeOrder;
     // Handle include
     if (jsonSchema.include) {
         const output = [];
@@ -59,7 +67,7 @@ export function mergeJson(originalContent, inputPath, options, targets, defaultL
                 return exitSync(1);
             }
             // Get source item for default locale
-            const matchingDefaultLocaleItems = findMatchingItemArray(defaultLocale, sourceObjectOptions, sourceObjectPointer, sourceObjectValue);
+            const matchingDefaultLocaleItems = findMatchingItemArray(canonicalDefaultLocale, sourceObjectOptions, sourceObjectPointer, sourceObjectValue);
             if (!Object.keys(matchingDefaultLocaleItems).length) {
                 logger.warn(`Matching sourceItems not found at path: ${sourceObjectPointer}. Please check your JSON file includes the key field. Skipping this target`);
                 continue;
@@ -88,7 +96,9 @@ export function mergeJson(originalContent, inputPath, options, targets, defaultL
                     targetItems = {};
                 }
                 // 2. Track all array indecies to remove (will be overwritten)
-                const targetItemsToRemove = findMatchingItemArray(target.targetLocale, sourceObjectOptions, sourceObjectPointer, sourceObjectValue);
+                const targetItemsToRemove = findMatchingItemArray(useCanonicalLocaleKeys
+                    ? gt.resolveCanonicalLocale(target.targetLocale)
+                    : target.targetLocale, sourceObjectOptions, sourceObjectPointer, sourceObjectValue);
                 Object.values(targetItemsToRemove).forEach(({ index }) => indiciesToRemove.add(index));
                 // 3. Merge matchingDefaultLocaleItems and targetItems
                 const mergedItems = {
@@ -110,14 +120,21 @@ export function mergeJson(originalContent, inputPath, options, targets, defaultL
                     const defaultLocaleSourceItem = matchingDefaultLocaleItems[sourceItemPointer].sourceItem;
                     const defaultLocaleKeyPointer = matchingDefaultLocaleItems[sourceItemPointer].keyPointer;
                     const mutatedSourceItem = structuredClone(defaultLocaleSourceItem);
-                    const { identifyingLocaleProperty: targetLocaleKeyProperty } = getSourceObjectOptionsArray(target.targetLocale, sourceObjectPointer, sourceObjectOptions);
+                    const { identifyingLocaleProperty: targetLocaleKeyProperty } = getSourceObjectOptionsArray(useCanonicalLocaleKeys
+                        ? gt.resolveCanonicalLocale(target.targetLocale)
+                        : target.targetLocale, sourceObjectPointer, sourceObjectOptions);
                     JSONPointer.set(mutatedSourceItem, defaultLocaleKeyPointer, targetLocaleKeyProperty);
                     for (const [translatedKeyJsonPointer, translatedValue,] of Object.entries(targetItem || {})) {
+                        const valueToSet = useCanonicalLocaleKeys &&
+                            defaultLocaleKeyPointer &&
+                            translatedKeyJsonPointer === defaultLocaleKeyPointer
+                            ? targetLocaleKeyProperty
+                            : translatedValue;
                         try {
                             const value = JSONPointer.get(mutatedSourceItem, translatedKeyJsonPointer);
                             if (!value)
                                 continue;
-                            JSONPointer.set(mutatedSourceItem, translatedKeyJsonPointer, translatedValue);
+                            JSONPointer.set(mutatedSourceItem, translatedKeyJsonPointer, valueToSet);
                         }
                         catch {
                             /* empty */
@@ -137,7 +154,7 @@ export function mergeJson(originalContent, inputPath, options, targets, defaultL
             const filteredSourceObjectValue = sourceObjectValue.filter((_, index) => !indiciesToRemove.has(index));
             // 10. Add all items to the original JSON
             filteredSourceObjectValue.push(...itemsToAdd);
-            JSONPointer.set(mergedJson, sourceObjectPointer, sortByLocaleOrder(filteredSourceObjectValue, sourceObjectOptions, localeOrder, sourceObjectPointer, defaultLocale));
+            JSONPointer.set(mergedJson, sourceObjectPointer, sortByLocaleOrder(filteredSourceObjectValue, sourceObjectOptions, canonicalLocaleOrder, sourceObjectPointer, canonicalDefaultLocale));
         }
         else {
             // Validate type
@@ -146,7 +163,7 @@ export function mergeJson(originalContent, inputPath, options, targets, defaultL
                 return exitSync(1);
             }
             // Validate localeProperty
-            const matchingDefaultLocaleItem = findMatchingItemObject(defaultLocale, sourceObjectPointer, sourceObjectOptions, sourceObjectValue);
+            const matchingDefaultLocaleItem = findMatchingItemObject(canonicalDefaultLocale, sourceObjectPointer, sourceObjectOptions, sourceObjectValue);
             // Validate source item exists
             if (!matchingDefaultLocaleItem.sourceItem) {
                 logger.error(`Source item not found at path: ${sourceObjectPointer}. You must specify a source item where its key matches the default locale`);
@@ -169,7 +186,9 @@ export function mergeJson(originalContent, inputPath, options, targets, defaultL
                     targetItems = {};
                 }
                 // 2. Find the source item for the target locale
-                const matchingTargetItem = findMatchingItemObject(target.targetLocale, sourceObjectPointer, sourceObjectOptions, sourceObjectValue);
+                const matchingTargetItem = findMatchingItemObject(useCanonicalLocaleKeys
+                    ? gt.resolveCanonicalLocale(target.targetLocale)
+                    : target.targetLocale, sourceObjectPointer, sourceObjectOptions, sourceObjectValue);
                 // If the target locale has a matching source item, use it to mutate the source item
                 // Otherwise, fallback to the default locale source item
                 const mutateSourceItem = structuredClone(defaultLocaleSourceItem);

package/dist/generated/version.d.ts

@@ -1 +1 @@
-export declare const PACKAGE_VERSION = "2.5.36";
+export declare const PACKAGE_VERSION = "2.5.37";

package/dist/generated/version.js

@@ -1,2 +1,2 @@
 // This file is auto-generated. Do not edit manually.
-export const PACKAGE_VERSION = '2.5.36';
+export const PACKAGE_VERSION = '2.5.37';

package/dist/types/index.d.ts

@@ -186,6 +186,7 @@ export type AdditionalOptions = {
         match: string;
         replace: string;
     }>;
+    experimentalCanonicalLocaleKeys?: boolean;
 };
 export type SharedStaticAssetsConfig = {
     include: string | string[];

package/dist/workflow/{UploadStep.d.ts → UploadSourcesStep.d.ts}

@@ -4,7 +4,7 @@ import { GT } from 'generaltranslation';
 import { Settings } from '../types/index.js';
 import { BranchData } from '../types/branch.js';
 import type { FileReference } from 'generaltranslation/types';
-export declare class UploadStep extends WorkflowStep<{
+export declare class UploadSourcesStep extends WorkflowStep<{
     files: FileToUpload[];
     branchData: BranchData;
 }, FileReference[]> {

package/dist/workflow/{UploadStep.js → UploadSourcesStep.js}

@@ -1,7 +1,7 @@
 import { WorkflowStep } from './Workflow.js';
 import { logger } from '../console/logger.js';
 import chalk from 'chalk';
-export class UploadStep extends WorkflowStep {
+export class UploadSourcesStep extends WorkflowStep {
     gt;
     settings;
     spinner = logger.createSpinner('dots');
@@ -62,6 +62,7 @@ export class UploadStep extends WorkflowStep {
             fileName: f.fileName,
             fileFormat: f.fileFormat,
             dataFormat: f.dataFormat,
+            locale: f.locale,
         })));
         this.spinner.stop(chalk.green('Files uploaded successfully'));
         return this.result;

package/dist/workflow/UploadTranslationsStep.d.ts

@@ -0,0 +1,22 @@
+import { WorkflowStep } from './Workflow.js';
+import { GT } from 'generaltranslation';
+import { Settings } from '../types/index.js';
+import { BranchData } from '../types/branch.js';
+import type { FileReference, FileToUpload } from 'generaltranslation/types';
+type UploadTranslationsInput = {
+    files: {
+        source: FileToUpload;
+        translations: FileToUpload[];
+    }[];
+    branchData: BranchData;
+};
+export declare class UploadTranslationsStep extends WorkflowStep<UploadTranslationsInput, FileReference[]> {
+    private gt;
+    private settings;
+    private spinner;
+    private result;
+    constructor(gt: GT, settings: Settings);
+    run({ files, branchData, }: UploadTranslationsInput): Promise<FileReference[]>;
+    wait(): Promise<void>;
+}
+export {};

package/dist/workflow/UploadTranslationsStep.js

@@ -0,0 +1,71 @@
+import { WorkflowStep } from './Workflow.js';
+import { logger } from '../console/logger.js';
+import chalk from 'chalk';
+export class UploadTranslationsStep extends WorkflowStep {
+    gt;
+    settings;
+    spinner = logger.createSpinner('dots');
+    result = [];
+    constructor(gt, settings) {
+        super();
+        this.gt = gt;
+        this.settings = settings;
+    }
+    async run({ files, branchData, }) {
+        // Filter to only files that have translations
+        const filesWithTranslations = files.filter((f) => f.translations.length > 0);
+        if (filesWithTranslations.length === 0) {
+            logger.info('No translation files to upload... skipping upload translations step');
+            return [];
+        }
+        const totalTranslations = filesWithTranslations.reduce((acc, f) => acc + f.translations.length, 0);
+        this.spinner.start(`Syncing ${totalTranslations} translation file${totalTranslations !== 1 ? 's' : ''} with General Translation API...`);
+        // Build the query for existing translation files
+        const translatedFilesQuery = filesWithTranslations.flatMap((f) => f.translations.map((t) => ({
+            fileId: t.fileId,
+            versionId: t.versionId,
+            branchId: t.branchId ?? branchData.currentBranch.id,
+            locale: t.locale,
+        })));
+        // Query for existing translation files
+        const fileData = await this.gt.queryFileData({
+            translatedFiles: translatedFilesQuery,
+        });
+        // Build a map of existing translations: branchId:fileId:versionId:locale
+        const existingTranslationsMap = new Set();
+        fileData.translatedFiles?.forEach((f) => {
+            existingTranslationsMap.add(`${f.branchId}:${f.fileId}:${f.versionId}:${f.locale}`);
+        });
+        // Filter out translations that already exist
+        const filesToUpload = filesWithTranslations
+            .map((f) => {
+            const newTranslations = f.translations.filter((t) => {
+                const branchId = t.branchId ?? branchData.currentBranch.id;
+                const key = `${branchId}:${t.fileId}:${t.versionId}:${t.locale}`;
+                return !existingTranslationsMap.has(key);
+            });
+            return {
+                source: f.source,
+                translations: newTranslations,
+            };
+        })
+            .filter((f) => f.translations.length > 0);
+        const skippedCount = totalTranslations -
+            filesToUpload.reduce((acc, f) => acc + f.translations.length, 0);
+        if (filesToUpload.length === 0) {
+            this.spinner.stop(chalk.green(`All ${totalTranslations} translation files already uploaded`));
+            return [];
+        }
+        const uploadCount = filesToUpload.reduce((acc, f) => acc + f.translations.length, 0);
+        const response = await this.gt.uploadTranslations(filesToUpload, {
+            sourceLocale: this.settings.defaultLocale,
+            modelProvider: this.settings.modelProvider,
+        });
+        this.result = response.uploadedFiles;
+        this.spinner.stop(chalk.green(`Translation files synced successfully! Uploaded: (${uploadCount}), Skipped: (${skippedCount})`));
+        return this.result;
+    }
+    async wait() {
+        return;
+    }
+}

package/dist/workflow/setupProject.js

@@ -1,6 +1,6 @@
 import { logErrorAndExit } from '../console/logging.js';
 import { gt } from '../utils/gt.js';
-import { UploadStep } from './UploadStep.js';
+import { UploadSourcesStep } from './UploadSourcesStep.js';
 import { SetupStep } from './SetupStep.js';
 import { BranchStep } from './BranchStep.js';
 import { logCollectedFiles } from '../console/logging.js';
@@ -26,7 +26,7 @@ export async function setupProject(files, options, settings) {
         const timeoutMs = calculateTimeout(options.timeout);
         // Create workflow with steps
         const branchStep = new BranchStep(gt, settings);
-        const uploadStep = new UploadStep(gt, settings);
+        const uploadStep = new UploadSourcesStep(gt, settings);
         const setupStep = new SetupStep(gt, settings, timeoutMs);
         // first run the branch step
         const branchData = await branchStep.run();

package/dist/workflow/stage.js

@@ -1,6 +1,6 @@
 import { logCollectedFiles, logErrorAndExit } from '../console/logging.js';
 import { gt } from '../utils/gt.js';
-import { UploadStep } from './UploadStep.js';
+import { UploadSourcesStep } from './UploadSourcesStep.js';
 import { SetupStep } from './SetupStep.js';
 import { EnqueueStep } from './EnqueueStep.js';
 import { BranchStep } from './BranchStep.js';
@@ -27,7 +27,7 @@ export async function stageFiles(files, options, settings) {
         const timeoutMs = calculateTimeout(options.timeout);
         // Create workflow with steps
         const branchStep = new BranchStep(gt, settings);
-        const uploadStep = new UploadStep(gt, settings);
+        const uploadStep = new UploadSourcesStep(gt, settings);
         const userEditDiffsStep = new UserEditDiffsStep(settings);
         const setupStep = new SetupStep(gt, settings, timeoutMs);
         const enqueueStep = new EnqueueStep(gt, settings, options.force);

package/dist/workflow/upload.d.ts

@@ -0,0 +1,12 @@
+import { Settings } from '../types/index.js';
+import type { FileToUpload } from 'generaltranslation/types';
+/**
+ * Uploads multiple files to the API using a workflow pattern
+ * @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: FileToUpload;
+    translations: FileToUpload[];
+}[], options: Settings): Promise<undefined>;

package/dist/workflow/upload.js

@@ -0,0 +1,47 @@
+import chalk from 'chalk';
+import { logger } from '../console/logger.js';
+import { logErrorAndExit } from '../console/logging.js';
+import { gt } from '../utils/gt.js';
+import { BranchStep } from './BranchStep.js';
+import { UploadSourcesStep } from './UploadSourcesStep.js';
+import { UploadTranslationsStep } from './UploadTranslationsStep.js';
+/**
+ * Uploads multiple files to the API using a workflow pattern
+ * @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) {
+    try {
+        logger.message(chalk.cyan('Files to upload:') +
+            '\n' +
+            files
+                .map((file) => `  - ${chalk.bold(file.source.fileName)}${file.translations.length > 0 ? ` -> ${file.translations.map((t) => t.locale).join(', ')}` : ''}`)
+                .join('\n'));
+        // Create workflow steps
+        const branchStep = new BranchStep(gt, options);
+        const uploadStep = new UploadSourcesStep(gt, options);
+        const uploadTranslationsStep = new UploadTranslationsStep(gt, options);
+        // Step 1: Resolve branch information
+        const branchData = await branchStep.run();
+        await branchStep.wait();
+        if (!branchData) {
+            return logErrorAndExit('Failed to resolve git branch information.');
+        }
+        await uploadStep.run({ files: files.map((f) => f.source), branchData });
+        await uploadStep.wait();
+        // Step 3: Upload translations (if any exist)
+        const filesWithTranslations = files.filter((f) => f.translations.length > 0);
+        if (filesWithTranslations.length > 0) {
+            await uploadTranslationsStep.run({
+                files: filesWithTranslations,
+                branchData,
+            });
+            await uploadTranslationsStep.wait();
+        }
+        logger.success('All files uploaded successfully');
+    }
+    catch (error) {
+        return logErrorAndExit('Failed to upload files. ' + error);
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gtx-cli",
-  "version": "2.5.36",
+  "version": "2.5.37",
   "main": "dist/index.js",
   "bin": "dist/main.js",
   "files": [
@@ -106,7 +106,7 @@
     "unified": "^11.0.5",
     "unist-util-visit": "^5.0.0",
     "yaml": "^2.8.0",
-    "generaltranslation": "8.1.4"
+    "generaltranslation": "8.1.5"
   },
   "devDependencies": {
     "@babel/types": "^7.28.4",

package/dist/api/uploadFiles.d.ts

@@ -1,27 +0,0 @@
-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;
-    modelProvider?: 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<undefined>;

package/dist/api/uploadFiles.js

@@ -1,41 +0,0 @@
-import chalk from 'chalk';
-import { logger } from '../console/logger.js';
-import { exitSync } from '../console/logging.js';
-import { gt } from '../utils/gt.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) {
-    logger.message(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 = logger.createSpinner('dots');
-    spinner.start(`Uploading ${files.length} file${files.length !== 1 ? 's' : ''} to General Translation...`);
-    try {
-        // Upload sources
-        await gt.uploadSourceFiles(files, {
-            ...options,
-            sourceLocale: options.defaultLocale,
-        });
-        // Upload translations (if any exist)
-        const withTranslations = files.filter((f) => f.translations.length > 0);
-        if (withTranslations.length > 0) {
-            await gt.uploadTranslations(withTranslations, {
-                ...options,
-                sourceLocale: options.defaultLocale, // optional, safe to include
-            });
-        }
-        spinner.stop(chalk.green('Files uploaded successfully'));
-    }
-    catch {
-        spinner.stop(chalk.red('An unexpected error occurred while uploading files'));
-        return exitSync(1);
-    }
-}