gtx-cli 2.1.5-alpha.3 → 2.1.5-alpha.5

package/dist/cli/base.js

@@ -5,6 +5,7 @@ import path from 'node:path';
 import fs from 'node:fs';
 import { generateSettings } from '../config/generateSettings.js';
 import chalk from 'chalk';
+import { translateFiles } from '../formats/files/translate.js';
 import { FILE_EXT_TO_EXT_LABEL } from '../formats/files/supportedFiles.js';
 import { handleSetupReactCommand } from '../setup/wizard.js';
 import { isPackageInstalled, searchForPackageJson, } from '../utils/packageJson.js';
@@ -13,11 +14,11 @@ import { installPackage } from '../utils/installPackage.js';
 import { getPackageManager } from '../utils/packageManager.js';
 import { retrieveCredentials, setCredentials } from '../utils/credentials.js';
 import { areCredentialsSet } from '../utils/credentials.js';
+import localizeStaticUrls from '../utils/localizeStaticUrls.js';
+import flattenJsonFiles from '../utils/flattenJsonFiles.js';
+import localizeStaticImports from '../utils/localizeStaticImports.js';
+import copyFile from '../fs/copyFile.js';
 import { upload } from '../formats/files/upload.js';
-import { attachTranslateFlags } from './flags.js';
-import { handleStage } from './commands/stage.js';
-import { handleDownload, handleTranslate, postProcessTranslations, } from './commands/translate.js';
-import updateConfig from '../fs/config/updateConfig.js';
 export class BaseCLI {
     library;
     additionalModules;
@@ -35,7 +36,7 @@ export class BaseCLI {
     }
     // Init is never called in a child class
     init() {
-        this.setupTranslateCommand();
+        this.setupGTCommand();
     }
     // Execute is called by the main program
     execute() {
@@ -44,49 +45,28 @@ export class BaseCLI {
             process.argv.push('init');
         }
     }
-    setupStageCommand() {
-        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.')).action(async (initOptions) => {
-            displayHeader('Staging project for translation with approval required...');
-            await this.handleStage(initOptions);
-            endCommand('Done!');
-        });
-    }
-    setupTranslateCommand() {
-        attachTranslateFlags(this.program
+    setupGTCommand() {
+        this.program
             .command('translate')
-            .description('Translate your project using General Translation')).action(async (initOptions) => {
+            .description('Translate your project using General 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('--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, does not send updates to General Translation API', 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)
+            .action(async (initOptions) => {
             displayHeader('Starting translation...');
-            await this.handleTranslate(initOptions);
+            const settings = await generateSettings(initOptions);
+            const options = { ...initOptions, ...settings };
+            await this.handleGenericTranslate(options);
             endCommand('Done!');
         });
     }
-    async handleStage(initOptions) {
-        const settings = await generateSettings(initOptions);
-        if (!settings.stageTranslations) {
-            // Update settings.stageTranslations to true
-            settings.stageTranslations = true;
-            await updateConfig({
-                configFilepath: settings.config,
-                stageTranslations: true,
-            });
-        }
-        await handleStage(initOptions, settings, this.library, true);
-    }
-    async handleTranslate(initOptions) {
-        const settings = await generateSettings(initOptions);
-        if (!settings.stageTranslations) {
-            const results = await handleStage(initOptions, settings, this.library, false);
-            if (results) {
-                await handleTranslate(initOptions, settings, results);
-            }
-        }
-        else {
-            await handleDownload(initOptions, settings);
-        }
-        await postProcessTranslations(settings);
-    }
     setupUploadCommand() {
         this.program
             .command('upload')
@@ -217,6 +197,55 @@ See the docs for more information: https://generaltranslation.com/docs/react/tut
         // Process all file types at once with a single call
         await upload(sourceFiles, placeholderPaths, transformPaths, dataFormat, settings);
     }
+    async handleGenericTranslate(settings) {
+        // dataFormat for JSONs
+        let dataFormat;
+        if (this.library === 'next-intl') {
+            dataFormat = 'ICU';
+        }
+        else if (this.library === 'i18next') {
+            if (this.additionalModules.includes('i18next-icu')) {
+                dataFormat = 'ICU';
+            }
+            else {
+                dataFormat = 'I18NEXT';
+            }
+        }
+        else {
+            dataFormat = 'JSX';
+        }
+        if (!settings.files ||
+            (Object.keys(settings.files.placeholderPaths).length === 1 &&
+                settings.files.placeholderPaths.gt)) {
+            return;
+        }
+        const { resolvedPaths: sourceFiles, placeholderPaths, transformPaths, } = settings.files;
+        // Localize static urls in default locale BEFORE translation
+        if (settings.experimentalLocalizeStaticUrls) {
+            await localizeStaticUrls(settings, [settings.defaultLocale]);
+        }
+        // Process all file types at once with a single call
+        await translateFiles(sourceFiles, placeholderPaths, transformPaths, dataFormat, settings);
+        // Localize static urls in other locales AFTER translation
+        if (settings.experimentalLocalizeStaticUrls) {
+            const otherLocales = settings.locales.filter((locale) => locale !== settings.defaultLocale);
+            if (otherLocales.length > 0) {
+                await localizeStaticUrls(settings, otherLocales);
+            }
+        }
+        // Localize static imports (/docs -> /[locale]/docs)
+        if (settings.experimentalLocalizeStaticImports) {
+            await localizeStaticImports(settings);
+        }
+        // Flatten json files into a single file
+        if (settings.experimentalFlattenJsonFiles) {
+            await flattenJsonFiles(settings);
+        }
+        // Copy files to the target locale
+        if (settings.options?.copyFiles) {
+            await copyFile(settings);
+        }
+    }
     async handleSetupReactCommand(options) {
         await handleSetupReactCommand(options);
     }
@@ -236,14 +265,13 @@ See the docs for more information: https://generaltranslation.com/docs/react/tut
         const usingCDN = isUsingGT
             ? await promptConfirm({
                 message: `Auto-detected that you're using gt-next or gt-react. Would you like to use the General Translation CDN to store your translations?\nSee ${isUsingGTNext
-                    ? 'https://generaltranslation.com/en/docs/next/guides/local-tx'
-                    : 'https://generaltranslation.com/en/docs/react/guides/local-tx'} for more information.\nIf you answer no, we'll configure the CLI tool to download completed translations.`,
+                    ? 'https://generaltranslation.com/docs/next/reference/local-tx'
+                    : 'https://generaltranslation.com/docs/react/reference/local-tx'} for more information.\nIf you answer no, we'll configure the CLI tool to download completed translations.`,
                 defaultValue: true,
             })
             : false;
         if (isUsingGT && !usingCDN) {
-            logMessage(`Make sure to add a loadTranslations function to your app configuration to correctly use local translations.
-See https://generaltranslation.com/en/docs/next/guides/local-tx`);
+            logMessage(`To prevent translations from being published, please disable the project setting on the dashboard: ${chalk.cyan('https://dash.generaltranslation.com/settings/project')}`);
         }
         // Ask where the translations are stored
         const translationsDir = isUsingGT && !usingCDN
@@ -292,7 +320,6 @@ See https://generaltranslation.com/en/docs/next/guides/local-tx`);
             defaultLocale,
             locales,
             files: Object.keys(files).length > 0 ? files : undefined,
-            publish: isUsingGT && usingCDN,
         });
         logSuccess(`Feel free to edit ${chalk.cyan(configFilepath)} to customize your translation setup. Docs: https://generaltranslation.com/docs/cli/reference/config`);
         // Install gtx-cli if not installed

package/dist/cli/next.js

@@ -8,6 +8,7 @@ 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, SupportedLibraries, TranslateFlags } from '../types/index.js';
+import { Options, SupportedFrameworks, WrapOptions, GenerateSourceOptions, SupportedLibraries } 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,7 +12,10 @@ export declare class ReactCLI extends BaseCLI {
     protected setupTranslateCommand(): void;
     protected setupValidateCommand(): void;
     protected setupGenerateSourceCommand(): void;
-    protected handleGenerateSourceCommand(initOptions: TranslateFlags): Promise<void>;
+    protected setupScanCommand(): void;
+    protected handleGenerateSourceCommand(initOptions: GenerateSourceOptions): 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, logStep, logSuccess, logWarning, promptConfirm, } from '../console/logging.js';
+import { displayHeader, endCommand, logError, logErrorAndExit, 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,12 +8,15 @@ 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 } from '../console/index.js';
-import { aggregateReactTranslations } from '../translation/stage.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 { validateConfigExists } from '../config/validateSettings.js';
 import { validateProject } from '../translation/validate.js';
 import { intro } from '@clack/prompts';
-import { attachAdditionalReactTranslateFlags, attachTranslateFlags, } from './flags.js';
+const DEFAULT_TIMEOUT = 600;
 const pkg = 'gt-react';
 export class ReactCLI extends BaseCLI {
     constructor(command, library, additionalModules) {
@@ -22,6 +25,7 @@ export class ReactCLI extends BaseCLI {
     init() {
         this.setupStageCommand();
         this.setupTranslateCommand();
+        this.setupScanCommand();
         this.setupGenerateSourceCommand();
         this.setupValidateCommand();
     }
@@ -32,18 +36,50 @@ export class ReactCLI extends BaseCLI {
         return wrapContentReact(options, pkg, framework, errors, warnings);
     }
     setupStageCommand() {
-        attachAdditionalReactTranslateFlags(attachTranslateFlags(this.program
+        this.program
             .command('stage')
-            .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...');
+            .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...');
             await this.handleStage(options);
             endCommand('Done!');
         });
     }
     setupTranslateCommand() {
-        attachAdditionalReactTranslateFlags(attachTranslateFlags(this.program
+        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.'))).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.')
+            .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) => {
             displayHeader('Translating project...');
             await this.handleTranslate(options);
             endCommand('Done!');
@@ -66,17 +102,79 @@ export class ReactCLI extends BaseCLI {
         });
     }
     setupGenerateSourceCommand() {
-        attachAdditionalReactTranslateFlags(attachTranslateFlags(this.program
+        this.program
             .command('generate')
-            .description('Generate a translation file for the source locale. This command should be used if you are handling your own translations.'))).action(async (initOptions) => {
+            .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) => {
             displayHeader('Generating source templates...');
-            await this.handleGenerateSourceCommand(initOptions);
+            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);
             endCommand('Done!');
         });
     }
     async handleGenerateSourceCommand(initOptions) {
         const settings = await generateSettings(initOptions);
-        const updates = await aggregateReactTranslations(initOptions, settings, this.library === 'gt-next' ? 'gt-next' : 'gt-react');
+        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')));
+            }
+        }
         // Convert updates to the proper data format
         const newData = {};
         for (const update of updates) {
@@ -157,6 +255,48 @@ 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,14 +76,9 @@ export async function generateSettings(options, cwd = process.cwd()) {
         }
     }
     // merge options
-    const mergedOptions = { ...gtConfig, ...options };
-    // Add defaultLocale if not provided
-    mergedOptions.defaultLocale =
-        mergedOptions.defaultLocale || libraryDefaultLocale;
+    let mergedOptions = { ...gtConfig, ...options };
     // 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
@@ -92,6 +87,9 @@ 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
@@ -103,16 +101,14 @@ 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.options = {
-        ...(mergedOptions.options || {}),
+    mergedOptions = {
+        ...mergedOptions,
         experimentalLocalizeStaticImports: gtConfig.options?.experimentalLocalizeStaticImports ||
             options.experimentalLocalizeStaticImports,
         experimentalLocalizeStaticUrls: gtConfig.options?.experimentalLocalizeStaticUrls ||
@@ -157,7 +153,6 @@ 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,4 +18,3 @@ 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,4 +21,3 @@ 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,7 +13,6 @@ 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,9 +73,6 @@ 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,5 +1,4 @@
 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
@@ -8,4 +7,4 @@ import { FileMapping } from '../../types/files.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): FileMapping;
+export declare function createFileMapping(filePaths: ResolvedFiles, placeholderPaths: ResolvedFiles, transformPaths: TransformFiles, targetLocales: string[], defaultLocale: string): Record<string, Record<string, string>>;

package/dist/formats/files/fileMapping.js

@@ -4,7 +4,6 @@ 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
@@ -19,11 +18,6 @@ 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,4 +1,13 @@
-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[]>;
+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>;