gtx-cli 2.6.31 → 2.7.0

package/dist/console/logger.js

@@ -1,250 +0,0 @@
-import chalk from 'chalk';
-import { randomUUID } from 'node:crypto';
-import { pino, destination } from 'pino';
-import { log as clackLog, spinner, progress, intro, outro, } from '@clack/prompts';
-// Mock spinner that logs to console instead of updating terminal UI
-class MockSpinner {
-    currentMessage = '';
-    logger;
-    isCancelled = false;
-    constructor(logger) {
-        this.logger = logger;
-    }
-    start(message) {
-        if (message) {
-            this.currentMessage = message;
-            this.logger.info(`[Spinner] ${message}`);
-        }
-    }
-    stop(message) {
-        const msg = message || this.currentMessage;
-        if (msg) {
-            this.logger.info(`[Spinner] ${msg}`);
-        }
-        this.currentMessage = '';
-    }
-    message(message) {
-        if (message) {
-            this.currentMessage = message;
-            this.logger.info(`[Spinner] ${message}`);
-        }
-    }
-}
-// Mock progress bar that logs to console instead of updating terminal UI
-class MockProgress {
-    max;
-    current = 0;
-    logger;
-    isCancelled = false;
-    constructor(max, logger) {
-        this.max = max;
-        this.logger = logger;
-    }
-    start(message) {
-        const msg = message || 'Starting progress';
-        this.logger.info(`[Progress] ${msg} (0/${this.max})`);
-    }
-    stop(message) {
-        const msg = message || 'Complete';
-        this.logger.info(`[Progress] ${msg} (${this.current}/${this.max})`);
-    }
-    message(message) {
-        if (message) {
-            this.logger.info(`[Progress] ${message} (${this.current}/${this.max})`);
-        }
-    }
-    advance(amount, message) {
-        this.current += amount;
-        const msg = message || 'Progress';
-        this.logger.info(`[Progress] ${msg} (${this.current}/${this.max})`);
-    }
-}
-/**
- * GT_LOG_FORMAT: default | json.
- * - If default, logs will be pretty-printed using @clack/prompts.
- * - If json, logs will be written in JSON format to the console.
- * GT_LOG_FILE: If specified, logs will be written to the file.
- * GT_LOG_LEVEL: The level of logs to write. If not specified, defaults to 'info'.
- * - Valid levels: debug, info, warn, error.
- */
-class Logger {
-    static instance;
-    pinoLogger = null;
-    fileLogger = null;
-    logFormat;
-    constructor() {
-        // Read configuration from environment variables
-        const format = (process.env.GT_LOG_FORMAT || 'default').toLowerCase();
-        const logFile = process.env.GT_LOG_FILE;
-        const logLevel = process.env.GT_LOG_LEVEL || 'info';
-        if (format !== 'default' && format !== 'json') {
-            console.error('Invalid log format');
-            process.exit(1);
-        }
-        if (logLevel !== 'debug' &&
-            logLevel !== 'info' &&
-            logLevel !== 'warn' &&
-            logLevel !== 'error') {
-            console.error('Invalid log level');
-            process.exit(1);
-        }
-        this.logFormat = format;
-        // Console output (stdout) - only for JSON format
-        // For 'default' format, we use @clack/prompts directly
-        if (format === 'json') {
-            this.pinoLogger = pino({
-                level: logLevel,
-                mixin: () => ({
-                    logId: randomUUID(),
-                }),
-            }, destination(1));
-        }
-        // File output (if specified) - always JSON format
-        if (logFile) {
-            this.fileLogger = pino({
-                level: logLevel,
-                mixin: () => ({
-                    logId: randomUUID(),
-                }),
-            }, destination(logFile));
-        }
-    }
-    static getInstance() {
-        if (!Logger.instance) {
-            Logger.instance = new Logger();
-        }
-        return Logger.instance;
-    }
-    // Standard logging methods
-    trace(message) {
-        if (this.logFormat === 'default') {
-            // @clack/prompts doesn't have trace, use message
-            clackLog.message(message, { symbol: chalk.dim('•') });
-        }
-        else {
-            this.pinoLogger?.trace(message);
-        }
-        this.fileLogger?.trace(message);
-    }
-    debug(message) {
-        if (this.logFormat === 'default') {
-            // @clack/prompts doesn't have debug, use message
-            clackLog.message(message, { symbol: chalk.dim('◆') });
-        }
-        else {
-            this.pinoLogger?.debug(message);
-        }
-        this.fileLogger?.debug(message);
-    }
-    info(message) {
-        if (this.logFormat === 'default') {
-            clackLog.info(message);
-        }
-        else {
-            this.pinoLogger?.info(message);
-        }
-        this.fileLogger?.info(message);
-    }
-    warn(message) {
-        if (this.logFormat === 'default') {
-            clackLog.warn(message);
-        }
-        else {
-            this.pinoLogger?.warn(message);
-        }
-        this.fileLogger?.warn(message);
-    }
-    error(message) {
-        if (this.logFormat === 'default') {
-            clackLog.error(message);
-        }
-        else {
-            this.pinoLogger?.error(message);
-        }
-        this.fileLogger?.error(message);
-    }
-    fatal(message) {
-        if (this.logFormat === 'default') {
-            clackLog.error(message); // @clack/prompts doesn't have fatal, use error
-        }
-        else {
-            this.pinoLogger?.fatal(message);
-        }
-        this.fileLogger?.fatal(message);
-    }
-    silent(message) {
-        // Silent doesn't log to console, only to file
-        this.fileLogger?.silent(message);
-    }
-    // @clack/prompts specific methods (for 'default' format)
-    success(message) {
-        if (this.logFormat === 'default') {
-            clackLog.success(message);
-        }
-        else {
-            this.pinoLogger?.info(message); // Map to info for non-default formats
-        }
-        this.fileLogger?.info(message);
-    }
-    step(message) {
-        if (this.logFormat === 'default') {
-            clackLog.step(message);
-        }
-        else {
-            this.pinoLogger?.info(message); // Map to info for non-default formats
-        }
-        this.fileLogger?.info(message);
-    }
-    message(message, symbol) {
-        if (this.logFormat === 'default') {
-            clackLog.message(message, symbol ? { symbol } : undefined);
-        }
-        else {
-            this.pinoLogger?.info(message); // Map to info for non-default formats
-        }
-        this.fileLogger?.info(message);
-    }
-    // Spinner functionality
-    createSpinner(indicator = 'timer') {
-        if (this.logFormat === 'default') {
-            return spinner({ indicator });
-        }
-        else {
-            return new MockSpinner(this);
-        }
-    }
-    // Progress bar functionality
-    createProgressBar(total) {
-        if (this.logFormat === 'default') {
-            return progress({ max: total });
-        }
-        else {
-            return new MockProgress(total, this);
-        }
-    }
-    // Command start/end markers
-    startCommand(message) {
-        if (this.logFormat === 'default') {
-            intro(chalk.cyan(message));
-        }
-        else {
-            this.info(`╭─ ${message}`);
-        }
-        this.fileLogger?.info(`[START] ${message}`);
-    }
-    endCommand(message) {
-        if (this.logFormat === 'default') {
-            outro(chalk.cyan(message));
-        }
-        else {
-            this.info(`╰─ ${message}`);
-        }
-        this.fileLogger?.info(`[END] ${message}`);
-    }
-    // Flush logs to ensure they're written before process exit
-    flush() {
-        this.pinoLogger?.flush();
-        this.fileLogger?.flush();
-    }
-}
-export const logger = Logger.getInstance();

package/dist/console/logging.d.ts

@@ -1,52 +0,0 @@
-import { FileToUpload } from 'generaltranslation/types';
-/**
- * Strip ANSI escape codes from a string (e.g., chalk color codes)
- */
-export declare function stripAnsi(str: string): string;
-export declare function logErrorAndExit(message: string): never;
-export declare function exitSync(code: number): never;
-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 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;
-/**
- * Helper: Log all collected files
- */
-export declare function logCollectedFiles(files: Pick<FileToUpload, 'fileName'>[], reactComponents?: number): void;

package/dist/console/logging.js

@@ -1,175 +0,0 @@
-import { text, select, confirm, isCancel, cancel, multiselect, } from '@clack/prompts';
-import chalk from 'chalk';
-import { getCLIVersion } from '../utils/packageJson.js';
-import { logger } from './logger.js';
-import { TEMPLATE_FILE_NAME } from '../utils/constants.js';
-/**
- * Strip ANSI escape codes from a string (e.g., chalk color codes)
- */
-export function stripAnsi(str) {
-    return str.replace(/\x1B\[[0-9;]*m/g, '');
-}
-export function logErrorAndExit(message) {
-    logger.error(message);
-    return exitSync(1);
-}
-export function exitSync(code) {
-    // Flush logs before exit
-    logger.flush();
-    process.exit(code);
-}
-// GT specific logging
-export function displayHeader(introString) {
-    displayAsciiTitle();
-    displayInitializingText();
-    if (introString) {
-        logger.startCommand(introString);
-    }
-}
-function displayAsciiTitle() {
-    console.log(chalk.cyan(`\n  ,ad8888ba,  888888888888  
- d8"'    \`"8b      88       
-d8'                88       
-88                 88       
-88      88888      88       
-Y8,        88      88       
- Y8a.    .a88      88       
-  \`"Y88888P"       88       `));
-}
-function displayInitializingText() {
-    const version = getCLIVersion();
-    console.log(`\n${chalk.bold.blue('General Translation, Inc.')}
-${chalk.dim('https://generaltranslation.com/docs')}
-${chalk.dim(`CLI Version: ${version}\n`)}`);
-}
-export function displayProjectId(projectId) {
-    logger.message(chalk.dim(`Project ID: ${chalk.bold(projectId)}`), chalk.cyan('~'));
-}
-export function displayResolvedPaths(resolvedPaths) {
-    const paths = resolvedPaths.map(([key, resolvedPath]) => {
-        return chalk.dim(`'${chalk.white(key)}' → '${chalk.green(resolvedPath)}'`);
-    });
-    logger.step(`Resolved path aliases:\n${paths.join('\n')}`);
-}
-export function displayCreatedConfigFile(configFilepath) {
-    logger.step(`Created config file ${chalk.cyan(configFilepath)}`);
-}
-export function displayUpdatedConfigFile(configFilepath) {
-    logger.success(`Updated config file ${chalk.cyan(configFilepath)}`);
-}
-export function displayUpdatedVersionsFile(versionFilepath) {
-    logger.success(`Updated versions file ${chalk.cyan(versionFilepath)}`);
-}
-// Input prompts
-export async function promptText({ message, defaultValue, validate, }) {
-    const result = await text({
-        message,
-        placeholder: defaultValue,
-        validate: validate
-            ? (value) => {
-                const validation = validate(value || '');
-                return validation === true ? undefined : validation.toString();
-            }
-            : undefined,
-    });
-    if (isCancel(result)) {
-        cancel('Operation cancelled');
-        return exitSync(0);
-    }
-    return result;
-}
-export async function promptSelect({ message, options, defaultValue, }) {
-    // Convert options to the format expected by clack
-    const clackOptions = options.map((opt) => ({
-        value: opt.value,
-        label: opt.label,
-        hint: opt.hint,
-    }));
-    const result = await select({
-        message,
-        options: clackOptions,
-        initialValue: defaultValue,
-    });
-    if (isCancel(result)) {
-        cancel('Operation cancelled');
-        return exitSync(0);
-    }
-    return result;
-}
-export async function promptMultiSelect({ message, options, required = true, }) {
-    // Convert options to the format expected by clack
-    const clackOptions = options.map((opt) => ({
-        value: opt.value,
-        label: opt.label,
-        hint: opt.hint,
-    }));
-    const result = await multiselect({
-        message,
-        options: clackOptions,
-        required,
-    });
-    if (isCancel(result)) {
-        cancel('Operation cancelled');
-        return exitSync(0);
-    }
-    return result;
-}
-export async function promptConfirm({ message, defaultValue = true, cancelMessage = 'Operation cancelled', }) {
-    const result = await confirm({
-        message,
-        initialValue: defaultValue,
-    });
-    if (isCancel(result)) {
-        cancel(cancelMessage);
-        return exitSync(0);
-    }
-    return result;
-}
-// Warning display functions
-export function warnApiKeyInConfig(optionsFilepath) {
-    logger.warn(`Found ${chalk.cyan('apiKey')} in "${chalk.green(optionsFilepath)}". ` +
-        chalk.white('Your API key is exposed! Please remove it from the file and include it as an environment variable.'));
-}
-export function warnVariableProp(file, attrName, value) {
-    logger.warn(`Found ${chalk.green('<T>')} component in ${chalk.cyan(file)} with variable ${attrName}: "${chalk.white(value)}". ` +
-        `Change "${attrName}" to ensure this content is translated.`);
-}
-export function warnNoId(file) {
-    logger.warn(`Found ${chalk.green('<T>')} component in ${chalk.cyan(file)} with no id. ` +
-        chalk.white('Add an id to ensure the content is translated.'));
-}
-export function warnHasUnwrappedExpression(file, id, unwrappedExpressions) {
-    logger.warn(`${chalk.green('<T>')} with id "${id}" in ${chalk.cyan(file)} has children: ${unwrappedExpressions.join(', ')} that could change at runtime. ` +
-        chalk.white('Use a variable component like ') +
-        chalk.green('<Var>') +
-        chalk.white(' (') +
-        chalk.blue('https://generaltranslation.com/docs') +
-        chalk.white(') to translate this properly.'));
-}
-export function warnNonStaticExpression(file, attrName, value) {
-    logger.warn(`Found non-static expression in ${chalk.cyan(file)} for attribute ${attrName}: "${chalk.white(value)}". ` +
-        `Change "${attrName}" to ensure this content is translated.`);
-}
-export function warnTemplateLiteral(file, value) {
-    logger.warn(`Found template literal with quasis (${value}) in ${chalk.cyan(file)}. ` +
-        chalk.white('Change the template literal to a string to ensure this content is translated.'));
-}
-export function warnTernary(file) {
-    logger.warn(`Found ternary expression in ${chalk.cyan(file)}. ` +
-        chalk.white('A Branch component may be more appropriate here.'));
-}
-/**
- * Helper: Log all collected files
- */
-export function logCollectedFiles(files, reactComponents) {
-    logger.message(chalk.cyan('Files found in project:') +
-        '\n' +
-        files
-            .map((file) => {
-            if (file.fileName === TEMPLATE_FILE_NAME) {
-                return `- <React Elements>${reactComponents ? ` (${reactComponents})` : ''}`;
-            }
-            return `- ${file.fileName}`;
-        })
-            .join('\n'));
-}

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

@@ -1,4 +0,0 @@
-import { Settings } from '../../types/index.js';
-import type { FileToUpload } from '../../types/data.js';
-export declare const SUPPORTED_DATA_FORMATS: string[];
-export declare function aggregateFiles(settings: Settings): Promise<FileToUpload[]>;

package/dist/formats/files/aggregateFiles.js

@@ -1,156 +0,0 @@
-import { logger } from '../../console/logger.js';
-import { recordWarning } from '../../state/translateWarnings.js';
-import { getRelative, readFile } from '../../fs/findFilepath.js';
-import { SUPPORTED_FILE_EXTENSIONS } from './supportedFiles.js';
-import { parseJson } from '../json/parseJson.js';
-import parseYaml from '../yaml/parseYaml.js';
-import YAML from 'yaml';
-import { determineLibrary } from '../../fs/determineFramework.js';
-import { hashStringSync } from '../../utils/hash.js';
-import { preprocessContent } from './preprocessContent.js';
-export const SUPPORTED_DATA_FORMATS = ['JSX', 'ICU', 'I18NEXT'];
-export async function aggregateFiles(settings) {
-    // Aggregate all files to translate
-    const allFiles = [];
-    if (!settings.files ||
-        (Object.keys(settings.files.placeholderPaths).length === 1 &&
-            settings.files.placeholderPaths.gt)) {
-        return allFiles;
-    }
-    const { resolvedPaths: filePaths } = settings.files;
-    const skipValidation = settings.options?.skipFileValidation;
-    // Process JSON files
-    if (filePaths.json) {
-        const { library, additionalModules } = determineLibrary();
-        // Determine dataFormat for JSONs
-        let dataFormat;
-        if (library === 'next-intl') {
-            dataFormat = 'ICU';
-        }
-        else if (library === 'i18next') {
-            if (additionalModules.includes('i18next-icu')) {
-                dataFormat = 'ICU';
-            }
-            else {
-                dataFormat = 'I18NEXT';
-            }
-        }
-        else {
-            dataFormat = 'STRING';
-        }
-        const jsonFiles = filePaths.json
-            .map((filePath) => {
-            const content = readFile(filePath);
-            const relativePath = getRelative(filePath);
-            // Pre-validate JSON parseability
-            if (!skipValidation?.json) {
-                try {
-                    JSON.parse(content);
-                }
-                catch (e) {
-                    logger.warn(`Skipping ${relativePath}: JSON file is not parsable`);
-                    recordWarning('skipped_file', relativePath, 'JSON file is not parsable');
-                    return null;
-                }
-            }
-            const parsedJson = parseJson(content, filePath, settings.options || {}, settings.defaultLocale);
-            return {
-                fileId: hashStringSync(relativePath),
-                versionId: hashStringSync(parsedJson),
-                content: parsedJson,
-                fileName: relativePath,
-                fileFormat: 'JSON',
-                dataFormat,
-                locale: settings.defaultLocale,
-            };
-        })
-            .filter((file) => {
-            if (!file)
-                return false;
-            if (typeof file.content !== 'string' || !file.content.trim()) {
-                logger.warn(`Skipping ${file.fileName}: JSON file is empty`);
-                recordWarning('skipped_file', file.fileName, 'JSON file is empty');
-                return false;
-            }
-            return true;
-        });
-        allFiles.push(...jsonFiles.filter((file) => file !== null));
-    }
-    // Process YAML files
-    if (filePaths.yaml) {
-        const yamlFiles = filePaths.yaml
-            .map((filePath) => {
-            const content = readFile(filePath);
-            const relativePath = getRelative(filePath);
-            // Pre-validate YAML parseability
-            if (!skipValidation?.yaml) {
-                try {
-                    YAML.parse(content);
-                }
-                catch (e) {
-                    logger.warn(`Skipping ${relativePath}: YAML file is not parsable`);
-                    recordWarning('skipped_file', relativePath, 'YAML file is not parsable');
-                    return null;
-                }
-            }
-            const { content: parsedYaml, fileFormat } = parseYaml(content, filePath, settings.options || {});
-            return {
-                content: parsedYaml,
-                fileName: relativePath,
-                fileFormat,
-                fileId: hashStringSync(relativePath),
-                versionId: hashStringSync(parsedYaml),
-                locale: settings.defaultLocale,
-            };
-        })
-            .filter((file) => {
-            if (!file || typeof file.content !== 'string' || !file.content.trim()) {
-                logger.warn(`Skipping ${file?.fileName ?? 'unknown'}: YAML file is empty`);
-                recordWarning('skipped_file', file?.fileName ?? 'unknown', 'YAML file is empty');
-                return false;
-            }
-            return true;
-        });
-        allFiles.push(...yamlFiles.filter((file) => file !== null));
-    }
-    for (const fileType of SUPPORTED_FILE_EXTENSIONS) {
-        if (fileType === 'json' || fileType === 'yaml')
-            continue;
-        if (filePaths[fileType]) {
-            const files = filePaths[fileType]
-                .map((filePath) => {
-                const content = readFile(filePath);
-                const relativePath = getRelative(filePath);
-                const processed = preprocessContent(content, relativePath, fileType, settings);
-                if (typeof processed !== 'string') {
-                    logger.warn(`Skipping ${relativePath}: ${processed.skip}`);
-                    recordWarning('skipped_file', relativePath, processed.skip);
-                    return null;
-                }
-                return {
-                    content: processed,
-                    fileName: relativePath,
-                    fileFormat: fileType.toUpperCase(),
-                    fileId: hashStringSync(relativePath),
-                    versionId: hashStringSync(content),
-                    locale: settings.defaultLocale,
-                };
-            })
-                .filter((file) => {
-                if (!file ||
-                    typeof file.content !== 'string' ||
-                    !file.content.trim()) {
-                    logger.warn(`Skipping ${file?.fileName ?? 'unknown'}: File is empty after sanitization`);
-                    recordWarning('skipped_file', file?.fileName ?? 'unknown', 'File is empty after sanitization');
-                    return false;
-                }
-                return true;
-            });
-            allFiles.push(...files.filter((file) => file !== null));
-        }
-    }
-    if (allFiles.length === 0 && !settings.publish) {
-        logger.error('No files to translate were found. Please check your configuration and try again.');
-    }
-    return allFiles;
-}

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

@@ -1,6 +0,0 @@
-import { Settings, SupportedLibraries, TranslateFlags } from '../../types/index.js';
-import type { FileToUpload } from 'generaltranslation/types';
-export declare function collectFiles(options: TranslateFlags, settings: Settings, library: SupportedLibraries): Promise<{
-    files: FileToUpload[];
-    reactComponents: number;
-}>;

package/dist/formats/files/collectFiles.js

@@ -1,49 +0,0 @@
-import { logErrorAndExit } from '../../console/logging.js';
-import { invalidConfigurationError } from '../../console/index.js';
-import { aggregateFiles } from './aggregateFiles.js';
-import { aggregateInlineTranslations } from '../../translation/stage.js';
-import { hashStringSync } from '../../utils/hash.js';
-import { TEMPLATE_FILE_NAME, TEMPLATE_FILE_ID } from '../../utils/constants.js';
-import { isInlineLibrary } from '../../types/libraries.js';
-export async function collectFiles(options, settings, library) {
-    // Aggregate files
-    const allFiles = await aggregateFiles(settings);
-    // Parse for React components
-    let reactComponents = 0;
-    if (isInlineLibrary(library)) {
-        const updates = await aggregateInlineTranslations(options, settings, library);
-        if (updates.length > 0) {
-            if (!settings.publish && !settings.files?.placeholderPaths.gt) {
-                logErrorAndExit(invalidConfigurationError);
-            }
-            // Convert updates to a file object
-            const fileData = {};
-            const fileMetadata = {};
-            // Convert updates to the proper data format
-            for (const update of updates) {
-                const { source, metadata, dataFormat } = update;
-                metadata.dataFormat = dataFormat; // add the data format to the metadata
-                const { hash, id } = metadata;
-                if (id) {
-                    fileData[id] = source;
-                    fileMetadata[id] = metadata;
-                }
-                else {
-                    fileData[hash] = source;
-                    fileMetadata[hash] = metadata;
-                }
-            }
-            reactComponents = updates.length;
-            allFiles.push({
-                fileName: TEMPLATE_FILE_NAME,
-                content: JSON.stringify(fileData),
-                fileFormat: 'GTJSON',
-                formatMetadata: fileMetadata,
-                fileId: TEMPLATE_FILE_ID,
-                versionId: hashStringSync(JSON.stringify(Object.keys(fileData).sort())),
-                locale: settings.defaultLocale,
-            });
-        }
-    }
-    return { files: allFiles, reactComponents };
-}