gtx-cli 2.3.6-alpha.2 → 2.3.6

package/dist/react/parse/createInlineUpdates.js

@@ -0,0 +1,122 @@
+import fs from 'node:fs';
+import { parse } from '@babel/parser';
+import traverseModule from '@babel/traverse';
+// Handle CommonJS/ESM interop
+const traverse = traverseModule.default || traverseModule;
+import { hashSource } from 'generaltranslation/id';
+import { parseJSXElement } from '../jsx/utils/parseJsx.js';
+import { parseStrings } from '../jsx/utils/parseStringFunction.js';
+import { extractImportName } from '../jsx/utils/parseAst.js';
+import { logError } from '../../console/logging.js';
+import { GT_TRANSLATION_FUNCS, INLINE_TRANSLATION_HOOK, INLINE_TRANSLATION_HOOK_ASYNC, INLINE_MESSAGE_HOOK, INLINE_MESSAGE_HOOK_ASYNC, MSG_TRANSLATION_HOOK, } from '../jsx/utils/constants.js';
+import { matchFiles } from '../../fs/matchFiles.js';
+import { DEFAULT_SRC_PATTERNS } from '../../config/generateSettings.js';
+export async function createInlineUpdates(pkg, validate, filePatterns) {
+    const updates = [];
+    const errors = [];
+    const warnings = new Set();
+    // Use the provided app directory or default to the current directory
+    const files = matchFiles(process.cwd(), filePatterns || DEFAULT_SRC_PATTERNS);
+    for (const file of files) {
+        const code = await fs.promises.readFile(file, 'utf8');
+        let ast;
+        try {
+            ast = parse(code, {
+                sourceType: 'module',
+                plugins: ['jsx', 'typescript'],
+            });
+        }
+        catch (error) {
+            logError(`Error parsing file ${file}: ${error}`);
+            continue;
+        }
+        const importAliases = {};
+        // First pass: collect imports and process translation functions
+        const translationPaths = [];
+        traverse(ast, {
+            ImportDeclaration(path) {
+                if (path.node.source.value.startsWith(pkg)) {
+                    const importName = extractImportName(path.node, pkg, GT_TRANSLATION_FUNCS);
+                    for (const name of importName) {
+                        if (name.original === INLINE_TRANSLATION_HOOK ||
+                            name.original === INLINE_TRANSLATION_HOOK_ASYNC ||
+                            name.original === INLINE_MESSAGE_HOOK ||
+                            name.original === INLINE_MESSAGE_HOOK_ASYNC ||
+                            name.original === MSG_TRANSLATION_HOOK) {
+                            translationPaths.push({
+                                localName: name.local,
+                                path,
+                                originalName: name.original,
+                            });
+                        }
+                        else {
+                            importAliases[name.local] = name.original;
+                        }
+                    }
+                }
+            },
+            VariableDeclarator(path) {
+                // Check if the init is a require call
+                if (path.node.init?.type === 'CallExpression' &&
+                    path.node.init.callee.type === 'Identifier' &&
+                    path.node.init.callee.name === 'require') {
+                    // Check if it's requiring our package
+                    const args = path.node.init.arguments;
+                    if (args.length === 1 &&
+                        args[0].type === 'StringLiteral' &&
+                        args[0].value.startsWith(pkg)) {
+                        const parentPath = path.parentPath;
+                        if (parentPath.isVariableDeclaration()) {
+                            const importName = extractImportName(parentPath.node, pkg, GT_TRANSLATION_FUNCS);
+                            for (const name of importName) {
+                                if (name.original === INLINE_TRANSLATION_HOOK ||
+                                    name.original === INLINE_TRANSLATION_HOOK_ASYNC ||
+                                    name.original === INLINE_MESSAGE_HOOK ||
+                                    name.original === INLINE_MESSAGE_HOOK_ASYNC ||
+                                    name.original === MSG_TRANSLATION_HOOK) {
+                                    translationPaths.push({
+                                        localName: name.local,
+                                        path: parentPath,
+                                        originalName: name.original,
+                                    });
+                                }
+                                else {
+                                    importAliases[name.local] = name.original;
+                                }
+                            }
+                        }
+                    }
+                }
+            },
+        });
+        // Process translation functions asynchronously
+        for (const { localName: name, originalName, path } of translationPaths) {
+            parseStrings(name, originalName, path, updates, errors, file);
+        }
+        // Parse <T> components
+        traverse(ast, {
+            JSXElement(path) {
+                parseJSXElement(importAliases, path.node, updates, errors, warnings, file);
+            },
+        });
+        // Extra validation (for Locadex)
+        // Done in parseStrings() atm
+        // if (validate) {
+        //   for (const { localName: name, path, originalName } of translationPaths) {
+        //     validateStringFunction(name, path, updates, errors, file, originalName);
+        //   }
+        // }
+    }
+    // Post-process to add a hash to each update
+    await Promise.all(updates.map(async (update) => {
+        const context = update.metadata.context;
+        const hash = hashSource({
+            source: update.source,
+            ...(context && { context }),
+            ...(update.metadata.id && { id: update.metadata.id }),
+            dataFormat: update.dataFormat,
+        });
+        update.metadata.hash = hash;
+    }));
+    return { updates, errors, warnings: [...warnings] };
+}

package/dist/react/parse/wrapContent.d.ts

@@ -0,0 +1,11 @@
+import { SupportedFrameworks, WrapOptions } from '../../types/index.js';
+/**
+ * Wraps all JSX elements in the src directory with a <T> tag, with unique ids.
+ * - Ignores pure strings
+ *
+ * @param options - The options object
+ * @returns An object containing the updates and errors
+ */
+export declare function wrapContentReact(options: WrapOptions, pkg: 'gt-react', framework: SupportedFrameworks, errors: string[], warnings: string[]): Promise<{
+    filesUpdated: string[];
+}>;

package/dist/react/parse/wrapContent.js

@@ -0,0 +1,162 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import * as t from '@babel/types';
+import { parse } from '@babel/parser';
+import traverseModule from '@babel/traverse';
+import generateModule from '@babel/generator';
+// Handle CommonJS/ESM interop
+const traverse = traverseModule.default || traverseModule;
+const generate = generateModule.default || generateModule;
+import { isMeaningful } from '../jsx/evaluateJsx.js';
+import { handleJsxElement } from '../jsx/wrapJsx.js';
+import { getRelativePath } from '../../fs/findFilepath.js';
+import { generateImportMap, createImports, } from '../jsx/utils/parseAst.js';
+import { DEFAULT_SRC_PATTERNS } from '../../config/generateSettings.js';
+import { matchFiles } from '../../fs/matchFiles.js';
+const IMPORT_MAP = {
+    T: { name: 'T', source: 'gt-react' },
+    Var: { name: 'Var', source: 'gt-react' },
+    GTT: { name: 'T', source: 'gt-react' },
+    GTVar: { name: 'Var', source: 'gt-react' },
+    GTProvider: { name: 'GTProvider', source: 'gt-react' },
+    // getLocale: { name: 'getLocale', source: 'gt-react/server' },
+};
+/**
+ * Wraps all JSX elements in the src directory with a <T> tag, with unique ids.
+ * - Ignores pure strings
+ *
+ * @param options - The options object
+ * @returns An object containing the updates and errors
+ */
+export async function wrapContentReact(options, pkg, framework, errors, warnings) {
+    const filePatterns = options.src || DEFAULT_SRC_PATTERNS;
+    const files = matchFiles(process.cwd(), filePatterns);
+    const filesUpdated = [];
+    for (const file of files) {
+        const baseFileName = path.basename(file);
+        const configPath = path.relative(path.dirname(file), path.resolve(process.cwd(), options.config));
+        // Ensure the path starts with ./ or ../
+        const normalizedConfigPath = configPath.startsWith('.')
+            ? configPath
+            : './' + configPath;
+        const code = await fs.promises.readFile(file, 'utf8');
+        // Create relative path from src directory and remove extension
+        const relativePath = getRelativePath(file, process.cwd());
+        let ast;
+        try {
+            ast = parse(code, {
+                sourceType: 'module',
+                plugins: ['jsx', 'typescript'],
+                tokens: true,
+                createParenthesizedExpressions: true,
+            });
+        }
+        catch (error) {
+            errors.push(`Error:Failed to parse ${file}: ${error}`);
+            continue;
+        }
+        let modified = false;
+        const usedImports = [];
+        const { importAlias, initialImports } = generateImportMap(ast, pkg);
+        // If the file already has a T import, skip processing it
+        if (initialImports.includes(IMPORT_MAP.T.name)) {
+            continue;
+        }
+        let globalId = 0;
+        traverse(ast, {
+            JSXElement(path) {
+                if (framework === 'next-pages' &&
+                    options.addGTProvider &&
+                    (baseFileName === '_app.tsx' || baseFileName === '_app.jsx')) {
+                    // Check if this is the Component element with pageProps
+                    const isComponentWithPageProps = t.isJSXElement(path.node) &&
+                        t.isJSXIdentifier(path.node.openingElement.name) &&
+                        path.node.openingElement.name.name === 'Component' &&
+                        path.node.openingElement.attributes.some((attr) => t.isJSXSpreadAttribute(attr) &&
+                            t.isIdentifier(attr.argument) &&
+                            attr.argument.name === 'pageProps');
+                    if (!isComponentWithPageProps) {
+                        return;
+                    }
+                    // Check if GTProvider already exists in the ancestors
+                    let hasGTProvider = false;
+                    let currentPath = path;
+                    while (currentPath.parentPath) {
+                        if (t.isJSXElement(currentPath.node) &&
+                            t.isJSXIdentifier(currentPath.node.openingElement.name) &&
+                            currentPath.node.openingElement.name.name === 'GTProvider') {
+                            hasGTProvider = true;
+                            break;
+                        }
+                        currentPath = currentPath.parentPath;
+                    }
+                    if (!hasGTProvider) {
+                        // Wrap the Component element with GTProvider
+                        const gtProviderJsx = t.jsxElement(t.jsxOpeningElement(t.jsxIdentifier('GTProvider'), [t.jsxSpreadAttribute(t.identifier('gtConfig'))], false), t.jsxClosingElement(t.jsxIdentifier('GTProvider')), [path.node]);
+                        path.replaceWith(gtProviderJsx);
+                        usedImports.push('GTProvider');
+                        usedImports.push({
+                            local: 'gtConfig',
+                            imported: 'default',
+                            source: normalizedConfigPath,
+                        });
+                        modified = true;
+                        path.skip();
+                        return;
+                    }
+                }
+                // Check if this JSX element has any JSX element ancestors
+                if (t.isJSXElement(path.parentPath?.node) ||
+                    t.isJSXExpressionContainer(path.parentPath?.node)) {
+                    // If we're nested inside JSX, skip processing this node
+                    return;
+                }
+                // At this point, we're only processing top-level JSX elements
+                const opts = {
+                    ...importAlias,
+                    idPrefix: relativePath,
+                    idCount: globalId,
+                    usedImports,
+                    modified: false,
+                    createIds: !options.disableIds,
+                    warnings,
+                    file,
+                };
+                const wrapped = handleJsxElement(path.node, opts, isMeaningful);
+                path.replaceWith(wrapped.node);
+                // Update global counters
+                modified = modified || opts.modified;
+                globalId = opts.idCount;
+            },
+        });
+        if (!modified)
+            continue;
+        const needsImport = usedImports.filter((imp) => typeof imp === 'string'
+            ? !initialImports.includes(imp)
+            : !initialImports.includes(imp.local));
+        if (needsImport.length > 0) {
+            createImports(ast, needsImport, IMPORT_MAP);
+        }
+        try {
+            const output = generate(ast, {
+                retainLines: true,
+                retainFunctionParens: true,
+                comments: true,
+                compact: 'auto',
+            }, code);
+            // Post-process the output to fix import spacing
+            let processedCode = output.code;
+            if (needsImport.length > 0) {
+                // Add newline after the comment only
+                processedCode = processedCode.replace(/((?:import\s*{\s*(?:T|GTT|Var|GTVar|GTProvider|getLocale)(?:\s*,\s*(?:T|GTT|Var|GTVar|GTProvider|getLocale))*\s*}\s*from|const\s*{\s*(?:T|GTT|Var|GTVar|GTProvider|getLocale)(?:\s*,\s*(?:T|GTT|Var|GTVar|GTProvider|getLocale))*\s*}\s*=\s*require)\s*['"]gt-(?:next|react)(?:\/server)?['"];?)/, '\n$1\n');
+            }
+            // Write the modified code back to the file
+            await fs.promises.writeFile(file, processedCode);
+            filesUpdated.push(file);
+        }
+        catch (error) {
+            errors.push(`Error: Failed to write ${file}: ${error}`);
+        }
+    }
+    return { filesUpdated };
+}

package/dist/react/utils/flattenDictionary.d.ts

@@ -0,0 +1,20 @@
+import { Dictionary, FlattenedDictionary, FlattenedJSONDictionary, JSONDictionary } from '../../types/data.js';
+/**
+ * Flattens a nested dictionary by concatenating nested keys.
+ * Throws an error if two keys result in the same flattened key.
+ * @param {Record<string, any>} dictionary - The dictionary to flatten.
+ * @param {string} [prefix=''] - The prefix for nested keys.
+ * @returns {Record<string, React.ReactNode>} The flattened dictionary object.
+ * @throws {Error} If two keys result in the same flattened key.
+ */
+export default function flattenDictionary(dictionary: Dictionary, prefix?: string): FlattenedDictionary;
+/**
+ * Flattens a nested dictionary containing only string values
+ * Throws an error if two keys result in the same flattened key.
+ * @param {JSONDictionary} dictionary - The dictionary to flatten.
+ * @param {string} [prefix=''] - The prefix for nested keys.
+ * @returns {FlattenedJSONDictionary} The flattened dictionary with string values.
+ * @throws {Error} If two keys result in the same flattened key.
+ * @throws {Error} If a value is an array.
+ */
+export declare function flattenJsonDictionary(dictionary: JSONDictionary, prefix?: string): FlattenedJSONDictionary;

package/dist/react/utils/flattenDictionary.js

@@ -0,0 +1,75 @@
+import { logErrorAndExit } from '../../console/logging.js';
+const createDuplicateKeyError = (key) => `Duplicate key found in dictionary: "${key}"`;
+/**
+ * Flattens a nested dictionary by concatenating nested keys.
+ * Throws an error if two keys result in the same flattened key.
+ * @param {Record<string, any>} dictionary - The dictionary to flatten.
+ * @param {string} [prefix=''] - The prefix for nested keys.
+ * @returns {Record<string, React.ReactNode>} The flattened dictionary object.
+ * @throws {Error} If two keys result in the same flattened key.
+ */
+export default function flattenDictionary(dictionary, prefix = '') {
+    const flattened = {};
+    for (const key in dictionary) {
+        if (dictionary.hasOwnProperty(key)) {
+            const newKey = prefix ? `${prefix}.${key}` : key;
+            if (typeof dictionary[key] === 'object' &&
+                dictionary[key] !== null &&
+                !Array.isArray(dictionary[key])) {
+                const nestedFlattened = flattenDictionary(dictionary[key], newKey);
+                for (const flatKey in nestedFlattened) {
+                    if (flattened.hasOwnProperty(flatKey)) {
+                        logErrorAndExit(createDuplicateKeyError(flatKey));
+                    }
+                    flattened[flatKey] = nestedFlattened[flatKey];
+                }
+            }
+            else {
+                if (flattened.hasOwnProperty(newKey)) {
+                    logErrorAndExit(createDuplicateKeyError(newKey));
+                }
+                flattened[newKey] = dictionary[key];
+            }
+        }
+    }
+    return flattened;
+}
+/**
+ * Flattens a nested dictionary containing only string values
+ * Throws an error if two keys result in the same flattened key.
+ * @param {JSONDictionary} dictionary - The dictionary to flatten.
+ * @param {string} [prefix=''] - The prefix for nested keys.
+ * @returns {FlattenedJSONDictionary} The flattened dictionary with string values.
+ * @throws {Error} If two keys result in the same flattened key.
+ * @throws {Error} If a value is an array.
+ */
+export function flattenJsonDictionary(dictionary, prefix = '') {
+    const flattened = {};
+    for (const key in dictionary) {
+        if (dictionary.hasOwnProperty(key)) {
+            const newKey = prefix ? `${prefix}.${key}` : key;
+            const value = dictionary[key];
+            if (Array.isArray(value)) {
+                logErrorAndExit(`Arrays are not supported in JSON dictionary at key: "${newKey}"`);
+            }
+            else if (typeof value === 'object' && value !== null) {
+                // Recursively flatten nested objects
+                const nestedFlattened = flattenJsonDictionary(value, newKey);
+                for (const flatKey in nestedFlattened) {
+                    if (flattened.hasOwnProperty(flatKey)) {
+                        logErrorAndExit(createDuplicateKeyError(flatKey));
+                    }
+                    flattened[flatKey] = nestedFlattened[flatKey];
+                }
+            }
+            else if (typeof value === 'string') {
+                // Handle string values
+                if (flattened.hasOwnProperty(newKey)) {
+                    logErrorAndExit(createDuplicateKeyError(newKey));
+                }
+                flattened[newKey] = value;
+            }
+        }
+    }
+    return flattened;
+}

package/dist/react/utils/getEntryAndMetadata.d.ts

@@ -0,0 +1,5 @@
+import { DictionaryEntry, DictionaryMetadata } from '../../types/data.js';
+export default function getEntryAndMetadata(value: DictionaryEntry): {
+    entry: string;
+    metadata?: DictionaryMetadata;
+};

package/dist/react/utils/getEntryAndMetadata.js

@@ -0,0 +1,11 @@
+export default function getEntryAndMetadata(value) {
+    if (Array.isArray(value)) {
+        if (value.length === 1) {
+            return { entry: value[0] };
+        }
+        if (value.length === 2) {
+            return { entry: value[0], metadata: value[1] };
+        }
+    }
+    return { entry: value };
+}

package/dist/react/utils/getVariableName.d.ts

@@ -0,0 +1,25 @@
+import { VariableType } from 'generaltranslation/types';
+/**
+ * These are the names of the variable components as they appear in gt-next and gt-react
+ */
+export declare const defaultVariableNames: {
+    readonly Var: "value";
+    readonly Num: "n";
+    readonly DateTime: "date";
+    readonly Currency: "cost";
+};
+/**
+ * Minify the variable type from the name of the variable component (from gt-next and gt-react)
+ * @param variableType - The type of the variable (Var, Num, DateTime, Currency)
+ * @returns The minified variable type
+ */
+export declare const minifyVariableType: (variableType: keyof typeof defaultVariableNames) => VariableType;
+export declare const baseVariablePrefix = "_gt_";
+/**
+ * Get the name of a variable
+ * @param props - The props of the variable
+ * @param variableType - The type of the variable (Var, Num, DateTime, Currency)
+ * @param id - The id of the variable
+ * @returns The name of the variable
+ */
+export declare function getVariableName(props: Record<string, any> | undefined, variableType: keyof typeof defaultVariableNames, id: number): string;

package/dist/react/utils/getVariableName.js

@@ -0,0 +1,37 @@
+/**
+ * These are the names of the variable components as they appear in gt-next and gt-react
+ */
+export const defaultVariableNames = {
+    Var: 'value',
+    Num: 'n',
+    DateTime: 'date',
+    Currency: 'cost',
+};
+const minifyVariableTypeMap = {
+    Var: 'v',
+    Num: 'n',
+    DateTime: 'd',
+    Currency: 'c',
+};
+/**
+ * Minify the variable type from the name of the variable component (from gt-next and gt-react)
+ * @param variableType - The type of the variable (Var, Num, DateTime, Currency)
+ * @returns The minified variable type
+ */
+export const minifyVariableType = (variableType) => {
+    return minifyVariableTypeMap[variableType];
+};
+export const baseVariablePrefix = '_gt_';
+/**
+ * Get the name of a variable
+ * @param props - The props of the variable
+ * @param variableType - The type of the variable (Var, Num, DateTime, Currency)
+ * @param id - The id of the variable
+ * @returns The name of the variable
+ */
+export function getVariableName(props = {}, variableType, id) {
+    if (props.name)
+        return props.name;
+    const baseVariableName = defaultVariableNames[variableType] || 'value';
+    return `${baseVariablePrefix}${baseVariableName}_${id}`;
+}

package/dist/setup/userInput.d.ts

@@ -0,0 +1,4 @@
+export declare function getDesiredLocales(): Promise<{
+    defaultLocale: string;
+    locales: string[];
+}>;

package/dist/setup/userInput.js

@@ -0,0 +1,29 @@
+import { libraryDefaultLocale } from 'generaltranslation/internal';
+import { promptText } from '../console/logging.js';
+import chalk from 'chalk';
+import { gt } from '../utils/gt.js';
+export async function getDesiredLocales() {
+    // Ask for the default locale
+    const defaultLocale = await promptText({
+        message: 'What is the default locale for your project?',
+        defaultValue: libraryDefaultLocale,
+    });
+    // Ask for the locales
+    const locales = await promptText({
+        message: `What locales would you like to translate your project into? ${chalk.dim('(space-separated list)')}`,
+        defaultValue: 'es zh fr de ja',
+        validate: (input) => {
+            const localeList = input.split(' ');
+            if (localeList.length === 0) {
+                return 'Please enter at least one locale';
+            }
+            for (const locale of localeList) {
+                if (!gt.isValidLocale(locale)) {
+                    return 'Please enter a valid locale (e.g., en, fr, es)';
+                }
+            }
+            return true;
+        },
+    });
+    return { defaultLocale, locales: locales.split(' ') };
+}

package/dist/setup/wizard.d.ts

@@ -0,0 +1,2 @@
+import { SetupOptions } from '../types/index.js';
+export declare function handleSetupReactCommand(options: SetupOptions): Promise<void>;

package/dist/setup/wizard.js

@@ -0,0 +1,127 @@
+import { detectFormatter } from '../hooks/postProcess.js';
+import { createSpinner, promptSelect } from '../console/logging.js';
+import { logInfo, logError, logStep, logWarning } from '../console/logging.js';
+import chalk from 'chalk';
+import { promptConfirm } from '../console/logging.js';
+import findFilepath from '../fs/findFilepath.js';
+import { formatFiles } from '../hooks/postProcess.js';
+import { handleInitGT } from '../next/parse/handleInitGT.js';
+import { getPackageJson, isPackageInstalled } from '../utils/packageJson.js';
+import { wrapContentNext } from '../next/parse/wrapContent.js';
+import { getPackageManager } from '../utils/packageManager.js';
+import { installPackage } from '../utils/installPackage.js';
+import { createOrUpdateConfig } from '../fs/config/setupConfig.js';
+import { loadConfig } from '../fs/config/loadConfig.js';
+export async function handleSetupReactCommand(options) {
+    // Ask user for confirmation using inquirer
+    const answer = await promptConfirm({
+        message: chalk.yellow(`This wizard will configure your React project for internationalization with GT.
+If your project is already using a different i18n library, this wizard may cause issues.
+
+Make sure you have committed or stashed any changes. Do you want to continue?`),
+        defaultValue: true,
+        cancelMessage: 'Operation cancelled. You can re-run this wizard with: npx gtx-cli setup',
+    });
+    if (!answer) {
+        logInfo('Operation cancelled. You can re-run this wizard with: npx gtx-cli setup');
+        process.exit(0);
+    }
+    const frameworkType = await promptSelect({
+        message: 'What framework are you using?',
+        options: [
+            { value: 'next-app', label: chalk.blue('Next.js App Router') },
+            { value: 'next-pages', label: chalk.green('Next.js Pages Router') },
+            { value: 'vite', label: chalk.cyan('Vite + React') },
+            { value: 'gatsby', label: chalk.magenta('Gatsby') },
+            { value: 'react', label: chalk.yellow('React') },
+            { value: 'redwood', label: chalk.red('RedwoodJS') },
+            { value: 'other', label: chalk.dim('Other') },
+        ],
+        defaultValue: 'next-app',
+    });
+    if (frameworkType === 'other') {
+        logError(`Sorry, other React frameworks are not currently supported. 
+Please let us know what you would like to see supported at https://github.com/generaltranslation/gt/issues`);
+        process.exit(0);
+    }
+    // ----- Create a starter gt.config.json file -----
+    await createOrUpdateConfig(options.config || 'gt.config.json', {
+        framework: frameworkType,
+    });
+    const packageJson = await getPackageJson();
+    if (!packageJson) {
+        logError(chalk.red('No package.json found in the current directory. Please run this command from the root of your project.'));
+        process.exit(1);
+    }
+    // Check if gt-next or gt-react is installed
+    if (frameworkType === 'next-app' &&
+        !isPackageInstalled('gt-next', packageJson)) {
+        const packageManager = await getPackageManager();
+        const spinner = createSpinner('timer');
+        spinner.start(`Installing gt-next with ${packageManager.name}...`);
+        await installPackage('gt-next', packageManager);
+        spinner.stop(chalk.green('Automatically installed gt-next.'));
+    }
+    else if (['next-pages', 'react', 'redwood', 'vite', 'gatsby'].includes(frameworkType) &&
+        !isPackageInstalled('gt-react', packageJson)) {
+        const packageManager = await getPackageManager();
+        const spinner = createSpinner('timer');
+        spinner.start(`Installing gt-react with ${packageManager.name}...`);
+        await installPackage('gt-react', packageManager);
+        spinner.stop(chalk.green('Automatically installed gt-react.'));
+    }
+    const errors = [];
+    const warnings = [];
+    let filesUpdated = [];
+    if (frameworkType === 'next-app') {
+        // Check if they have a next.config.js file
+        const nextConfigPath = findFilepath([
+            './next.config.js',
+            './next.config.ts',
+            './next.config.mjs',
+            './next.config.mts',
+        ]);
+        if (!nextConfigPath) {
+            logError('No next.config.[js|ts|mjs|mts] file found.');
+            process.exit(1);
+        }
+        const mergeOptions = {
+            ...options,
+            disableIds: true,
+            disableFormatting: true,
+            skipTs: true,
+            addGTProvider: true,
+        };
+        const spinner = createSpinner();
+        spinner.start('Wrapping JSX content with <T> tags...');
+        // Wrap all JSX elements in the src directory with a <T> tag, with unique ids
+        const { filesUpdated: filesUpdatedNext } = await wrapContentNext(mergeOptions, 'gt-next', errors, warnings);
+        filesUpdated = [...filesUpdated, ...filesUpdatedNext];
+        spinner.stop(chalk.green(`Success! Updated ${chalk.bold.cyan(filesUpdated.length)} files:\n`) + filesUpdated.map((file) => `${chalk.green('-')} ${file}`).join('\n'));
+        // Read tsconfig.json if it exists
+        const tsconfigPath = findFilepath(['tsconfig.json']);
+        const tsconfigJson = tsconfigPath ? loadConfig(tsconfigPath) : undefined;
+        // Add the withGTConfig() function to the next.config.js file
+        await handleInitGT(nextConfigPath, errors, warnings, filesUpdated, packageJson, tsconfigJson);
+        logStep(chalk.green(`Added withGTConfig() to your ${nextConfigPath} file.`));
+    }
+    if (errors.length > 0) {
+        logError(chalk.red('Failed to write files:\n') + errors.join('\n'));
+    }
+    if (warnings.length > 0) {
+        logWarning(chalk.yellow('Warnings encountered:') +
+            '\n' +
+            warnings.map((warning) => `${chalk.yellow('-')} ${warning}`).join('\n'));
+    }
+    const formatter = await detectFormatter();
+    if (!formatter || filesUpdated.length === 0) {
+        return;
+    }
+    const applyFormatting = await promptConfirm({
+        message: `Would you like the wizard to auto-format the modified files? ${chalk.dim(`(${formatter})`)}`,
+        defaultValue: true,
+    });
+    // Format updated files if formatters are available
+    if (applyFormatting)
+        await formatFiles(filesUpdated, formatter);
+}

package/dist/translation/parse.d.ts

@@ -0,0 +1,15 @@
+import { Updates, TranslateFlags } from '../types/index.js';
+/**
+ * Searches for gt-react or gt-next dictionary files and creates updates for them,
+ * as well as inline updates for <T> tags and useGT()/getGT() calls
+ *
+ * @param options - The options object
+ * @param sourceDictionary - The source dictionary file path
+ * @param pkg - The package name
+ * @returns An object containing the updates and errors
+ */
+export declare function createUpdates(options: TranslateFlags, src: string[] | undefined, sourceDictionary: string | undefined, pkg: 'gt-react' | 'gt-next', validate: boolean): Promise<{
+    updates: Updates;
+    errors: string[];
+    warnings: string[];
+}>;