gtx-cli 2.3.6-alpha.2 → 2.3.6

package/dist/cli/react.js

@@ -0,0 +1,175 @@
+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';
+import { formatFiles } from '../hooks/postProcess.js';
+import { BaseCLI } from './base.js';
+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 { validateConfigExists } from '../config/validateSettings.js';
+import { validateProject } from '../translation/validate.js';
+import { intro } from '@clack/prompts';
+import { attachAdditionalReactTranslateFlags, attachTranslateFlags, } from './flags.js';
+const pkg = 'gt-react';
+export class ReactCLI extends BaseCLI {
+    constructor(command, library, additionalModules) {
+        super(command, library, additionalModules);
+    }
+    init() {
+        this.setupStageCommand();
+        this.setupTranslateCommand();
+        this.setupGenerateSourceCommand();
+        this.setupValidateCommand();
+    }
+    execute() {
+        super.execute();
+    }
+    wrapContent(options, framework, errors, warnings) {
+        return wrapContentReact(options, pkg, framework, errors, warnings);
+    }
+    setupStageCommand() {
+        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.'))).action(async (options) => {
+            displayHeader('Staging project for translation with approval required...');
+            await this.handleStage(options);
+            endCommand('Done!');
+        });
+    }
+    setupTranslateCommand() {
+        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.'))).action(async (options) => {
+            displayHeader('Translating project...');
+            await this.handleTranslate(options);
+            endCommand('Done!');
+        });
+    }
+    setupValidateCommand() {
+        this.program
+            .command('validate [files...]')
+            .description('Scans the project for a dictionary and/or <T> tags, and validates the project for errors.')
+            .option('-c, --config <path>', 'Filepath to config file, by default gt.config.json', findFilepath(['gt.config.json']))
+            .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('--inline', 'Include inline <T> tags in addition to dictionary file', true)
+            .action(async (files, options) => {
+            // intro here since we don't want to show the ascii title
+            intro(chalk.cyan('Validating project...'));
+            await this.handleValidate(options, files);
+            endCommand('Done!');
+        });
+    }
+    setupGenerateSourceCommand() {
+        attachAdditionalReactTranslateFlags(attachTranslateFlags(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) => {
+            displayHeader('Generating source templates...');
+            await this.handleGenerateSourceCommand(initOptions);
+            endCommand('Done!');
+        });
+    }
+    async handleGenerateSourceCommand(initOptions) {
+        const settings = await generateSettings(initOptions);
+        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) {
+            const { source, metadata } = update;
+            const { hash, id } = metadata;
+            if (id) {
+                newData[id] = source;
+            }
+            else {
+                newData[hash] = source;
+            }
+        }
+        // Save source file if files.json is provided
+        if (settings.files && settings.files.placeholderPaths.gt) {
+            const translationFiles = resolveLocaleFiles(settings.files.placeholderPaths, settings.defaultLocale);
+            if (!translationFiles.gt) {
+                logError(noFilesError);
+                process.exit(1);
+            }
+            await saveJSON(translationFiles.gt, newData);
+            logStep('Source file saved successfully!');
+            // Also save translations (after merging with existing translations)
+            for (const locale of settings.locales) {
+                const translationsFile = resolveLocaleFiles(settings.files.placeholderPaths, locale);
+                if (!translationsFile.gt) {
+                    continue;
+                }
+                const existingTranslations = loadJSON(translationsFile.gt);
+                const mergedTranslations = {
+                    ...newData,
+                    ...existingTranslations,
+                };
+                // Filter out keys that don't exist in newData
+                const filteredTranslations = Object.fromEntries(Object.entries(mergedTranslations).filter(([key]) => newData[key]));
+                await saveJSON(translationsFile.gt, filteredTranslations);
+            }
+            logStep('Merged translations successfully!');
+        }
+    }
+    async handleScanCommand(options) {
+        // Ask user for confirmation using inquirer
+        const answer = await promptConfirm({
+            message: chalk.yellow('Warning: This operation will modify your source files! Make sure you have committed or stashed your current changes. Do you want to continue?'),
+            defaultValue: true,
+        });
+        if (!answer) {
+            logError('Operation cancelled.');
+            process.exit(0);
+        }
+        // ----- Create a starter gt.config.json file -----
+        await generateSettings(options);
+        // ----- //
+        const includeTId = await promptConfirm({
+            message: 'Do you want to include an unique id for each <T> tag?',
+            defaultValue: true,
+        });
+        options.disableIds = !includeTId;
+        const errors = [];
+        const warnings = [];
+        // Wrap all JSX elements in the src directory with a <T> tag, with unique ids
+        const { filesUpdated } = await this.wrapContent(options, 'react', errors, warnings);
+        if (errors.length > 0) {
+            logError(chalk.red('Failed to write files:\n') + errors.join('\n'));
+        }
+        // Format updated files if formatters are available
+        if (!options.disableFormatting)
+            await formatFiles(filesUpdated);
+        logSuccess(`Success! Added <T> tags and updated ${chalk.bold.cyan(filesUpdated.length)} files:\n` +
+            filesUpdated.map((file) => `${chalk.green('-')} ${file}`).join('\n'));
+        if (filesUpdated.length > 0) {
+            logStep(chalk.green('Please verify the changes before committing.'));
+        }
+        if (warnings.length > 0) {
+            logWarning(chalk.yellow('Warnings encountered:') +
+                '\n' +
+                warnings
+                    .map((warning) => `${chalk.yellow('-')} ${warning}`)
+                    .join('\n'));
+        }
+    }
+    async handleValidate(initOptions, files) {
+        validateConfigExists();
+        const settings = await generateSettings(initOptions);
+        // First run the base class's handleTranslate method
+        const options = { ...initOptions, ...settings };
+        const pkg = this.library === 'gt-next' ? 'gt-next' : 'gt-react';
+        if (files && files.length > 0) {
+            // Validate specific files using createInlineUpdates
+            await validateProject(options, pkg, files);
+        }
+        else {
+            // Validate whole project as before
+            await validateProject(options, pkg);
+        }
+    }
+}

package/dist/config/generateSettings.d.ts

@@ -0,0 +1,9 @@
+import { Settings } from '../types/index.js';
+export declare const DEFAULT_SRC_PATTERNS: string[];
+/**
+ * Generates settings from any
+ * @param options - The options to generate settings from
+ * @param cwd - The current working directory
+ * @returns The generated settings
+ */
+export declare function generateSettings(options: any, cwd?: string): Promise<Settings>;

package/dist/config/generateSettings.js

@@ -0,0 +1,176 @@
+import { displayProjectId, logErrorAndExit, warnApiKeyInConfig, } from '../console/logging.js';
+import { loadConfig } from '../fs/config/loadConfig.js';
+import { defaultBaseUrl, libraryDefaultLocale, } from 'generaltranslation/internal';
+import fs from 'node:fs';
+import { createOrUpdateConfig } from '../fs/config/setupConfig.js';
+import { resolveFiles } from '../fs/config/parseFilesConfig.js';
+import { validateSettings } from './validateSettings.js';
+import { GT_DASHBOARD_URL } from '../utils/constants.js';
+import { resolveProjectId } from '../fs/utils.js';
+import path from 'node:path';
+import chalk from 'chalk';
+import { resolveConfig } from './resolveConfig.js';
+import { gt } from '../utils/gt.js';
+import { generatePreset } from './optionPresets.js';
+export const DEFAULT_SRC_PATTERNS = [
+    'src/**/*.{js,jsx,ts,tsx}',
+    'app/**/*.{js,jsx,ts,tsx}',
+    'pages/**/*.{js,jsx,ts,tsx}',
+    'components/**/*.{js,jsx,ts,tsx}',
+];
+/**
+ * Generates settings from any
+ * @param options - The options to generate settings from
+ * @param cwd - The current working directory
+ * @returns The generated settings
+ */
+export async function generateSettings(options, cwd = process.cwd()) {
+    // Load config file
+    let gtConfig = {};
+    if (options.config && !options.config.endsWith('.json')) {
+        options.config = `${options.config}.json`;
+    }
+    if (options.config) {
+        gtConfig = loadConfig(options.config);
+    }
+    else {
+        const config = resolveConfig(cwd);
+        if (config) {
+            gtConfig = config.config;
+            options.config = config.path;
+        }
+        else {
+            gtConfig = {};
+        }
+    }
+    // Warn if apiKey is present in gt.config.json
+    if (gtConfig.apiKey) {
+        warnApiKeyInConfig(options.config);
+        process.exit(1);
+    }
+    const projectIdEnv = resolveProjectId();
+    // Resolve mismatched projectIds
+    if (gtConfig.projectId &&
+        options.projectId &&
+        gtConfig.projectId !== options.projectId) {
+        logErrorAndExit(`Project ID mismatch between ${chalk.green(gtConfig.projectId)} and ${chalk.green(options.projectId)}! Please use the same projectId in all configs.`);
+    }
+    else if (gtConfig.projectId &&
+        projectIdEnv &&
+        gtConfig.projectId !== projectIdEnv) {
+        logErrorAndExit(`Project ID mismatch between ${chalk.green(gtConfig.projectId)} and ${chalk.green(projectIdEnv)}! Please use the same projectId in all configs.`);
+    }
+    if (options.options?.docsUrlPattern &&
+        !options.options?.docsUrlPattern.includes('[locale]')) {
+        logErrorAndExit('Failed to localize static urls: URL pattern must include "[locale]" to denote the location of the locale');
+    }
+    if (options.options?.docsImportPattern &&
+        !options.options?.docsImportPattern.includes('[locale]')) {
+        logErrorAndExit('Failed to localize static imports: Import pattern must include "[locale]" to denote the location of the locale');
+    }
+    if (options.options?.copyFiles) {
+        for (const file of options.options.copyFiles) {
+            if (!file.includes('[locale]')) {
+                logErrorAndExit('Failed to copy files: File path must include "[locale]" to denote the location of the locale');
+            }
+        }
+    }
+    // merge 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
+    mergedOptions.projectId = mergedOptions.projectId || resolveProjectId();
+    // Add baseUrl if not provided
+    mergedOptions.baseUrl = mergedOptions.baseUrl || defaultBaseUrl;
+    // Add dashboardUrl if not provided
+    mergedOptions.dashboardUrl = mergedOptions.dashboardUrl || GT_DASHBOARD_URL;
+    // Add locales if not provided
+    mergedOptions.locales = mergedOptions.locales || [];
+    // Add default config file name if not provided
+    mergedOptions.config =
+        mergedOptions.config || path.join(cwd, 'gt.config.json');
+    // Display projectId if present
+    if (mergedOptions.projectId)
+        displayProjectId(mergedOptions.projectId);
+    // Add stageTranslations if not provided
+    // For human review, always stage the project
+    mergedOptions.stageTranslations = mergedOptions.stageTranslations ?? false;
+    // Add publish if not provided
+    mergedOptions.publish = (gtConfig.publish || options.publish) ?? false;
+    // Populate src if not provided
+    mergedOptions.src = mergedOptions.src || DEFAULT_SRC_PATTERNS;
+    // Resolve all glob patterns in the files object
+    const compositePatterns = [
+        ...Object.entries(mergedOptions.options?.jsonSchema || {}),
+    ]
+        .filter(([, schema]) => schema.composite)
+        .map(([key]) => key);
+    mergedOptions.files = mergedOptions.files
+        ? resolveFiles(mergedOptions.files, mergedOptions.defaultLocale, mergedOptions.locales, cwd, compositePatterns)
+        : undefined;
+    mergedOptions.options = {
+        ...(mergedOptions.options || {}),
+        experimentalLocalizeStaticImports: gtConfig.options?.experimentalLocalizeStaticImports ||
+            options.experimentalLocalizeStaticImports,
+        experimentalLocalizeStaticUrls: gtConfig.options?.experimentalLocalizeStaticUrls ||
+            options.experimentalLocalizeStaticUrls,
+        experimentalHideDefaultLocale: gtConfig.options?.experimentalHideDefaultLocale ||
+            options.experimentalHideDefaultLocale,
+        experimentalFlattenJsonFiles: gtConfig.options?.experimentalFlattenJsonFiles ||
+            options.experimentalFlattenJsonFiles,
+    };
+    // Add additional options if provided
+    if (mergedOptions.options) {
+        if (mergedOptions.options.jsonSchema) {
+            for (const fileGlob of Object.keys(mergedOptions.options.jsonSchema)) {
+                const jsonSchema = mergedOptions.options.jsonSchema[fileGlob];
+                if (jsonSchema.preset) {
+                    mergedOptions.options.jsonSchema[fileGlob] = {
+                        ...generatePreset(jsonSchema.preset, 'json'),
+                        ...jsonSchema,
+                    };
+                }
+            }
+        }
+        if (mergedOptions.options.yamlSchema) {
+            for (const fileGlob of Object.keys(mergedOptions.options.yamlSchema)) {
+                const yamlSchema = mergedOptions.options.yamlSchema[fileGlob];
+                if (yamlSchema.preset) {
+                    mergedOptions.options.yamlSchema[fileGlob] = {
+                        ...generatePreset(yamlSchema.preset, 'yaml'),
+                        ...yamlSchema,
+                    };
+                }
+            }
+        }
+    }
+    // if there's no existing config file, creates one
+    // does not include the API key to avoid exposing it
+    if (!fs.existsSync(mergedOptions.config)) {
+        await createOrUpdateConfig(mergedOptions.config, {
+            projectId: mergedOptions.projectId,
+            defaultLocale: mergedOptions.defaultLocale,
+            locales: mergedOptions.locales?.length > 0 ? mergedOptions.locales : undefined,
+            framework: mergedOptions.framework,
+        });
+    }
+    mergedOptions.configDirectory = path.join(cwd, '.gt');
+    validateSettings(mergedOptions);
+    // Set up GT instance
+    gt.setConfig({
+        projectId: mergedOptions.projectId,
+        apiKey: mergedOptions.apiKey,
+        baseUrl: mergedOptions.baseUrl,
+        sourceLocale: mergedOptions.defaultLocale,
+        customMapping: mergedOptions.customMapping,
+    });
+    return mergedOptions;
+}

package/dist/config/optionPresets.d.ts

@@ -0,0 +1,2 @@
+import { JsonSchema, YamlSchema } from '../types/index.js';
+export declare function generatePreset(preset: string, type: 'json' | 'yaml'): JsonSchema | YamlSchema;

package/dist/config/optionPresets.js

@@ -0,0 +1,56 @@
+export function generatePreset(preset, type) {
+    if (type === 'json') {
+        switch (preset) {
+            case 'mintlify':
+                // https://mintlify.com/docs/navigation
+                return {
+                    composite: {
+                        '$.navigation.languages': {
+                            type: 'array',
+                            key: '$.language',
+                            include: [
+                                '$..group',
+                                '$..tab',
+                                '$..item',
+                                '$..anchor',
+                                '$..dropdown',
+                            ],
+                            transform: {
+                                '$..pages[*]': {
+                                    match: '^{locale}/(.*)$',
+                                    replace: '{locale}/$1',
+                                },
+                            },
+                        },
+                        '$.redirects': {
+                            type: 'array',
+                            key: '$.language',
+                            include: [],
+                            transform: {
+                                '$.source': {
+                                    match: '^/{locale}/(.*)$',
+                                    replace: '/{locale}/$1',
+                                },
+                                '$.destination': {
+                                    match: '^/{locale}/(.*)$',
+                                    replace: '/{locale}/$1',
+                                },
+                            },
+                        },
+                    },
+                };
+            default:
+                return {};
+        }
+    }
+    else {
+        switch (preset) {
+            case 'mintlify':
+                return {
+                    include: ['$..summary', '$..description'],
+                };
+            default:
+                return {};
+        }
+    }
+}

package/dist/config/resolveConfig.d.ts

@@ -0,0 +1,4 @@
+export declare function resolveConfig(cwd: string): {
+    path: string;
+    config: Record<string, any>;
+} | null;

package/dist/config/resolveConfig.js

@@ -0,0 +1,19 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { loadConfig } from '../fs/config/loadConfig.js';
+export function resolveConfig(cwd) {
+    const configFilepath = 'gt.config.json';
+    if (fs.existsSync(path.join(cwd, configFilepath))) {
+        return {
+            path: path.join(cwd, configFilepath),
+            config: loadConfig(path.join(cwd, configFilepath)),
+        };
+    }
+    if (fs.existsSync(path.join(cwd, 'src/gt.config.json'))) {
+        return {
+            path: path.join(cwd, 'src/gt.config.json'),
+            config: loadConfig(path.join(cwd, 'src/gt.config.json')),
+        };
+    }
+    return null;
+}

package/dist/config/utils.d.ts

@@ -0,0 +1,2 @@
+import { Settings } from '../types/index.js';
+export declare function isUsingLocalTranslations(settings: Settings): boolean;

package/dist/config/utils.js

@@ -0,0 +1,4 @@
+// returns true if the project is configured to use local translations
+export function isUsingLocalTranslations(settings) {
+    return !!(settings.files && settings.files.placeholderPaths.gt);
+}

package/dist/config/validateSettings.d.ts

@@ -0,0 +1,3 @@
+import { Settings } from '../types/index.js';
+export declare function validateSettings(settings: Settings): void;
+export declare function validateConfigExists(): string;

package/dist/config/validateSettings.js

@@ -0,0 +1,32 @@
+import { isValidLocale, isSupersetLocale } from 'generaltranslation';
+import { logErrorAndExit } from '../console/logging.js';
+import fs from 'node:fs';
+import path from 'node:path';
+export function validateSettings(settings) {
+    // Validate locales
+    for (const locale of settings.locales) {
+        if (!isValidLocale(locale, settings.customMapping)) {
+            logErrorAndExit(`Provided locales: "${settings?.locales?.join()}", ${locale} is not a valid locale!`);
+        }
+    }
+    if (settings.defaultLocale &&
+        !isValidLocale(settings.defaultLocale, settings.customMapping)) {
+        logErrorAndExit(`defaultLocale: ${settings.defaultLocale} is not a valid locale!`);
+    }
+    // defaultLocale cannot be a superset of any other locale
+    if (settings.defaultLocale &&
+        settings.locales.some((locale) => isSupersetLocale(settings.defaultLocale, locale) &&
+            !isSupersetLocale(locale, settings.defaultLocale))) {
+        const locale = settings.locales.find((locale) => isSupersetLocale(settings.defaultLocale, locale));
+        logErrorAndExit(`defaultLocale: ${settings.defaultLocale} is a superset of another locale (${locale})! Please change the defaultLocale to a more specific locale.`);
+    }
+}
+export function validateConfigExists() {
+    const possibleConfigPaths = ['gt.config.json', 'src/gt.config.json'];
+    for (const possibleConfigPath of possibleConfigPaths) {
+        if (fs.existsSync(path.resolve(path.relative(process.cwd(), possibleConfigPath)))) {
+            return possibleConfigPath;
+        }
+    }
+    logErrorAndExit('No gt.config.json file found. Are you in the correct directory?');
+}

package/dist/console/colors.d.ts

@@ -0,0 +1,5 @@
+export declare function colorizeFilepath(filepath: string): string;
+export declare function colorizeComponent(component: string): string;
+export declare function colorizeIdString(id: string): string;
+export declare function colorizeContent(content: string): string;
+export declare function colorizeLine(line: string): string;

package/dist/console/colors.js

@@ -0,0 +1,16 @@
+import chalk from 'chalk';
+export function colorizeFilepath(filepath) {
+    return chalk.cyan(filepath);
+}
+export function colorizeComponent(component) {
+    return chalk.yellow(component);
+}
+export function colorizeIdString(id) {
+    return chalk.yellow(id);
+}
+export function colorizeContent(content) {
+    return chalk.yellow(content);
+}
+export function colorizeLine(line) {
+    return chalk.dim(line);
+}

package/dist/console/index.d.ts

@@ -0,0 +1,21 @@
+export declare const warnApiKeyInConfigSync: (optionsFilepath: string) => string;
+export declare const warnVariablePropSync: (file: string, attrName: string, value: string, location?: string) => string;
+export declare const warnHasUnwrappedExpressionSync: (file: string, unwrappedExpressions: string[], id?: string, location?: string) => string;
+export declare const warnNestedTComponent: (file: string, location?: string) => string;
+export declare const warnNonStaticExpressionSync: (file: string, attrName: string, value: string, location?: string) => string;
+export declare const warnTemplateLiteralSync: (file: string, value: string, location?: string) => string;
+export declare const warnNonStringSync: (file: string, value: string, location?: string) => string;
+export declare const warnAsyncUseGT: (file: string, location?: string) => string;
+export declare const warnSyncGetGT: (file: string, location?: string) => string;
+export declare const warnTernarySync: (file: string, location?: string) => string;
+export declare const withLocation: (file: string, message: string, location?: string) => string;
+export declare const noLocalesError = "No locales found! Please provide a list of locales to translate to, or specify them in your gt.config.json file.";
+export declare const noDefaultLocaleError = "No default locale found! Please provide a default locale, or specify it in your gt.config.json file.";
+export declare const noFilesError = "Incorrect or missing files configuration! Please make sure your files are configured correctly in your gt.config.json file.";
+export declare const noSourceFileError = "No source file found! Please double check your translations directory and default locale.";
+export declare const noSupportedFormatError = "Unsupported data format! Please make sure your translationsDir parameter ends with a supported file extension.";
+export declare const noApiKeyError = "No API key found! Please provide an API key using the --api-key flag or set the GT_API_KEY environment variable.";
+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

@@ -0,0 +1,24 @@
+import { colorizeFilepath, colorizeComponent, colorizeIdString, colorizeContent, colorizeLine, } from './colors.js';
+// Synchronous wrappers for backward compatibility
+export const warnApiKeyInConfigSync = (optionsFilepath) => `${colorizeFilepath(optionsFilepath)}: Your API key is exposed! Please remove it from the file and include it as an environment variable.`;
+export const warnVariablePropSync = (file, attrName, value, location) => withLocation(file, `${colorizeComponent('<T>')} component has dynamic attribute ${colorizeIdString(attrName)} with value: ${colorizeContent(value)}. Change ${colorizeIdString(attrName)} to ensure this content is translated.`, location);
+export const warnHasUnwrappedExpressionSync = (file, unwrappedExpressions, id, location) => withLocation(file, `${colorizeComponent('<T>')} component${id ? ` with id ${colorizeIdString(id)}` : ''} has children that could change at runtime. Use a variable component like ${colorizeComponent('<Var>')} to ensure this content is translated.\n${colorizeContent(unwrappedExpressions.join('\n'))}`, location);
+export const warnNestedTComponent = (file, location) => withLocation(file, `Found nested <T> component. <T> components cannot be directly nested.`, location);
+export const warnNonStaticExpressionSync = (file, attrName, value, location) => withLocation(file, `Found non-static expression for attribute ${colorizeIdString(attrName)}: ${colorizeContent(value)}. Change "${colorizeIdString(attrName)}" to ensure this content is translated.`, location);
+export const warnTemplateLiteralSync = (file, value, location) => withLocation(file, `Found template literal with quasis (${colorizeContent(value)}). Change the template literal to a string to ensure this content is translated.`, location);
+export const warnNonStringSync = (file, value, location) => withLocation(file, `Found non-string literal (${colorizeContent(value)}). Change the value to a string literal to ensure this content is translated.`, location);
+export const warnAsyncUseGT = (file, location) => withLocation(file, `Found useGT() in an async function. Use getGT() instead, or make the function synchronous.`, location);
+export const warnSyncGetGT = (file, location) => withLocation(file, `Found getGT() in a synchronous function. Use useGT() instead, or make the function async.`, location);
+export const warnTernarySync = (file, location) => withLocation(file, 'Found ternary expression. A Branch component may be more appropriate here.', location);
+export const withLocation = (file, message, location) => `${colorizeFilepath(file)}${location ? ` (${colorizeLine(location)})` : ''}: ${message}`;
+// Re-export error messages
+export const noLocalesError = `No locales found! Please provide a list of locales to translate to, or specify them in your gt.config.json file.`;
+export const noDefaultLocaleError = `No default locale found! Please provide a default locale, or specify it in your gt.config.json file.`;
+export const noFilesError = `Incorrect or missing files configuration! Please make sure your files are configured correctly in your gt.config.json file.`;
+export const noSourceFileError = `No source file found! Please double check your translations directory and default locale.`;
+export const noSupportedFormatError = `Unsupported data format! Please make sure your translationsDir parameter ends with a supported file extension.`;
+export const noApiKeyError = `No API key found! Please provide an API key using the --api-key flag or set the GT_API_KEY environment variable.`;
+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

@@ -0,0 +1,53 @@
+export declare function logInfo(message: string): void;
+export declare function logWarning(message: string): void;
+export declare function logError(message: string): void;
+export declare function logSuccess(message: string): void;
+export declare function logStep(message: string): void;
+export declare function logMessage(message: string): void;
+export declare function logErrorAndExit(message: string): never;
+export declare function exit(code: number): never;
+export declare function startCommand(message: string): void;
+export declare function endCommand(message: string): void;
+export declare function displayHeader(introString?: string): void;
+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, }: {
+    message: string;
+    defaultValue?: string;
+    validate?: (value: string) => boolean | string;
+}): Promise<string>;
+export declare function promptSelect<T>({ message, options, defaultValue, }: {
+    message: string;
+    options: Array<{
+        value: T;
+        label: string;
+        hint?: string;
+    }>;
+    defaultValue?: T;
+}): Promise<T>;
+export declare function promptMultiSelect<T extends string>({ message, options, required, }: {
+    message: string;
+    options: Array<{
+        value: T;
+        label: string;
+        hint?: string;
+    }>;
+    required?: boolean;
+}): Promise<T[]>;
+export declare function promptConfirm({ message, defaultValue, cancelMessage, }: {
+    message: string;
+    defaultValue?: boolean;
+    cancelMessage?: string;
+}): Promise<boolean>;
+export declare function warnApiKeyInConfig(optionsFilepath: string): void;
+export declare function warnVariableProp(file: string, attrName: string, value: string): void;
+export declare function warnNoId(file: string): void;
+export declare function warnHasUnwrappedExpression(file: string, id: string, unwrappedExpressions: string[]): void;
+export declare function warnNonStaticExpression(file: string, attrName: string, value: string): void;
+export declare function warnTemplateLiteral(file: string, value: string): void;
+export declare function warnTernary(file: string): void;