gtx-cli 2.6.31 → 2.7.0

package/dist/cli/commands/setupProject.js

@@ -1,37 +0,0 @@
-import { logger } from '../../console/logger.js';
-import { exitSync, logCollectedFiles } from '../../console/logging.js';
-import { collectFiles } from '../../formats/files/collectFiles.js';
-import { runSetupProjectWorkflow } from '../../workflows/setupProject.js';
-import { hasValidCredentials, hasValidLocales } from './utils/validation.js';
-export async function handleSetupProject(options, settings, library) {
-    if (!hasValidLocales(settings))
-        return exitSync(1);
-    // Validate credentials if not in dry run
-    if (!options.dryRun && !hasValidCredentials(settings))
-        return exitSync(1);
-    const { files: allFiles, reactComponents } = await collectFiles(options, settings, library);
-    // Dry run
-    if (options.dryRun) {
-        logger.success(`Dry run: No files were uploaded to General Translation.`);
-        logCollectedFiles(allFiles, reactComponents);
-        return null;
-    }
-    // Upload files and run setup step
-    let fileVersionData;
-    let branchData;
-    if (allFiles.length > 0) {
-        const { branchData: branchDataResult } = await runSetupProjectWorkflow(allFiles, options, settings);
-        branchData = branchDataResult;
-        fileVersionData = Object.fromEntries(allFiles.map((file) => [
-            file.fileId,
-            {
-                fileName: file.fileName,
-                versionId: file.versionId,
-            },
-        ]));
-    }
-    return {
-        fileVersionData,
-        branchData,
-    };
-}

package/dist/cli/commands/stage.d.ts

@@ -1,9 +0,0 @@
-import { Settings, SupportedLibraries, TranslateFlags } from '../../types/index.js';
-import type { EnqueueFilesResult } from 'generaltranslation/types';
-import { FileTranslationData } from '../../workflows/download.js';
-import { BranchData } from '../../types/branch.js';
-export declare function handleStage(options: TranslateFlags, settings: Settings, library: SupportedLibraries, stage: boolean): Promise<{
-    fileVersionData: FileTranslationData | undefined;
-    jobData: EnqueueFilesResult | undefined;
-    branchData: BranchData | undefined;
-} | null>;

package/dist/cli/commands/stage.js

@@ -1,59 +0,0 @@
-import { logger } from '../../console/logger.js';
-import { exitSync, logCollectedFiles } from '../../console/logging.js';
-import { runStageFilesWorkflow } from '../../workflows/stage.js';
-import { updateVersions } from '../../fs/config/updateVersions.js';
-import updateConfig from '../../fs/config/updateConfig.js';
-import { TEMPLATE_FILE_ID } from '../../utils/constants.js';
-import { collectFiles } from '../../formats/files/collectFiles.js';
-import { convertToFileTranslationData } from '../../formats/files/convertToFileTranslationData.js';
-import { hasValidCredentials, hasValidLocales } from './utils/validation.js';
-export async function handleStage(options, settings, library, stage) {
-    if (!hasValidLocales(settings))
-        return exitSync(1);
-    // Validate credentials if not in dry run
-    if (!options.dryRun && !hasValidCredentials(settings))
-        return exitSync(1);
-    const { files: allFiles, reactComponents } = await collectFiles(options, settings, library);
-    // Dry run
-    if (options.dryRun) {
-        logger.success(`Dry run: No files were sent to General Translation.`);
-        logCollectedFiles(allFiles, reactComponents);
-        return null;
-    }
-    // Send translations to General Translation
-    let fileVersionData;
-    let jobData;
-    let branchData;
-    if (allFiles.length > 0) {
-        const { branchData: branchDataResult, enqueueResult } = await runStageFilesWorkflow({ files: allFiles, options, settings });
-        jobData = enqueueResult;
-        branchData = branchDataResult;
-        fileVersionData = convertToFileTranslationData(allFiles);
-        // This logic is a little scuffed because stage is async from the API
-        if (stage) {
-            await updateVersions({
-                configDirectory: settings.configDirectory,
-                versionData: fileVersionData,
-            });
-        }
-        const templateData = allFiles.find((file) => file.fileId === TEMPLATE_FILE_ID);
-        if (templateData?.versionId) {
-            await updateConfig(settings.config, {
-                _versionId: templateData.versionId,
-                _branchId: branchData.currentBranch.id,
-            });
-        }
-    }
-    // Always delete branch id from config if branching is disabled
-    // Avoids incorrect CDN queries at runtime
-    if (!settings.branchOptions.enabled) {
-        await updateConfig(settings.config, {
-            _branchId: null,
-        });
-    }
-    return {
-        fileVersionData,
-        jobData,
-        branchData,
-    };
-}

package/dist/cli/commands/translate.d.ts

@@ -1,7 +0,0 @@
-import { EnqueueFilesResult } from 'generaltranslation/types';
-import { TranslateFlags } from '../../types/index.js';
-import { Settings } from '../../types/index.js';
-import { FileTranslationData } from '../../workflows/download.js';
-import { BranchData } from '../../types/branch.js';
-export declare function handleTranslate(options: TranslateFlags, settings: Settings, fileVersionData: FileTranslationData | undefined, jobData: EnqueueFilesResult | undefined, branchData: BranchData | undefined): Promise<void>;
-export declare function postProcessTranslations(settings: Settings, includeFiles?: Set<string>): Promise<void>;

package/dist/cli/commands/translate.js

@@ -1,70 +0,0 @@
-import { runDownloadWorkflow, } from '../../workflows/download.js';
-import { createFileMapping } from '../../formats/files/fileMapping.js';
-import copyFile from '../../fs/copyFile.js';
-import flattenJsonFiles from '../../utils/flattenJsonFiles.js';
-import localizeStaticUrls from '../../utils/localizeStaticUrls.js';
-import localizeRelativeAssets from '../../utils/localizeRelativeAssets.js';
-import processAnchorIds from '../../utils/processAnchorIds.js';
-import processOpenApi from '../../utils/processOpenApi.js';
-import localizeStaticImports from '../../utils/localizeStaticImports.js';
-import { getDownloadedMeta } from '../../state/recentDownloads.js';
-import { persistPostProcessHashes } from '../../utils/persistPostprocessHashes.js';
-// Downloads translations that were completed
-export async function handleTranslate(options, settings, fileVersionData, jobData, branchData) {
-    if (fileVersionData) {
-        const { resolvedPaths, placeholderPaths, transformPaths } = settings.files;
-        const fileMapping = createFileMapping(resolvedPaths, placeholderPaths, transformPaths, settings.locales, settings.defaultLocale);
-        // Check for remaining translations
-        await runDownloadWorkflow({
-            fileVersionData: fileVersionData,
-            jobData: jobData,
-            branchData: branchData,
-            locales: settings.locales,
-            timeoutDuration: options.timeout,
-            resolveOutputPath: (sourcePath, locale) => fileMapping[locale]?.[sourcePath] ?? null,
-            options: settings,
-            forceRetranslation: options.force,
-            forceDownload: options.forceDownload || options.force, // if force is true should also force download
-        });
-    }
-}
-export async function postProcessTranslations(settings, includeFiles) {
-    // Mintlify OpenAPI localization (spec routing + validation)
-    await processOpenApi(settings, includeFiles);
-    // Localize static urls (/docs -> /[locale]/docs) and preserve anchor IDs for non-default locales
-    // Default locale is processed earlier in the flow in base.ts
-    if (settings.options?.experimentalLocalizeStaticUrls) {
-        const nonDefaultLocales = settings.locales.filter((locale) => locale !== settings.defaultLocale);
-        if (nonDefaultLocales.length > 0) {
-            await localizeStaticUrls(settings, nonDefaultLocales, includeFiles);
-        }
-    }
-    // Rewrite relative asset URLs in translated md/mdx files
-    if (settings.options?.experimentalLocalizeRelativeAssets) {
-        const nonDefaultLocales = settings.locales.filter((locale) => locale !== settings.defaultLocale);
-        if (nonDefaultLocales.length > 0) {
-            await localizeRelativeAssets(settings, nonDefaultLocales, includeFiles);
-        }
-    }
-    const shouldProcessAnchorIds = settings.options?.experimentalLocalizeStaticUrls ||
-        settings.options?.experimentalAddHeaderAnchorIds;
-    // Add explicit anchor IDs to translated MDX/MD files to preserve navigation
-    // Uses inline {#id} format by default, or div wrapping if experimentalAddHeaderAnchorIds is 'mintlify'
-    if (shouldProcessAnchorIds) {
-        await processAnchorIds(settings, includeFiles);
-    }
-    // Localize static imports (import Snippet from /snippets/file.mdx -> import Snippet from /snippets/[locale]/file.mdx)
-    if (settings.options?.experimentalLocalizeStaticImports) {
-        await localizeStaticImports(settings, includeFiles);
-    }
-    // Flatten json files into a single file
-    if (settings.options?.experimentalFlattenJsonFiles) {
-        await flattenJsonFiles(settings, includeFiles);
-    }
-    // Copy files to the target locale
-    if (settings.options?.copyFiles) {
-        await copyFile(settings);
-    }
-    // Record postprocessed content hashes for newly downloaded files
-    persistPostProcessHashes(settings, includeFiles, getDownloadedMeta());
-}

package/dist/cli/commands/upload.d.ts

@@ -1,13 +0,0 @@
-import { ResolvedFiles, Settings, TransformFiles } from '../../types/index.js';
-import { DataFormat } from '../../types/data.js';
-import { UploadOptions } from '../base.js';
-/**
- * Sends multiple files to the API for translation
- * @param filePaths - Resolved file paths for different file types
- * @param placeholderPaths - Placeholder paths for translated files
- * @param transformPaths - Transform paths for file naming
- * @param dataFormat - Format of the data within the files
- * @param settings - Translation options including API settings
- * @returns Promise that resolves when translation is complete
- */
-export declare function upload(filePaths: ResolvedFiles, placeholderPaths: ResolvedFiles, transformPaths: TransformFiles, dataFormat: DataFormat | undefined, settings: Settings & UploadOptions): Promise<void>;

package/dist/cli/commands/upload.js

@@ -1,142 +0,0 @@
-import { noSupportedFormatError, noDefaultLocaleError, } from '../../console/index.js';
-import { exitSync, logErrorAndExit } from '../../console/logging.js';
-import { logger } from '../../console/logger.js';
-import { getRelative, readFile } from '../../fs/findFilepath.js';
-import { SUPPORTED_FILE_EXTENSIONS } from '../../formats/files/supportedFiles.js';
-import sanitizeFileContent from '../../utils/sanitizeFileContent.js';
-import { parseJson } from '../../formats/json/parseJson.js';
-import { runUploadFilesWorkflow } from '../../workflows/upload.js';
-import { existsSync, readFileSync } from 'node:fs';
-import { createFileMapping } from '../../formats/files/fileMapping.js';
-import parseYaml from '../../formats/yaml/parseYaml.js';
-import { hashStringSync } from '../../utils/hash.js';
-import { hasValidCredentials } from './utils/validation.js';
-const SUPPORTED_DATA_FORMATS = ['JSX', 'ICU', 'I18NEXT'];
-/**
- * Sends multiple files to the API for translation
- * @param filePaths - Resolved file paths for different file types
- * @param placeholderPaths - Placeholder paths for translated files
- * @param transformPaths - Transform paths for file naming
- * @param dataFormat - Format of the data within the files
- * @param settings - Translation options including API settings
- * @returns Promise that resolves when translation is complete
- */
-export async function upload(filePaths, placeholderPaths, transformPaths, dataFormat = 'JSX', settings) {
-    // Collect all files to translate
-    const allFiles = [];
-    const additionalOptions = settings.options || {};
-    // Process JSON files
-    if (filePaths.json) {
-        if (!SUPPORTED_DATA_FORMATS.includes(dataFormat)) {
-            logErrorAndExit(noSupportedFormatError);
-        }
-        const jsonFiles = filePaths.json.map((filePath) => {
-            const content = readFile(filePath);
-            const parsedJson = parseJson(content, filePath, additionalOptions, settings.defaultLocale);
-            const relativePath = getRelative(filePath);
-            return {
-                content: parsedJson,
-                fileName: relativePath,
-                fileFormat: 'JSON',
-                dataFormat,
-                locale: settings.defaultLocale,
-                fileId: hashStringSync(relativePath),
-                versionId: hashStringSync(parsedJson),
-            };
-        });
-        allFiles.push(...jsonFiles);
-    }
-    // Process YAML files
-    if (filePaths.yaml) {
-        if (!SUPPORTED_DATA_FORMATS.includes(dataFormat)) {
-            logErrorAndExit(noSupportedFormatError);
-        }
-        const yamlFiles = filePaths.yaml.map((filePath) => {
-            const content = readFile(filePath);
-            const { content: parsedYaml, fileFormat } = parseYaml(content, filePath, additionalOptions);
-            const relativePath = getRelative(filePath);
-            return {
-                content: parsedYaml,
-                fileName: relativePath,
-                fileFormat,
-                dataFormat,
-                locale: settings.defaultLocale,
-                fileId: hashStringSync(relativePath),
-                versionId: hashStringSync(parsedYaml),
-            };
-        });
-        allFiles.push(...yamlFiles);
-    }
-    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 sanitizedContent = sanitizeFileContent(content);
-                const relativePath = getRelative(filePath);
-                return {
-                    content: sanitizedContent,
-                    fileName: relativePath,
-                    fileFormat: fileType.toUpperCase(),
-                    dataFormat,
-                    locale: settings.defaultLocale,
-                    fileId: hashStringSync(relativePath),
-                    versionId: hashStringSync(sanitizedContent),
-                };
-            });
-            allFiles.push(...files);
-        }
-    }
-    if (allFiles.length === 0) {
-        logger.error('No files to upload were found. Please check your configuration and try again.');
-        return;
-    }
-    if (!settings.defaultLocale) {
-        return logErrorAndExit(noDefaultLocaleError);
-    }
-    if (!hasValidCredentials(settings))
-        return exitSync(1);
-    const locales = settings.locales || [];
-    // Create file mapping for all file types
-    const fileMapping = createFileMapping(filePaths, placeholderPaths, transformPaths, locales, settings.defaultLocale);
-    // construct object
-    const uploadData = allFiles.map((file) => {
-        const sourceFile = {
-            content: file.content,
-            fileName: file.fileName,
-            fileFormat: file.fileFormat,
-            dataFormat: file.dataFormat,
-            locale: file.locale,
-            fileId: file.fileId,
-            versionId: file.versionId,
-        };
-        const translations = [];
-        for (const locale of locales) {
-            const translatedFileName = fileMapping[locale][file.fileName];
-            if (translatedFileName && existsSync(translatedFileName)) {
-                const translatedContent = readFileSync(translatedFileName, 'utf8');
-                translations.push({
-                    content: translatedContent,
-                    fileName: file.fileName,
-                    fileFormat: file.fileFormat,
-                    dataFormat: file.dataFormat,
-                    locale,
-                    fileId: file.fileId,
-                    versionId: file.versionId,
-                });
-            }
-        }
-        return {
-            source: sourceFile,
-            translations,
-        };
-    });
-    try {
-        // Send all files in a single API call
-        await runUploadFilesWorkflow({ files: uploadData, options: settings });
-    }
-    catch (error) {
-        logErrorAndExit(`Error uploading files: ${error}`);
-    }
-}

package/dist/cli/commands/utils/validation.d.ts

@@ -1,13 +0,0 @@
-import { Settings } from '../../../types/index.js';
-/**
- * Validate locales
- * @param settings - The settings to validate
- * @returns True if has locales and default locale
- */
-export declare function hasValidLocales(settings: Settings): boolean;
-/**
- * Validate credentials
- * @param settings - The settings to validate
- * @returns True if has API key, project ID, and does not have a development API key
- */
-export declare function hasValidCredentials(settings: Settings): boolean;

package/dist/cli/commands/utils/validation.js

@@ -1,38 +0,0 @@
-import { noDefaultLocaleError, noLocalesError, noApiKeyError, devApiKeyError, noProjectIdError, } from '../../../console/index.js';
-import { logger } from '../../../console/logger.js';
-/**
- * Validate locales
- * @param settings - The settings to validate
- * @returns True if has locales and default locale
- */
-export function hasValidLocales(settings) {
-    if (!settings.locales) {
-        logger.error(noLocalesError);
-        return false;
-    }
-    if (!settings.defaultLocale) {
-        logger.error(noDefaultLocaleError);
-        return false;
-    }
-    return true;
-}
-/**
- * Validate credentials
- * @param settings - The settings to validate
- * @returns True if has API key, project ID, and does not have a development API key
- */
-export function hasValidCredentials(settings) {
-    if (!settings.apiKey) {
-        logger.error(noApiKeyError);
-        return false;
-    }
-    if (settings.apiKey.startsWith('gtx-dev-')) {
-        logger.error(devApiKeyError);
-        return false;
-    }
-    if (!settings.projectId) {
-        logger.error(noProjectIdError);
-        return false;
-    }
-    return true;
-}

package/dist/cli/flags.d.ts

@@ -1,15 +0,0 @@
-import { Command } from 'commander';
-export declare function attachSharedFlags(command: Command): Command;
-export declare function attachTranslateFlags(command: Command): Command;
-/**
- * Attaches flags necessary for validating a project
- * @param command
- * @returns The command with the validate flags attached
- */
-export declare function attachValidateFlags(command: Command): Command;
-/**
- * Attaches flags necessary for translating a project
- * @param command
- * @returns The command with the translate flags attached
- */
-export declare function attachInlineTranslateFlags(command: Command): Command;

package/dist/cli/flags.js

@@ -1,70 +0,0 @@
-import findFilepath from '../fs/findFilepath.js';
-import { DEFAULT_GIT_REMOTE_NAME } from '../utils/constants.js';
-const DEFAULT_TIMEOUT = 600;
-export function attachSharedFlags(command) {
-    command
-        .option('-c, --config <path>', 'Filepath to config file, by default gt.config.json', findFilepath(['gt.config.json']))
-        .option('--api-key <key>', 'API key for General Translation cloud service')
-        .option('--project-id <id>', 'General Translation project ID');
-    return command;
-}
-export function attachTranslateFlags(command) {
-    attachSharedFlags(command)
-        .option('--version-id <id>', 'General Translation version ID')
-        .option('--default-language, --default-locale <locale>', 'Default locale (e.g., en)')
-        .option('--new, --locales <locales...>', 'Space-separated list of locales (e.g., en fr es)')
-        .option('--dry-run', 'Dry run, do not send updates to the General Translation API', false)
-        .option('--timeout <seconds>', 'Translation wait timeout in seconds', (value) => {
-        const parsedValue = parseInt(value, 10);
-        if (isNaN(parsedValue)) {
-            throw new Error('Invalid timeout: not a number.');
-        }
-        if (parsedValue < 0) {
-            throw new Error('Invalid timeout: must be a positive number.');
-        }
-        return parsedValue;
-    }, DEFAULT_TIMEOUT)
-        .option('--save-local', 'Detect and save local edits before enqueuing translations', false)
-        .option('--publish', 'Publish translations to the CDN', false)
-        .option('--experimental-localize-static-urls', 'Triggering this will run a script after the cli tool that localizes all urls in content files. Currently only supported for md and mdx files.', false)
-        .option('--experimental-hide-default-locale', 'When localizing static locales, hide the default locale from the path', false)
-        .option('--experimental-flatten-json-files', 'Triggering this will flatten the json files into a single file. This is useful for projects that have a lot of json files.', false)
-        .option('--experimental-localize-static-imports', 'Triggering this will run a script after the cli tool that localizes all static imports in content files. Currently only supported for md and mdx files.', false)
-        .option('--experimental-localize-relative-assets', 'Triggering this will rewrite relative image asset URLs in translated md/mdx files to valid paths.', false)
-        .option('--force', 'Force a retranslation, invalidating all existing cached translations if they exist.', false)
-        .option('--force-download', 'Force download and overwrite local files, bypassing gt-lock.json checks.', false)
-        .option('--experimental-clear-locale-dirs', 'Clear locale directories before downloading new translations', false)
-        .option('--branch <branch>', 'Specify a custom branch to use for translations')
-        .option('--disable-branch-detection', 'Disable additional branch detection and optimizations and use the manually specified branch', false)
-        .option('--enable-branching', 'Enable branching for the project')
-        .option('--remote-name <name>', 'Specify a custom remote name to use for branch detection', DEFAULT_GIT_REMOTE_NAME);
-    return command;
-}
-/**
- * Attaches flags necessary for parsing inline content
- * @param command - The command to attach the flags to
- * @returns The command with the inline content parsing flags attached
- */
-function attachInlineContentParsingFlags(command) {
-    return command
-        .option('--tsconfig, --jsconfig <path>', 'Path to custom 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 content in translations (e.g., inline jsx translations, inline string translations, etc.)', true);
-}
-/**
- * Attaches flags necessary for validating a project
- * @param command
- * @returns The command with the validate flags attached
- */
-export function attachValidateFlags(command) {
-    return attachInlineContentParsingFlags(command.option('-c, --config <path>', 'Filepath to config file, by default gt.config.json', findFilepath(['gt.config.json'])));
-}
-/**
- * Attaches flags necessary for translating a project
- * @param command
- * @returns The command with the translate flags attached
- */
-export function attachInlineTranslateFlags(command) {
-    return attachInlineContentParsingFlags(command.option('--ignore-errors', 'Ignore errors encountered while scanning for inline content', false));
-}

package/dist/cli/inline.d.ts

@@ -1,17 +0,0 @@
-import { Command } from 'commander';
-import { BaseCLI } from './base.js';
-import { SupportedLibraries, TranslateFlags, Options } from '../types/index.js';
-import { InlineLibrary } from '../types/libraries.js';
-/**
- * Stand in for a CLI tool that does any sort of inline content translations
- */
-export declare class InlineCLI extends BaseCLI {
-    constructor(command: Command, library: InlineLibrary, additionalModules?: SupportedLibraries[]);
-    init(): void;
-    protected setupStageCommand(): void;
-    protected setupTranslateCommand(): void;
-    protected setupValidateCommand(): void;
-    protected setupGenerateSourceCommand(): void;
-    protected handleGenerateSourceCommand(initOptions: TranslateFlags): Promise<void>;
-    protected handleValidate(initOptions: Options, files?: string[]): Promise<void>;
-}

package/dist/cli/inline.js

@@ -1,135 +0,0 @@
-import { BaseCLI } from './base.js';
-import { attachInlineTranslateFlags, attachTranslateFlags, attachValidateFlags, } from './flags.js';
-import { displayHeader, exitSync } from '../console/logging.js';
-import { logger } from '../console/logger.js';
-import { intro } from '@clack/prompts';
-import chalk from 'chalk';
-import { resolveLocaleFiles } from '../fs/config/parseFilesConfig.js';
-import { noFilesError } from '../console/index.js';
-import { saveJSON } from '../fs/saveJSON.js';
-import loadJSON from '../fs/loadJSON.js';
-import { generateSettings } from '../config/generateSettings.js';
-import { aggregateInlineTranslations } from '../translation/stage.js';
-import { validateConfigExists } from '../config/validateSettings.js';
-import { validateProject } from '../translation/validate.js';
-import { Libraries } from '../types/libraries.js';
-/**
- * Stand in for a CLI tool that does any sort of inline content translations
- */
-export class InlineCLI extends BaseCLI {
-    constructor(command, library, additionalModules) {
-        super(command, library, additionalModules);
-    }
-    init() {
-        this.setupStageCommand();
-        this.setupTranslateCommand();
-        this.setupGenerateSourceCommand();
-        this.setupValidateCommand();
-        this.setupDownloadCommand();
-        this.setupEnqueueCommand();
-    }
-    setupStageCommand() {
-        attachInlineTranslateFlags(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);
-            logger.endCommand('Done!');
-        });
-    }
-    setupTranslateCommand() {
-        attachInlineTranslateFlags(attachTranslateFlags(this.program
-            .command('translate')
-            .description('Scans the project for a dictionary and inline translations and sends the updates to the General Translation API for translation.'))).action(async (options) => {
-            displayHeader('Translating project...');
-            await this.handleTranslate(options);
-            logger.endCommand('Done!');
-        });
-    }
-    setupValidateCommand() {
-        attachValidateFlags(this.program
-            .command('validate [files...]')
-            .description('Scans the project for a dictionary and/or inline content and validates the project for errors.')).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);
-            logger.endCommand('Done!');
-        });
-    }
-    setupGenerateSourceCommand() {
-        attachInlineTranslateFlags(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);
-            logger.endCommand('Done!');
-        });
-    }
-    async handleGenerateSourceCommand(initOptions) {
-        const settings = await generateSettings(initOptions);
-        const updates = await aggregateInlineTranslations(initOptions, settings, fallbackToGtReact(this.library));
-        // 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) {
-                logger.error(noFilesError);
-                exitSync(1);
-            }
-            await saveJSON(translationFiles.gt, newData);
-            logger.step('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);
-            }
-            logger.step('Merged translations successfully!');
-        }
-    }
-    async handleValidate(initOptions, files) {
-        validateConfigExists();
-        const settings = await generateSettings(initOptions);
-        // First run the base class's handleTranslate method
-        const options = { ...initOptions, ...settings };
-        // Fallback to gt-react
-        const pkg = fallbackToGtReact(this.library);
-        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);
-        }
-    }
-}
-function fallbackToGtReact(library) {
-    return [
-        Libraries.GT_NEXT,
-        Libraries.GT_NODE,
-        Libraries.GT_REACT_NATIVE,
-    ].includes(library)
-        ? library
-        : Libraries.GT_REACT;
-}

package/dist/cli/next.d.ts

@@ -1,10 +0,0 @@
-import { WrapOptions, SupportedFrameworks, SupportedLibraries } from '../types/index.js';
-import { ReactCLI } from './react.js';
-import { Command } from 'commander';
-import { Libraries } from '../types/libraries.js';
-export declare class NextCLI extends ReactCLI {
-    constructor(command: Command, library: typeof Libraries.GT_NEXT, additionalModules?: SupportedLibraries[]);
-    protected wrapContent(options: WrapOptions, framework: SupportedFrameworks, errors: string[], warnings: string[]): Promise<{
-        filesUpdated: string[];
-    }>;
-}