gtx-cli 2.1.5 → 2.1.6

package/dist/cli/flags.js

@@ -0,0 +1,37 @@
+import findFilepath from '../fs/findFilepath.js';
+const DEFAULT_TIMEOUT = 600;
+export function attachTranslateFlags(command) {
+    command
+        .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>', 'General Translation project ID')
+        .option('--version-id <id>', 'General Translation version ID')
+        .option('--default-language, --default-locale <locale>', 'Default locale (e.g., en)')
+        .option('--new, --locales <locales...>', 'Space-separated list of locales (e.g., en fr es)')
+        .option('--dry-run', 'Dry run, do not send updates to the General Translation API', false)
+        .option('--timeout <seconds>', 'Translation wait timeout in seconds', (value) => {
+        const parsedValue = parseInt(value, 10);
+        if (isNaN(parsedValue)) {
+            throw new Error('Not a number.');
+        }
+        if (parsedValue < 0) {
+            throw new Error('Timeout must be a positive number.');
+        }
+        return parsedValue;
+    }, DEFAULT_TIMEOUT)
+        .option('--publish', 'Publish translations to the CDN', false)
+        .option('--experimental-localize-static-urls', 'Triggering this will run a script after the cli tool that localizes all urls in content files. Currently only supported for md and mdx files.', false)
+        .option('--experimental-hide-default-locale', 'When localizing static locales, hide the default locale from the path', false)
+        .option('--experimental-flatten-json-files', 'Triggering this will flatten the json files into a single file. This is useful for projects that have a lot of json files.', false)
+        .option('--experimental-localize-static-imports', 'Triggering this will run a script after the cli tool that localizes all static imports in content files. Currently only supported for md and mdx files.', false);
+    return command;
+}
+export function attachAdditionalReactTranslateFlags(command) {
+    command
+        .option('--tsconfig, --jsconfig <path>', 'Path to custom jsconfig or tsconfig file', findFilepath(['./tsconfig.json', './jsconfig.json']))
+        .option('--dictionary <path>', 'Path to dictionary file')
+        .option('--src <paths...>', "Space-separated list of glob patterns containing the app's source code, by default 'src/**/*.{js,jsx,ts,tsx}' 'app/**/*.{js,jsx,ts,tsx}' 'pages/**/*.{js,jsx,ts,tsx}' 'components/**/*.{js,jsx,ts,tsx}'")
+        .option('--inline', 'Include inline <T> tags in addition to dictionary file', true)
+        .option('--ignore-errors', 'Ignore errors encountered while scanning for <T> tags', false);
+    return command;
+}

package/dist/cli/next.js

@@ -8,7 +8,6 @@ export class NextCLI extends ReactCLI {
     init() {
         this.setupStageCommand();
         this.setupTranslateCommand();
-        this.setupScanCommand();
         this.setupGenerateSourceCommand();
         this.setupValidateCommand();
     }

package/dist/cli/react.d.ts

@@ -1,5 +1,5 @@
 import { Command } from 'commander';
-import { Options, SupportedFrameworks, WrapOptions, GenerateSourceOptions, SupportedLibraries } from '../types/index.js';
+import { Options, SupportedFrameworks, WrapOptions, SupportedLibraries, TranslateFlags } from '../types/index.js';
 import { BaseCLI } from './base.js';
 export declare class ReactCLI extends BaseCLI {
     constructor(command: Command, library: 'gt-react' | 'gt-next', additionalModules?: SupportedLibraries[]);
@@ -12,10 +12,7 @@ export declare class ReactCLI extends BaseCLI {
     protected setupTranslateCommand(): void;
     protected setupValidateCommand(): void;
     protected setupGenerateSourceCommand(): void;
-    protected setupScanCommand(): void;
-    protected handleGenerateSourceCommand(initOptions: GenerateSourceOptions): Promise<void>;
+    protected handleGenerateSourceCommand(initOptions: TranslateFlags): Promise<void>;
     protected handleScanCommand(options: WrapOptions): Promise<void>;
-    protected handleStage(initOptions: Options): Promise<void>;
-    protected handleTranslate(initOptions: Options): Promise<void>;
     protected handleValidate(initOptions: Options, files?: string[]): Promise<void>;
 }

package/dist/cli/react.js

@@ -1,4 +1,4 @@
-import { displayHeader, endCommand, logError, logErrorAndExit, logStep, logSuccess, logWarning, promptConfirm, } from '../console/logging.js';
+import { displayHeader, endCommand, logError, logStep, logSuccess, logWarning, promptConfirm, } from '../console/logging.js';
 import loadJSON from '../fs/loadJSON.js';
 import findFilepath from '../fs/findFilepath.js';
 import chalk from 'chalk';
@@ -8,15 +8,12 @@ import { wrapContentReact } from '../react/parse/wrapContent.js';
 import { generateSettings } from '../config/generateSettings.js';
 import { saveJSON } from '../fs/saveJSON.js';
 import { resolveLocaleFiles } from '../fs/config/parseFilesConfig.js';
-import { noFilesError, noVersionIdError } from '../console/index.js';
-import { stageProject } from '../translation/stage.js';
-import { createUpdates } from '../translation/parse.js';
-import { translate } from '../translation/translate.js';
-import updateConfig from '../fs/config/updateConfig.js';
+import { noFilesError } from '../console/index.js';
+import { aggregateReactTranslations } from '../translation/stage.js';
 import { validateConfigExists } from '../config/validateSettings.js';
 import { validateProject } from '../translation/validate.js';
 import { intro } from '@clack/prompts';
-const DEFAULT_TIMEOUT = 600;
+import { attachAdditionalReactTranslateFlags, attachTranslateFlags, } from './flags.js';
 const pkg = 'gt-react';
 export class ReactCLI extends BaseCLI {
     constructor(command, library, additionalModules) {
@@ -25,7 +22,6 @@ export class ReactCLI extends BaseCLI {
     init() {
         this.setupStageCommand();
         this.setupTranslateCommand();
-        this.setupScanCommand();
         this.setupGenerateSourceCommand();
         this.setupValidateCommand();
     }
@@ -36,50 +32,18 @@ export class ReactCLI extends BaseCLI {
         return wrapContentReact(options, pkg, framework, errors, warnings);
     }
     setupStageCommand() {
-        this.program
+        attachAdditionalReactTranslateFlags(attachTranslateFlags(this.program
             .command('stage')
-            .description('Submits the project to the General Translation API for translation. Translations created using this command will require human approval.')
-            .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('--version-id <id>', 'Version ID for the translation service')
-            .option('--tsconfig, --jsconfig <path>', 'Path to jsconfig or tsconfig file', findFilepath(['./tsconfig.json', './jsconfig.json']))
-            .option('--dictionary <path>', 'Path to dictionary file')
-            .option('--src <paths...>', "Space-separated list of glob patterns containing the app's source code, by default 'src/**/*.{js,jsx,ts,tsx}' 'app/**/*.{js,jsx,ts,tsx}' 'pages/**/*.{js,jsx,ts,tsx}' 'components/**/*.{js,jsx,ts,tsx}'")
-            .option('--default-language, --default-locale <locale>', 'Default locale (e.g., en)')
-            .option('--new, --locales <locales...>', 'Space-separated list of locales (e.g., en fr es)')
-            .option('--inline', 'Include inline <T> tags in addition to dictionary file', true)
-            .option('--ignore-errors', 'Ignore errors encountered while scanning for <T> tags', false)
-            .option('--dry-run', 'Dry run, does not send updates to General Translation API', false)
-            .option('--timeout <seconds>', 'Timeout in seconds for waiting for updates to be deployed to the CDN', DEFAULT_TIMEOUT.toString())
-            .action(async (options) => {
-            displayHeader('Staging project for translation with approval...');
+            .description('Submits the project to the General Translation API for translation. Translations created using this command will require human approval.'))).action(async (options) => {
+            displayHeader('Staging project for translation with approval required...');
             await this.handleStage(options);
             endCommand('Done!');
         });
     }
     setupTranslateCommand() {
-        this.program
+        attachAdditionalReactTranslateFlags(attachTranslateFlags(this.program
             .command('translate')
-            .description('Scans the project for a dictionary and/or <T> tags, and sends the updates to the General Translation API for translation.')
-            .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('--version-id <id>', 'Version ID for the translation service')
-            .option('--tsconfig, --jsconfig <path>', 'Path to jsconfig or tsconfig file', findFilepath(['./tsconfig.json', './jsconfig.json']))
-            .option('--dictionary <path>', 'Path to dictionary file')
-            .option('--src <paths...>', "Space-separated list of glob patterns containing the app's source code, by default 'src/**/*.{js,jsx,ts,tsx}' 'app/**/*.{js,jsx,ts,tsx}' 'pages/**/*.{js,jsx,ts,tsx}' 'components/**/*.{js,jsx,ts,tsx}'")
-            .option('--default-language, --default-locale <locale>', 'Default locale (e.g., en)')
-            .option('--new, --locales <locales...>', 'Space-separated list of locales (e.g., en fr es)')
-            .option('--inline', 'Include inline <T> tags in addition to dictionary file', true)
-            .option('--ignore-errors', 'Ignore errors encountered while scanning for <T> tags', false)
-            .option('--dry-run', 'Dry run, does not send updates to General Translation API', false)
-            .option('--timeout <seconds>', 'Timeout in seconds for waiting for updates to be deployed to the CDN', DEFAULT_TIMEOUT.toString())
-            .option('--experimental-localize-static-urls', 'Triggering this will run a script after the cli tool that localizes all urls in content files. Currently only supported for md and mdx files.', false)
-            .option('--experimental-hide-default-locale', 'When localizing static locales, hide the default locale from the path', false)
-            .option('--experimental-flatten-json-files', 'Triggering this will flatten the json files into a single file. This is useful for projects that have a lot of json files.', false)
-            .option('--experimental-localize-static-imports', 'Triggering this will run a script after the cli tool that localizes all static imports in content files. Currently only supported for md and mdx files.', false)
-            .action(async (options) => {
+            .description('Scans the project for a dictionary and/or <T> tags, and sends the updates to the General Translation API for translation.'))).action(async (options) => {
             displayHeader('Translating project...');
             await this.handleTranslate(options);
             endCommand('Done!');
@@ -102,79 +66,17 @@ export class ReactCLI extends BaseCLI {
         });
     }
     setupGenerateSourceCommand() {
-        this.program
+        attachAdditionalReactTranslateFlags(attachTranslateFlags(this.program
             .command('generate')
-            .description('Generate a translation file for the source locale. The -t flag must be provided. This command should be used if you are handling your own translations.')
-            .option('--src <paths...>', "Space-separated list of glob patterns containing the app's source code, by default 'src/**/*.{js,jsx,ts,tsx}' 'app/**/*.{js,jsx,ts,tsx}' 'pages/**/*.{js,jsx,ts,tsx}' 'components/**/*.{js,jsx,ts,tsx}'")
-            .option('--tsconfig, --jsconfig <path>', 'Path to jsconfig or tsconfig file', findFilepath(['./tsconfig.json', './jsconfig.json']))
-            .option('--dictionary <path>', 'Path to dictionary file')
-            .option('--default-language, --default-locale <locale>', 'Source locale (e.g., en)')
-            .option('--inline', 'Include inline <T> tags in addition to dictionary file', true)
-            .option('--ignore-errors', 'Ignore errors encountered while scanning for <T> tags', false)
-            .option('--suppress-warnings', 'Suppress warnings encountered while scanning for <T> tags', false)
-            .option('-t, --translations-dir, --translation-dir <path>', 'Path to directory where translations will be saved. If this flag is not provided, translations will not be saved locally.')
-            .action(async (options) => {
+            .description('Generate a translation file for the source locale. This command should be used if you are handling your own translations.'))).action(async (initOptions) => {
             displayHeader('Generating source templates...');
-            await this.handleGenerateSourceCommand(options);
-            endCommand('Done!');
-        });
-    }
-    setupScanCommand() {
-        this.program
-            .command('scan')
-            .description('Scans the project and wraps all JSX elements in the src directory with a <T> tag, with unique ids')
-            .option('--src <paths...>', "Space-separated list of glob patterns containing the app's source code, by default 'src/**/*.{js,jsx,ts,tsx}' 'app/**/*.{js,jsx,ts,tsx}' 'pages/**/*.{js,jsx,ts,tsx}' 'components/**/*.{js,jsx,ts,tsx}'")
-            .option('-c, --config <path>', 'Filepath to config file, by default gt.config.json', findFilepath(['gt.config.json']))
-            .option('--disable-ids', 'Disable id generation for the <T> tags', false)
-            .option('--disable-formatting', 'Disable formatting of edited files', false)
-            .option('--skip-ts', 'Skip wrapping <T> tags in TypeScript files', false)
-            .action(async (options) => {
-            displayHeader('Scanning project...');
-            await this.handleScanCommand(options);
+            await this.handleGenerateSourceCommand(initOptions);
             endCommand('Done!');
         });
     }
     async handleGenerateSourceCommand(initOptions) {
         const settings = await generateSettings(initOptions);
-        const options = { ...initOptions, ...settings };
-        if (!options.dictionary) {
-            options.dictionary = findFilepath([
-                './dictionary.js',
-                './src/dictionary.js',
-                './dictionary.json',
-                './src/dictionary.json',
-                './dictionary.ts',
-                './src/dictionary.ts',
-            ]);
-        }
-        // User has to provide a dictionary file
-        // will not read from settings.files.resolvedPaths.json
-        const { updates, errors, warnings } = await createUpdates(options, options.dictionary, this.library === 'gt-next' ? 'gt-next' : 'gt-react', false);
-        if (warnings.length > 0) {
-            if (options.suppressWarnings) {
-                logWarning(chalk.yellow(`CLI tool encountered ${warnings.length} warnings while scanning for translatable content. ${chalk.gray('To view these warnings, re-run without the --suppress-warnings flag')}`));
-            }
-            else {
-                logWarning(chalk.yellow(`CLI tool encountered ${warnings.length} warnings while scanning for translatable content. ${chalk.gray('To suppress these warnings, re-run with --suppress-warnings')}\n` +
-                    warnings
-                        .map((warning) => chalk.yellow('• Warning: ') + chalk.white(warning))
-                        .join('\n')));
-            }
-        }
-        if (errors.length > 0) {
-            if (options.ignoreErrors) {
-                logWarning(chalk.yellow(`CLI tool encountered errors while scanning for translatable content. These components will not be translated.\n` +
-                    errors
-                        .map((error) => chalk.yellow('• Warning: ') + chalk.white(error))
-                        .join('\n')));
-            }
-            else {
-                logErrorAndExit(chalk.red(`CLI tool encountered errors while scanning for translatable content. ${chalk.gray('To ignore these errors, re-run with --ignore-errors')}\n` +
-                    errors
-                        .map((error) => chalk.red('• Error: ') + chalk.white(error))
-                        .join('\n')));
-            }
-        }
+        const updates = await aggregateReactTranslations(initOptions, settings, this.library === 'gt-next' ? 'gt-next' : 'gt-react');
         // Convert updates to the proper data format
         const newData = {};
         for (const update of updates) {
@@ -255,48 +157,6 @@ export class ReactCLI extends BaseCLI {
                     .join('\n'));
         }
     }
-    async handleStage(initOptions) {
-        const settings = await generateSettings(initOptions);
-        // First run the base class's handleTranslate method
-        const options = { ...initOptions, ...settings };
-        if (!settings.stageTranslations) {
-            // Update settings.stageTranslations to true
-            settings.stageTranslations = true;
-            await updateConfig({
-                configFilepath: options.config,
-                stageTranslations: true,
-            });
-        }
-        const pkg = this.library === 'gt-next' ? 'gt-next' : 'gt-react';
-        await stageProject(options, pkg);
-    }
-    async handleTranslate(initOptions) {
-        const settings = await generateSettings(initOptions);
-        // First run the base class's handleTranslate method
-        const options = { ...initOptions, ...settings };
-        try {
-            await super.handleGenericTranslate(options);
-            // If the base class's handleTranslate completes successfully, continue with ReactCLI-specific code
-        }
-        catch {
-            // Continue with ReactCLI-specific code even if base handleTranslate failed
-        }
-        if (!settings.stageTranslations) {
-            // If stageTranslations is false, stage the project
-            const pkg = this.library === 'gt-next' ? 'gt-next' : 'gt-react';
-            const results = await stageProject(options, pkg);
-            if (results) {
-                await translate(options, results.versionId);
-            }
-        }
-        else {
-            if (!settings._versionId) {
-                logError(noVersionIdError);
-                process.exit(1);
-            }
-            await translate(options, settings._versionId);
-        }
-    }
     async handleValidate(initOptions, files) {
         validateConfigExists();
         const settings = await generateSettings(initOptions);

package/dist/config/generateSettings.js

@@ -76,9 +76,14 @@ export async function generateSettings(options, cwd = process.cwd()) {
         }
     }
     // merge options
-    let mergedOptions = { ...gtConfig, ...options };
+    const mergedOptions = { ...gtConfig, ...options };
+    // Add defaultLocale if not provided
+    mergedOptions.defaultLocale =
+        mergedOptions.defaultLocale || libraryDefaultLocale;
     // merge locales
     mergedOptions.locales = Array.from(new Set([...(gtConfig.locales || []), ...(options.locales || [])]));
+    // Separate defaultLocale from locales
+    mergedOptions.locales = mergedOptions.locales.filter((locale) => locale !== mergedOptions.defaultLocale);
     // Add apiKey if not provided
     mergedOptions.apiKey = mergedOptions.apiKey || process.env.GT_API_KEY;
     // Add projectId if not provided
@@ -87,9 +92,6 @@ export async function generateSettings(options, cwd = process.cwd()) {
     mergedOptions.baseUrl = mergedOptions.baseUrl || defaultBaseUrl;
     // Add dashboardUrl if not provided
     mergedOptions.dashboardUrl = mergedOptions.dashboardUrl || GT_DASHBOARD_URL;
-    // Add defaultLocale if not provided
-    mergedOptions.defaultLocale =
-        mergedOptions.defaultLocale || libraryDefaultLocale;
     // Add locales if not provided
     mergedOptions.locales = mergedOptions.locales || [];
     // Add default config file name if not provided
@@ -101,14 +103,16 @@ export async function generateSettings(options, cwd = process.cwd()) {
     // Add stageTranslations if not provided
     // For human review, always stage the project
     mergedOptions.stageTranslations = mergedOptions.stageTranslations ?? false;
+    // Add publish if not provided
+    mergedOptions.publish = mergedOptions.publish ?? false;
     // Populate src if not provided
     mergedOptions.src = mergedOptions.src || DEFAULT_SRC_PATTERNS;
     // Resolve all glob patterns in the files object
     mergedOptions.files = mergedOptions.files
         ? resolveFiles(mergedOptions.files, mergedOptions.defaultLocale, mergedOptions.locales, cwd)
         : undefined;
-    mergedOptions = {
-        ...mergedOptions,
+    mergedOptions.options = {
+        ...(mergedOptions.options || {}),
         experimentalLocalizeStaticImports: gtConfig.options?.experimentalLocalizeStaticImports ||
             options.experimentalLocalizeStaticImports,
         experimentalLocalizeStaticUrls: gtConfig.options?.experimentalLocalizeStaticUrls ||
@@ -153,6 +157,7 @@ export async function generateSettings(options, cwd = process.cwd()) {
             framework: mergedOptions.framework,
         });
     }
+    mergedOptions.configDirectory = path.join(cwd, '.gt');
     validateSettings(mergedOptions);
     // Set up GT instance
     gt.setConfig({

package/dist/console/index.d.ts

@@ -18,3 +18,4 @@ export declare const noApiKeyError = "No API key found! Please provide an API ke
 export declare const devApiKeyError = "You are using a development API key. Please use a production API key to use the General Translation API.\nYou can generate a production API key with the command: npx gtx-cli auth -t production";
 export declare const noProjectIdError = "No project ID found! Please provide a project ID using the --project-id flag, specify it in your gt.config.json file, or set the GT_PROJECT_ID environment variable.";
 export declare const noVersionIdError = "No version ID found! Please provide a version ID using the --version-id flag or specify it in your gt.config.json file as the _versionId property.";
+export declare const invalidConfigurationError = "Invalid files configuration! Please either provide a valid configuration to download local translations or set the --publish flag to true to upload translations to the CDN.";

package/dist/console/index.js

@@ -21,3 +21,4 @@ export const noApiKeyError = `No API key found! Please provide an API key using
 export const devApiKeyError = `You are using a development API key. Please use a production API key to use the General Translation API.\nYou can generate a production API key with the command: npx gtx-cli auth -t production`;
 export const noProjectIdError = `No project ID found! Please provide a project ID using the --project-id flag, specify it in your gt.config.json file, or set the GT_PROJECT_ID environment variable.`;
 export const noVersionIdError = `No version ID found! Please provide a version ID using the --version-id flag or specify it in your gt.config.json file as the _versionId property.`;
+export const invalidConfigurationError = `Invalid files configuration! Please either provide a valid configuration to download local translations or set the --publish flag to true to upload translations to the CDN.`;

package/dist/console/logging.d.ts

@@ -13,6 +13,7 @@ export declare function displayProjectId(projectId: string): void;
 export declare function displayResolvedPaths(resolvedPaths: [string, string][]): void;
 export declare function displayCreatedConfigFile(configFilepath: string): void;
 export declare function displayUpdatedConfigFile(configFilepath: string): void;
+export declare function displayUpdatedVersionsFile(versionFilepath: string): void;
 export declare function createSpinner(indicator?: 'dots' | 'timer'): import("@clack/prompts").SpinnerResult;
 export declare function createOraSpinner(indicator?: 'dots' | 'circleHalves'): Promise<import("ora").Ora>;
 export declare function promptText({ message, defaultValue, validate, }: {

package/dist/console/logging.js

@@ -73,6 +73,9 @@ export function displayCreatedConfigFile(configFilepath) {
 export function displayUpdatedConfigFile(configFilepath) {
     log.success(`Updated config file ${chalk.cyan(configFilepath)}`);
 }
+export function displayUpdatedVersionsFile(versionFilepath) {
+    log.success(`Updated versions file ${chalk.cyan(versionFilepath)}`);
+}
 // Spinner functionality
 export function createSpinner(indicator = 'timer') {
     return spinner({ indicator });

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

@@ -1,4 +1,5 @@
 import { ResolvedFiles, TransformFiles } from '../../types/index.js';
+import { FileMapping } from '../../types/files.js';
 /**
  * Creates a mapping between source files and their translated counterparts for each locale
  * @param filePaths - Resolved file paths for different file types
@@ -7,4 +8,4 @@ import { ResolvedFiles, TransformFiles } from '../../types/index.js';
  * @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>>;
+export declare function createFileMapping(filePaths: ResolvedFiles, placeholderPaths: ResolvedFiles, transformPaths: TransformFiles, targetLocales: string[], defaultLocale: string): FileMapping;

package/dist/formats/files/fileMapping.js

@@ -4,6 +4,7 @@ import path from 'node:path';
 import { getRelative } from '../../fs/findFilepath.js';
 import { getLocaleProperties } from 'generaltranslation';
 import { replaceLocalePlaceholders } from '../utils.js';
+import { TEMPLATE_FILE_NAME } from '../../cli/commands/stage.js';
 /**
  * Creates a mapping between source files and their translated counterparts for each locale
  * @param filePaths - Resolved file paths for different file types
@@ -18,6 +19,11 @@ export function createFileMapping(filePaths, placeholderPaths, transformPaths, t
         const translatedPaths = resolveLocaleFiles(placeholderPaths, locale);
         const localeMapping = {};
         // Process each file type
+        // Start with GTJSON Template files
+        if (translatedPaths.gt) {
+            const filepath = translatedPaths.gt;
+            localeMapping[TEMPLATE_FILE_NAME] = filepath;
+        }
         for (const typeIndex of SUPPORTED_FILE_EXTENSIONS) {
             if (!filePaths[typeIndex] || !translatedPaths[typeIndex])
                 continue;

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

@@ -1,13 +1,4 @@
-import { ResolvedFiles, Settings, TransformFiles } from '../../types/index.js';
-import { DataFormat } from '../../types/data.js';
-import { TranslateOptions } 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 translateFiles(filePaths: ResolvedFiles, placeholderPaths: ResolvedFiles, transformPaths: TransformFiles, dataFormat: DataFormat | undefined, options: Settings & TranslateOptions): Promise<void>;
+import { Settings } from '../../types/index.js';
+import { FileToTranslate } from '../../types/data.js';
+export declare const SUPPORTED_DATA_FORMATS: string[];
+export declare function aggregateFiles(settings: Settings): Promise<FileToTranslate[]>;

package/dist/formats/files/translate.js

@@ -1,38 +1,42 @@
-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 { 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 { createFileMapping } from './fileMapping.js';
 import parseYaml from '../yaml/parseYaml.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 translateFiles(filePaths, placeholderPaths, transformPaths, dataFormat = 'JSX', options) {
-    // Collect all files to translate
+import { determineLibrary } from '../../fs/determineFramework.js';
+export const SUPPORTED_DATA_FORMATS = ['JSX', 'ICU', 'I18NEXT'];
+export async function aggregateFiles(settings) {
+    // Aggregate all files to translate
     const allFiles = [];
-    const additionalOptions = options.options || {};
+    if (!settings.files ||
+        (Object.keys(settings.files.placeholderPaths).length === 1 &&
+            settings.files.placeholderPaths.gt)) {
+        return allFiles;
+    }
+    const { resolvedPaths: filePaths } = settings.files;
     // Process JSON files
     if (filePaths.json) {
-        if (!SUPPORTED_DATA_FORMATS.includes(dataFormat)) {
-            logErrorAndExit(noSupportedFormatError);
+        const { library, additionalModules } = determineLibrary();
+        // Determine dataFormat for JSONs
+        let dataFormat;
+        if (library === 'next-intl') {
+            dataFormat = 'ICU';
+        }
+        else if (library === 'i18next') {
+            if (additionalModules.includes('i18next-icu')) {
+                dataFormat = 'ICU';
+            }
+            else {
+                dataFormat = 'I18NEXT';
+            }
+        }
+        else {
+            dataFormat = 'JSX';
         }
         const jsonFiles = filePaths.json.map((filePath) => {
             const content = readFile(filePath);
-            const parsedJson = parseJson(content, filePath, additionalOptions, options.defaultLocale);
+            const parsedJson = parseJson(content, filePath, settings.options || {}, settings.defaultLocale);
             const relativePath = getRelative(filePath);
             return {
                 content: parsedJson,
@@ -45,18 +49,14 @@ export async function translateFiles(filePaths, placeholderPaths, transformPaths
     }
     // Process YAML files
     if (filePaths.yaml) {
-        if (!SUPPORTED_DATA_FORMATS.includes(dataFormat)) {
-            logErrorAndExit(noSupportedFormatError);
-        }
         const yamlFiles = filePaths.yaml.map((filePath) => {
             const content = readFile(filePath);
-            const { content: parsedYaml, fileFormat } = parseYaml(content, filePath, additionalOptions);
+            const { content: parsedYaml, fileFormat } = parseYaml(content, filePath, settings.options || {});
             const relativePath = getRelative(filePath);
             return {
                 content: parsedYaml,
                 fileName: relativePath,
                 fileFormat,
-                dataFormat,
             };
         });
         allFiles.push(...yamlFiles);
@@ -73,7 +73,6 @@ export async function translateFiles(filePaths, placeholderPaths, transformPaths
                     content: sanitizedContent,
                     fileName: relativePath,
                     fileFormat: fileType.toUpperCase(),
-                    dataFormat,
                 };
             });
             allFiles.push(...files);
@@ -81,117 +80,6 @@ export async function translateFiles(filePaths, placeholderPaths, transformPaths
     }
     if (allFiles.length === 0) {
         logError('No files to translate were found. Please check your configuration and try again.');
-        return;
-    }
-    if (options.dryRun) {
-        const fileNames = allFiles.map((file) => `- ${file.fileName}`).join('\n');
-        logSuccess(`Dry run: No files were sent to General Translation. Found files:\n${fileNames}`);
-        return;
-    }
-    // Validate required settings are present
-    if (!options.locales) {
-        logErrorAndExit(noLocalesError);
-    }
-    if (!options.defaultLocale) {
-        logErrorAndExit(noDefaultLocaleError);
-    }
-    if (!options.apiKey) {
-        logErrorAndExit(noApiKeyError);
-    }
-    if (options.apiKey.startsWith('gtx-dev-')) {
-        logErrorAndExit(devApiKeyError);
-    }
-    if (!options.projectId) {
-        logErrorAndExit(noProjectIdError);
-    }
-    try {
-        // Send all files in a single API call
-        const response = await sendFiles(allFiles, {
-            ...options,
-            publish: false,
-            wait: true,
-        });
-        const { data, locales, translations } = response;
-        // Create file mapping for all file types
-        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
-        await checkFileTranslations(data, locales, 600, (sourcePath, locale) => fileMapping[locale][sourcePath], downloadStatus, // Pass the already downloaded files to avoid duplicate requests
-        options);
-    }
-    catch (error) {
-        logErrorAndExit(`Error translating 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,
-                inputPath: fileName,
-                outputPath,
-                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;
+    return allFiles;
 }