gtx-cli 2.3.5 → 2.3.6-alpha.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gtx-cli",
-  "version": "2.3.5",
+  "version": "2.3.6-alpha.1",
   "main": "dist/index.js",
   "bin": "dist/main.js",
   "files": [
@@ -8,19 +8,6 @@
     "CHANGELOG.md"
   ],
   "type": "module",
-  "scripts": {
-    "build": "tsc",
-    "build:clean": "rm -rf dist; npm run build",
-    "build:release": "npm run build:clean",
-    "lint": "eslint \"src/**/*.{js,ts}\" \"./**/__tests__/**/*.{js,ts}\"",
-    "lint:fix": "eslint \"src/**/*.{js,ts}\" \"./**/__tests__/**/*.{js,ts}\" --fix",
-    "test": "vitest run --config=./vitest.config.ts",
-    "test:watch": "vitest --config=./vitest.config.ts",
-    "release": "npm run build:clean && npm publish",
-    "release:alpha": "npm run build:clean && npm publish --tag alpha",
-    "release:beta": "npm run build:clean && npm publish --tag beta",
-    "release:latest": "npm run build:clean && npm publish --tag latest"
-  },
   "exports": {
     ".": {
       "import": "./dist/index.js"
@@ -87,7 +74,6 @@
     "esbuild": "^0.25.4",
     "fast-glob": "^3.3.3",
     "form-data": "^4.0.4",
-    "generaltranslation": "^7.6.2",
     "gt-remark": "^1.0.1",
     "json-pointer": "^0.6.2",
     "jsonpath-plus": "^10.3.0",
@@ -104,22 +90,41 @@
     "tsconfig-paths": "^4.2.0",
     "unified": "^11.0.5",
     "unist-util-visit": "^5.0.0",
-    "yaml": "^2.8.0"
+    "yaml": "^2.8.0",
+    "generaltranslation": "7.6.4-alpha.1"
   },
   "devDependencies": {
+    "@babel/types": "^7.28.4",
     "@biomejs/biome": "^1.9.4",
     "@types/babel__generator": "^7.27.0",
     "@types/babel__traverse": "^7.20.6",
     "@types/figlet": "^1.7.0",
+    "@types/mdast": "^4.0.0",
+    "@types/micromatch": "^4.0.9",
     "@types/mock-require": "^2.0.3",
     "@types/node": "^22.5.1",
     "@types/react": "^18.3.4",
     "@types/resolve": "^1.20.2",
     "eslint": "^9.20.0",
     "esm": "^3.2.25",
-    "mdast": "^3.0.0",
+    "mdast-util-mdx-jsx": "^3.2.0",
+    "mdast-util-mdxjs-esm": "^2.0.1",
     "prettier": "^3.4.2",
     "ts-node": "^10.9.2",
+    "tslib": "^2.8.1",
     "typescript": "^5.5.4"
+  },
+  "scripts": {
+    "build": "tsc",
+    "build:clean": "rm -rf dist; pnpm run build",
+    "build:release": "pnpm run build:clean",
+    "lint": "eslint \"src/**/*.{js,ts}\" \"./**/__tests__/**/*.{js,ts}\"",
+    "lint:fix": "eslint \"src/**/*.{js,ts}\" \"./**/__tests__/**/*.{js,ts}\" --fix",
+    "test": "vitest run --config=./vitest.config.ts",
+    "test:watch": "vitest --config=./vitest.config.ts",
+    "release": "pnpm run build:clean && pnpm publish",
+    "release:alpha": "pnpm run build:clean && pnpm publish --tag alpha",
+    "release:beta": "pnpm run build:clean && pnpm publish --tag beta",
+    "release:latest": "pnpm run build:clean && pnpm publish --tag latest"
   }
-}
+}

package/dist/api/checkFileTranslations.d.ts

@@ -1,23 +0,0 @@
-import { Settings } from '../types/index.js';
-export type CheckFileTranslationData = {
-    [key: string]: {
-        versionId: string;
-        fileName: string;
-    };
-};
-/**
- * Checks the status of translations for a given version ID
- * @param apiKey - The API key for the General Translation API
- * @param baseUrl - The base URL for 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 in seconds
- * @returns True if all translations are deployed, false otherwise
- */
-export declare function checkFileTranslations(data: {
-    [key: string]: {
-        versionId: string;
-        fileName: string;
-    };
-}, locales: string[], timeoutDuration: number, resolveOutputPath: (sourcePath: string, locale: string) => string | null, options: Settings, forceRetranslation?: boolean): Promise<boolean>;

package/dist/api/checkFileTranslations.js

@@ -1,236 +0,0 @@
-import chalk from 'chalk';
-import { createOraSpinner, logError } from '../console/logging.js';
-import { getLocaleProperties } from 'generaltranslation';
-import { downloadFileBatch } from './downloadFileBatch.js';
-import { gt } from '../utils/gt.js';
-import { TEMPLATE_FILE_NAME } from '../cli/commands/stage.js';
-/**
- * Checks the status of translations for a given version ID
- * @param apiKey - The API key for the General Translation API
- * @param baseUrl - The base URL for 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 in seconds
- * @returns True if all translations are deployed, false otherwise
- */
-export async function checkFileTranslations(data, locales, timeoutDuration, resolveOutputPath, options, forceRetranslation) {
-    const startTime = Date.now();
-    console.log();
-    const spinner = await createOraSpinner();
-    const spinnerMessage = forceRetranslation
-        ? 'Waiting for retranslation...'
-        : 'Waiting for translation...';
-    spinner.start(spinnerMessage);
-    // Initialize the query data
-    const fileQueryData = prepareFileQueryData(data, locales);
-    const downloadStatus = {
-        downloaded: new Set(),
-        failed: new Set(),
-        skipped: new Set(),
-    };
-    // Do first check immediately, but skip if force retranslation is enabled
-    if (!forceRetranslation) {
-        const initialCheck = await checkTranslationDeployment(fileQueryData, downloadStatus, spinner, resolveOutputPath, options);
-        if (initialCheck) {
-            spinner.succeed(chalk.green('Files translated!'));
-            return true;
-        }
-    }
-    // Calculate time until next 5-second interval since startTime
-    const msUntilNextInterval = Math.max(0, 5000 - ((Date.now() - startTime) % 5000));
-    return new Promise((resolve) => {
-        let intervalCheck;
-        // Start the interval aligned with the original request time
-        setTimeout(() => {
-            intervalCheck = setInterval(async () => {
-                const isDeployed = await checkTranslationDeployment(fileQueryData, downloadStatus, spinner, resolveOutputPath, options);
-                const elapsed = Date.now() - startTime;
-                if (isDeployed || elapsed >= timeoutDuration * 1000) {
-                    clearInterval(intervalCheck);
-                    if (isDeployed) {
-                        spinner.succeed(chalk.green('All files translated!'));
-                        resolve(true);
-                    }
-                    else {
-                        spinner.fail(chalk.red('Timed out waiting for translations'));
-                        resolve(false);
-                    }
-                }
-            }, 5000);
-        }, msUntilNextInterval);
-    });
-}
-/**
- * Prepares the file query data from input data and locales
- */
-function prepareFileQueryData(data, locales) {
-    const fileQueryData = [];
-    for (const file in data) {
-        for (const locale of locales) {
-            fileQueryData.push({
-                versionId: data[file].versionId,
-                fileName: data[file].fileName,
-                locale,
-            });
-        }
-    }
-    return fileQueryData;
-}
-/**
- * Generates a formatted status text showing translation progress
- * @param downloadedFiles - Set of downloaded file+locale combinations
- * @param fileQueryData - Array of file query data objects
- * @returns Formatted status text
- */
-function generateStatusSuffixText(downloadStatus, fileQueryData) {
-    // Simple progress indicator
-    const progressText = chalk.green(`[${downloadStatus.downloaded.size + downloadStatus.failed.size}/${fileQueryData.length}]`) + ` translations completed`;
-    // Get terminal height to adapt our output
-    const terminalHeight = process.stdout.rows || 24; // Default to 24 if undefined
-    // If terminal is very small, just show the basic progress
-    if (terminalHeight < 6) {
-        return `${progressText}`;
-    }
-    const newSuffixText = [`${progressText}`];
-    // Organize data by filename
-    const fileStatus = new Map();
-    // Initialize with all files and locales from fileQueryData
-    for (const item of fileQueryData) {
-        if (!fileStatus.has(item.fileName)) {
-            fileStatus.set(item.fileName, {
-                completed: new Set(),
-                pending: new Set([item.locale]),
-                failed: new Set(),
-            });
-        }
-        else {
-            fileStatus.get(item.fileName)?.pending.add(item.locale);
-        }
-    }
-    // Mark which ones are completed or failed
-    for (const fileLocale of downloadStatus.downloaded) {
-        const [fileName, locale] = fileLocale.split(':');
-        const status = fileStatus.get(fileName);
-        if (status) {
-            status.pending.delete(locale);
-            status.completed.add(locale);
-        }
-    }
-    for (const fileLocale of downloadStatus.failed) {
-        const [fileName, locale] = fileLocale.split(':');
-        const status = fileStatus.get(fileName);
-        if (status) {
-            status.pending.delete(locale);
-            status.failed.add(locale);
-        }
-    }
-    // Calculate how many files we can show based on terminal height
-    const filesArray = Array.from(fileStatus.entries());
-    const maxFilesToShow = Math.min(filesArray.length, terminalHeight - 3 // Header + progress + buffer
-    );
-    // Display each file with its status on a single line
-    for (let i = 0; i < maxFilesToShow; i++) {
-        const [fileName, status] = filesArray[i];
-        // Create condensed locale status
-        const localeStatuses = [];
-        // Add completed locales
-        if (status.completed.size > 0) {
-            const completedCodes = Array.from(status.completed)
-                .map((locale) => getLocaleProperties(locale).code)
-                .join(', ');
-            localeStatuses.push(chalk.green(`${completedCodes}`));
-        }
-        // Add failed locales
-        if (status.failed.size > 0) {
-            const failedCodes = Array.from(status.failed)
-                .map((locale) => getLocaleProperties(locale).code)
-                .join(', ');
-            localeStatuses.push(chalk.red(`${failedCodes}`));
-        }
-        // Add pending locales
-        if (status.pending.size > 0) {
-            const pendingCodes = Array.from(status.pending)
-                .map((locale) => getLocaleProperties(locale).code)
-                .join(', ');
-            localeStatuses.push(chalk.yellow(`${pendingCodes}`));
-        }
-        // Format the line
-        const prettyFileName = fileName === TEMPLATE_FILE_NAME ? '<React Elements>' : fileName;
-        newSuffixText.push(`${chalk.bold(prettyFileName)} [${localeStatuses.join(', ')}]`);
-    }
-    // If we couldn't show all files, add an indicator
-    if (filesArray.length > maxFilesToShow) {
-        newSuffixText.push(`... and ${filesArray.length - maxFilesToShow} more files`);
-    }
-    return newSuffixText.join('\n');
-}
-/**
- * Checks translation status and downloads ready files
- */
-async function checkTranslationDeployment(fileQueryData, downloadStatus, spinner, resolveOutputPath, options) {
-    try {
-        // Only query for files that haven't been downloaded yet
-        const currentQueryData = fileQueryData.filter((item) => !downloadStatus.downloaded.has(`${item.fileName}:${item.locale}`) &&
-            !downloadStatus.failed.has(`${item.fileName}:${item.locale}`) &&
-            !downloadStatus.skipped.has(`${item.fileName}:${item.locale}`));
-        // If all files have been downloaded, we're done
-        if (currentQueryData.length === 0) {
-            return true;
-        }
-        // Check for translations
-        const responseData = await gt.checkFileTranslations(currentQueryData);
-        const translations = responseData.translations || [];
-        // Filter for ready translations
-        const readyTranslations = translations.filter((translation) => translation.isReady && translation.fileName);
-        if (readyTranslations.length > 0) {
-            // Prepare batch download data
-            const batchFiles = readyTranslations
-                .map((translation) => {
-                const locale = gt.resolveAliasLocale(translation.locale);
-                const fileName = translation.fileName;
-                const translationId = translation.id;
-                const outputPath = resolveOutputPath(fileName, locale);
-                // Skip downloading GTJSON files that are not in the files configuration
-                if (outputPath === null) {
-                    downloadStatus.skipped.add(`${fileName}:${locale}`);
-                    return null;
-                }
-                return {
-                    translationId,
-                    inputPath: fileName,
-                    outputPath,
-                    locale,
-                    fileLocale: `${fileName}:${locale}`,
-                };
-            })
-                .filter((file) => file !== null);
-            const batchResult = await downloadFileBatch(batchFiles, options);
-            // Process results
-            batchFiles.forEach((file) => {
-                const { translationId, fileLocale } = file;
-                if (batchResult.successful.includes(translationId)) {
-                    downloadStatus.downloaded.add(fileLocale);
-                }
-                else if (batchResult.failed.includes(translationId)) {
-                    downloadStatus.failed.add(fileLocale);
-                }
-            });
-        }
-        // Force a refresh of the spinner display
-        const statusText = generateStatusSuffixText(downloadStatus, fileQueryData);
-        // Clear and reapply the suffix to force a refresh
-        spinner.text = statusText;
-        // If all files have been downloaded, we're done
-        if (downloadStatus.downloaded.size +
-            downloadStatus.failed.size +
-            downloadStatus.skipped.size ===
-            fileQueryData.length) {
-            return true;
-        }
-    }
-    catch (error) {
-        logError(chalk.red('Error checking translation status: ') + error);
-    }
-    return false;
-}

package/dist/api/downloadFileBatch.d.ts

@@ -1,20 +0,0 @@
-import { Settings } from '../types/index.js';
-export type BatchedFiles = Array<{
-    translationId: string;
-    outputPath: string;
-    inputPath: string;
-    locale: string;
-    fileLocale: string;
-}>;
-export type DownloadFileBatchResult = {
-    successful: string[];
-    failed: string[];
-};
-/**
- * Downloads multiple translation files in a single batch request
- * @param files - Array of files to download with their output paths
- * @param maxRetries - Maximum number of retry attempts
- * @param retryDelay - Delay between retries in milliseconds
- * @returns Object containing successful and failed file IDs
- */
-export declare function downloadFileBatch(files: BatchedFiles, options: Settings, maxRetries?: number, retryDelay?: number): Promise<DownloadFileBatchResult>;

package/dist/api/downloadFileBatch.js

@@ -1,113 +0,0 @@
-import * as fs from 'fs';
-import * as path from 'path';
-import { logError, logWarning } from '../console/logging.js';
-import { gt } from '../utils/gt.js';
-import { validateJsonSchema } from '../formats/json/utils.js';
-import { validateYamlSchema } from '../formats/yaml/utils.js';
-import { mergeJson } from '../formats/json/mergeJson.js';
-import mergeYaml from '../formats/yaml/mergeYaml.js';
-/**
- * Downloads multiple translation files in a single batch request
- * @param files - Array of files to download with their output paths
- * @param maxRetries - Maximum number of retry attempts
- * @param retryDelay - Delay between retries in milliseconds
- * @returns Object containing successful and failed file IDs
- */
-export async function downloadFileBatch(files, options, maxRetries = 3, retryDelay = 1000) {
-    let retries = 0;
-    const fileIds = files.map((file) => file.translationId);
-    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,
-        gt.resolveAliasLocale(file.locale),
-    ]));
-    while (retries <= maxRetries) {
-        try {
-            // Download the files
-            const responseData = await gt.downloadFileBatch(fileIds);
-            const downloadedFiles = responseData.files || [];
-            // Process each file in the response
-            for (const file of downloadedFiles) {
-                try {
-                    const translationId = file.id;
-                    const outputPath = outputPathMap.get(translationId);
-                    const inputPath = inputPathMap.get(translationId);
-                    const locale = localeMap.get(translationId);
-                    if (!outputPath || !inputPath) {
-                        logWarning(`No input/output path found for file: ${translationId}`);
-                        result.failed.push(translationId);
-                        continue;
-                    }
-                    // Ensure the directory exists
-                    const dir = path.dirname(outputPath);
-                    if (!fs.existsSync(dir)) {
-                        fs.mkdirSync(dir, { recursive: true });
-                    }
-                    let data = file.data;
-                    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: file.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: file.data,
-                                        targetLocale: locale,
-                                    },
-                                ])[0];
-                            }
-                        }
-                    }
-                    // Write the file to disk
-                    await fs.promises.writeFile(outputPath, data);
-                    result.successful.push(translationId);
-                }
-                catch (error) {
-                    logError(`Error saving file ${file.id}: ` + error);
-                    result.failed.push(file.id);
-                }
-            }
-            // Add any files that weren't in the response to the failed list
-            const downloadedIds = new Set(downloadedFiles.map((file) => file.id));
-            for (const fileId of fileIds) {
-                if (!downloadedIds.has(fileId) && !result.failed.includes(fileId)) {
-                    result.failed.push(fileId);
-                }
-            }
-            return result;
-        }
-        catch (error) {
-            // If we've retried too many times, log an error and return false
-            if (retries >= maxRetries) {
-                logError(`Error downloading files in batch after ${maxRetries + 1} attempts: ` +
-                    error);
-                // Mark all files as failed
-                result.failed = [...fileIds];
-                return result;
-            }
-            // Increment retry counter and wait before next attempt
-            retries++;
-            await new Promise((resolve) => setTimeout(resolve, retryDelay));
-        }
-    }
-    // Mark all files as failed if we get here
-    result.failed = [...fileIds];
-    return result;
-}

package/dist/api/sendFiles.d.ts

@@ -1,17 +0,0 @@
-import { Settings, TranslateFlags } from '../types/index.js';
-import { CompletedFileTranslationData, FileToTranslate } from 'generaltranslation/types';
-export type SendFilesResult = {
-    data: Record<string, {
-        fileName: string;
-        versionId: string;
-    }>;
-    locales: string[];
-    translations: CompletedFileTranslationData[];
-};
-/**
- * Sends multiple files for translation to the API
- * @param files - Array of file objects to translate
- * @param options - The options for the API call
- * @returns The translated content or version ID
- */
-export declare function sendFiles(files: FileToTranslate[], options: TranslateFlags, settings: Settings): Promise<SendFilesResult>;

package/dist/api/sendFiles.js

@@ -1,115 +0,0 @@
-import chalk from 'chalk';
-import { createSpinner, logError, logMessage, logSuccess, } from '../console/logging.js';
-import { gt } from '../utils/gt.js';
-import { TEMPLATE_FILE_NAME } from '../cli/commands/stage.js';
-/**
- * Sends multiple files for translation to the API
- * @param files - Array of file objects to translate
- * @param options - The options for the API call
- * @returns The translated content or version ID
- */
-export async function sendFiles(files, options, settings) {
-    // Keep track of the most recent spinner so we can stop it on error
-    let currentSpinner = null;
-    logMessage(chalk.cyan('Files to translate:') +
-        '\n' +
-        files
-            .map((file) => {
-            if (file.fileName === TEMPLATE_FILE_NAME) {
-                return `- <React Elements>`;
-            }
-            return `- ${file.fileName}`;
-        })
-            .join('\n'));
-    try {
-        // Step 1: Upload files (get references)
-        const uploadSpinner = createSpinner('dots');
-        currentSpinner = uploadSpinner;
-        uploadSpinner.start(`Uploading ${files.length} file${files.length !== 1 ? 's' : ''} to General Translation API...`);
-        const sourceLocale = settings.defaultLocale;
-        if (!sourceLocale) {
-            uploadSpinner.stop(chalk.red('Missing default source locale'));
-            throw new Error('sendFiles: settings.defaultLocale is required to upload source files');
-        }
-        // Convert FileToTranslate[] -> { source: FileUpload }[]
-        const uploads = files.map(({ content, fileName, fileFormat, dataFormat }) => ({
-            source: {
-                content,
-                fileName,
-                fileFormat,
-                dataFormat,
-                locale: sourceLocale,
-            },
-        }));
-        const upload = await gt.uploadSourceFiles(uploads, {
-            sourceLocale,
-            modelProvider: settings.modelProvider,
-        });
-        uploadSpinner.stop(chalk.green('Files uploaded successfully'));
-        // Check if setup is needed
-        const setupDecision = await Promise.resolve(gt.shouldSetupProject?.())
-            .then((v) => v)
-            .catch(() => ({ shouldSetupProject: false }));
-        const shouldSetupProject = Boolean(setupDecision?.shouldSetupProject);
-        // Step 2: Setup if needed and poll until complete
-        if (shouldSetupProject) {
-            // Calculate timeout once for setup fetching
-            // Accept number or numeric string, default to 600s
-            const timeoutVal = options?.timeout !== undefined ? Number(options.timeout) : 600;
-            const setupTimeoutMs = (Number.isFinite(timeoutVal) ? timeoutVal : 600) * 1000;
-            const { setupJobId } = await gt.setupProject(upload.uploadedFiles);
-            const setupSpinner = createSpinner('dots');
-            currentSpinner = setupSpinner;
-            setupSpinner.start('Setting up project...');
-            const start = Date.now();
-            const pollInterval = 2000;
-            let setupCompleted = false;
-            let setupFailedMessage = null;
-            while (true) {
-                const status = await gt.checkSetupStatus(setupJobId);
-                if (status.status === 'completed') {
-                    setupCompleted = true;
-                    break;
-                }
-                if (status.status === 'failed') {
-                    setupFailedMessage = status.error?.message || 'Unknown error';
-                    break;
-                }
-                if (Date.now() - start > setupTimeoutMs) {
-                    setupFailedMessage = 'Timed out while waiting for setup generation';
-                    break;
-                }
-                await new Promise((r) => setTimeout(r, pollInterval));
-            }
-            if (setupCompleted) {
-                setupSpinner.stop(chalk.green('Setup successfully completed'));
-            }
-            else {
-                setupSpinner.stop(chalk.yellow(`Setup ${setupFailedMessage ? 'failed' : 'timed out'} — proceeding without setup${setupFailedMessage ? ` (${setupFailedMessage})` : ''}`));
-            }
-        }
-        // Step 3: Enqueue translations by reference
-        const enqueueSpinner = createSpinner('dots');
-        currentSpinner = enqueueSpinner;
-        enqueueSpinner.start('Enqueuing translations...');
-        const enqueueResult = await gt.enqueueFiles(upload.uploadedFiles, {
-            sourceLocale: settings.defaultLocale,
-            targetLocales: settings.locales,
-            publish: settings.publish,
-            requireApproval: settings.stageTranslations,
-            modelProvider: settings.modelProvider,
-            force: options?.force,
-        });
-        const { data, message, locales, translations } = enqueueResult;
-        enqueueSpinner.stop(chalk.green('Files for translation uploaded successfully'));
-        logSuccess(message);
-        return { data, locales, translations };
-    }
-    catch (error) {
-        if (currentSpinner) {
-            currentSpinner.stop(chalk.red('Failed to send files for translation'));
-        }
-        logError('Failed to send files for translation');
-        throw error;
-    }
-}

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<void>;

package/dist/api/uploadFiles.js

@@ -1,40 +0,0 @@
-import chalk from 'chalk';
-import { createSpinner, exit, logMessage } 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) {
-    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...`);
-    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'));
-        exit(1);
-    }
-}