gt 0.10.0 → 2.7.0

package/dist/console/index.js

@@ -0,0 +1,46 @@
+import { BRANCH_COMPONENT } from '../react/jsx/utils/constants.js';
+import { colorizeFilepath, colorizeComponent, colorizeIdString, colorizeContent, colorizeLine, colorizeFunctionName, } from './colors.js';
+import { formatCodeClamp } from './formatting.js';
+const withWillErrorInNextVersion = (message) => `${message} (This will become an error in the next major version of the CLI.)`;
+// Static function related errors
+const withStaticError = (message) => `<Static> rules violation: ${message}`;
+const withDeclareStaticError = (message) => `declareStatic() rules violation: ${message}`;
+// 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 warnInvalidReturnSync = (file, functionName, expression, location) => withLocation(file, withStaticError(`Function ${colorizeFunctionName(functionName)} does not return a static expression. ${colorizeFunctionName(functionName)} must return either (1) a static string literal, (2) another static function invocation, (3) static JSX content, or (4) a ternary expression. Instead got:\n${colorizeContent(expression)}`), location);
+// TODO: this is temporary until we handle implicit returns
+export const warnMissingReturnSync = (file, functionName, location) => withLocation(file, `Function ${colorizeFunctionName(functionName)} is wrapped in ${colorizeComponent('<Static>')} tags but does have an explicit return statement. Static functions must have an explicit return statment.`, 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 warnFailedToConstructJsxTreeSync = (file, code, location) => withLocation(file, `Failed to construct JsxTree! Call expression is not a valid createElement call: ${colorizeContent(code)}`, 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 warnInvalidMaxCharsSync = (file, value, location) => withLocation(file, `Found invalid maxChars value: ${colorizeContent(value)}. Change the value to a valid number to ensure this content is translated.`, location);
+export const warnInvalidIcuSync = (file, value, error, location) => withWillErrorInNextVersion(withLocation(file, `Found invalid ICU string: ${colorizeContent(value)}. Change the value to a valid ICU to ensure this content is translated. Error message: ${error}.`, 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}`;
+export const warnFunctionNotFoundSync = (file, functionName, location) => withLocation(file, `Function ${colorizeFunctionName(functionName)} definition could not be resolved. This might affect translation resolution for this ${colorizeComponent('<T>')} component.`, location);
+export const warnInvalidDeclareVarNameSync = (file, value, location) => withLocation(file, `Found invalid declareVar() $name tag. Must be a static expression. Received: ${colorizeContent(value)}.`, location);
+export const warnDuplicateFunctionDefinitionSync = (file, functionName, location) => withLocation(file, `Function ${colorizeFunctionName(functionName)} is defined multiple times. Only the first definition will be used.`, location);
+export const warnInvalidStaticInitSync = (file, functionName, location) => withLocation(file, withStaticError(`The definition for ${colorizeFunctionName(functionName)} could not be resolved. When using arrow syntax to define a static function, the right hand side or the assignment MUST only contain the arrow function itself and no other expressions.
+Example: ${colorizeContent(`const ${colorizeFunctionName(functionName)} = () => { ... }`)}
+Invalid: ${colorizeContent(`const ${colorizeFunctionName(functionName)} = [() => { ... }][0]`)}`), location);
+export const warnDataAttrOnBranch = (file, attrName, location) => withLocation(file, `${colorizeComponent(`<${BRANCH_COMPONENT}>`)} component ignores attributes prefixed with ${colorizeIdString('"data-"')}. Found ${colorizeIdString(attrName)}. Remove it or use a different attribute name.`, location);
+export const warnRecursiveFunctionCallSync = (file, functionName, location) => withLocation(file, withStaticError(`Recursive function call detected: ${colorizeFunctionName(functionName)}. A static function cannot use recursive calls to construct its result.`), location);
+export const warnDeclareStaticNotWrappedSync = (file, functionName, location) => withLocation(file, withDeclareStaticError(`Could not resolve ${colorizeFunctionName(formatCodeClamp(functionName))}. This call is not wrapped in declareStatic(). Ensure the function is properly wrapped with declareStatic() and does not have circular import dependencies.`), location);
+export const warnDeclareStaticNoResultsSync = (file, functionName, location) => withLocation(file, withDeclareStaticError(`Could not resolve ${colorizeFunctionName(formatCodeClamp(functionName))}. DeclareStatic can only receive function invocations and cannot use undefined values or looped calls to construct its result.`), location);
+// Re-export error messages
+export const noLocalesError = `No locales found! Please provide a list of locales for translation, 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 gt 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/logger.d.ts

@@ -0,0 +1,35 @@
+import type { SpinnerResult, ProgressResult } from '@clack/prompts';
+export type LogFormat = 'default' | 'json';
+/**
+ * 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.
+ */
+declare class Logger {
+    private static instance;
+    private pinoLogger;
+    private fileLogger;
+    private logFormat;
+    private constructor();
+    static getInstance(): Logger;
+    trace(message: string): void;
+    debug(message: string): void;
+    info(message: string): void;
+    warn(message: string): void;
+    error(message: string): void;
+    fatal(message: string): void;
+    silent(message: string): void;
+    success(message: string): void;
+    step(message: string): void;
+    message(message: string, symbol?: string): void;
+    createSpinner(indicator?: 'dots' | 'timer'): SpinnerResult;
+    createProgressBar(total: number): ProgressResult;
+    startCommand(message: string): void;
+    endCommand(message: string): void;
+    flush(): void;
+}
+export declare const logger: Logger;
+export {};

package/dist/console/logger.js

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

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

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

@@ -0,0 +1,4 @@
+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[]>;