gtx-cli 2.3.5 → 2.3.6-alpha.1

package/dist/cli/react.js

@@ -1,175 +0,0 @@
-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

@@ -1,9 +0,0 @@
-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

@@ -1,176 +0,0 @@
-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

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

package/dist/config/optionPresets.js

@@ -1,56 +0,0 @@
-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

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

package/dist/config/resolveConfig.js

@@ -1,19 +0,0 @@
-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

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

package/dist/config/utils.js

@@ -1,4 +0,0 @@
-// 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

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

package/dist/config/validateSettings.js

@@ -1,32 +0,0 @@
-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

@@ -1,5 +0,0 @@
-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

@@ -1,16 +0,0 @@
-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

@@ -1,21 +0,0 @@
-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

@@ -1,24 +0,0 @@
-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

@@ -1,53 +0,0 @@
-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;