gt 0.10.0 → 2.7.0

package/dist/fs/matchFiles.js

@@ -0,0 +1,8 @@
+import fg from 'fast-glob';
+export function matchFiles(cwd, patterns) {
+    return fg.sync(patterns, {
+        cwd,
+        absolute: true,
+        onlyFiles: true,
+    });
+}

package/dist/fs/saveJSON.d.ts

@@ -0,0 +1 @@
+export declare function saveJSON(filepath: string, data: Record<string, any>): Promise<void>;

package/dist/fs/saveJSON.js

@@ -0,0 +1,7 @@
+import path from 'node:path';
+import fs from 'node:fs';
+export async function saveJSON(filepath, data) {
+    // Ensure directory exists
+    await fs.promises.mkdir(path.dirname(filepath), { recursive: true });
+    await fs.promises.writeFile(filepath, JSON.stringify(data, null, 2));
+}

package/dist/fs/utils.d.ts

@@ -0,0 +1 @@
+export declare function resolveProjectId(): string | undefined;

package/dist/fs/utils.js

@@ -0,0 +1,16 @@
+export function resolveProjectId() {
+    const CANDIDATES = [
+        process.env.GT_PROJECT_ID, // any server side, Remix
+        process.env.NEXT_PUBLIC_GT_PROJECT_ID, // Next.js
+        process.env.VITE_GT_PROJECT_ID, // Vite
+        process.env.REACT_APP_GT_PROJECT_ID, // Create React App
+        process.env.REDWOOD_ENV_GT_PROJECT_ID, // RedwoodJS
+        process.env.GATSBY_GT_PROJECT_ID, // Gatsby
+        process.env.EXPO_PUBLIC_GT_PROJECT_ID, // Expo (React Native)
+        process.env.RAZZLE_GT_PROJECT_ID, // Razzle
+        process.env.UMI_GT_PROJECT_ID, // UmiJS
+        process.env.BLITZ_PUBLIC_GT_PROJECT_ID, // Blitz.js
+        process.env.PUBLIC_GT_PROJECT_ID, // WMR, Qwik (general "public" convention)
+    ];
+    return CANDIDATES.find((projectId) => projectId !== undefined);
+}

package/dist/functions.d.ts

@@ -0,0 +1,7 @@
+/**
+ * This file serves as an entrypoint for programmatically invoking CLI commands.
+ * Import from 'gt/functions' to access these APIs.
+ */
+export { getValidateJson } from './translation/validate.js';
+export type { ValidationResult, ValidationMessage, ValidationLevel, } from './translation/validate.js';
+export { Libraries, GTLibrary, InlineLibrary, ReactLibrary, GT_LIBRARIES, INLINE_LIBRARIES, REACT_LIBRARIES, GT_LIBRARIES_UPSTREAM, } from './types/libraries.js';

package/dist/functions.js

@@ -0,0 +1,6 @@
+/**
+ * This file serves as an entrypoint for programmatically invoking CLI commands.
+ * Import from 'gt/functions' to access these APIs.
+ */
+export { getValidateJson } from './translation/validate.js';
+export { Libraries, GT_LIBRARIES, INLINE_LIBRARIES, REACT_LIBRARIES, GT_LIBRARIES_UPSTREAM, } from './types/libraries.js';

package/dist/generated/version.d.ts

@@ -0,0 +1 @@
+export declare const PACKAGE_VERSION = "2.7.0";

package/dist/generated/version.js

@@ -0,0 +1,2 @@
+// This file is auto-generated. Do not edit manually.
+export const PACKAGE_VERSION = '2.7.0';

package/dist/git/branches.d.ts

@@ -0,0 +1,7 @@
+export declare function getCurrentBranch(remoteName: string): Promise<{
+    currentBranchName: string;
+    defaultBranch: boolean;
+    defaultBranchName: string;
+} | null>;
+export declare function getIncomingBranches(remoteName: string): Promise<string[]>;
+export declare function getCheckedOutBranches(remoteName: string): Promise<string[]>;

package/dist/git/branches.js

@@ -0,0 +1,88 @@
+import { execFile } from 'child_process';
+import { promisify } from 'util';
+const execAsync = promisify(execFile);
+const MAX_BRANCHES = 5;
+export async function getCurrentBranch(remoteName) {
+    try {
+        const { stdout } = await execAsync('git', ['rev-parse', '--abbrev-ref', 'HEAD'], {
+            encoding: 'utf8',
+            windowsHide: true,
+        });
+        const currentBranchName = stdout.trim();
+        // Get the default branch (usually main or master)
+        const { stdout: defaultBranchRef } = await execAsync('git', ['symbolic-ref', `refs/remotes/${remoteName}/HEAD`], { encoding: 'utf8', windowsHide: true });
+        const defaultBranchName = defaultBranchRef
+            .trim()
+            .replace(`refs/remotes/${remoteName}/`, '');
+        const defaultBranch = currentBranchName === defaultBranchName;
+        return { currentBranchName, defaultBranch, defaultBranchName };
+    }
+    catch {
+        return null;
+    }
+}
+export async function getIncomingBranches(remoteName) {
+    try {
+        // Get merge commits into the current branch
+        const { stdout } = await execAsync('git', [
+            'log',
+            '--merges',
+            '--first-parent',
+            '--pretty=format:%s',
+            `-${MAX_BRANCHES}`,
+        ], {
+            encoding: 'utf8',
+            windowsHide: true,
+        });
+        if (!stdout.trim()) {
+            return [];
+        }
+        const branches = [];
+        const lines = stdout.trim().split('\n');
+        for (const line of lines) {
+            // Parse merge commit messages:
+            // - "Merge branch 'feature-name'" or "Merge branch 'feature-name' into main"
+            // - "Merge pull request #123 from user/branch-name"
+            const branchMatch = line.match(/Merge branch '([^']+)'/);
+            const prMatch = line.match(/Merge pull request #\d+ from [^/]+\/(.+)/);
+            if (branchMatch && branchMatch[1]) {
+                branches.push(branchMatch[1]);
+            }
+            else if (prMatch && prMatch[1]) {
+                branches.push(prMatch[1]);
+            }
+        }
+        return branches.slice(0, MAX_BRANCHES);
+    }
+    catch {
+        // If log fails or no merges found, return empty array
+        return [];
+    }
+}
+export async function getCheckedOutBranches(remoteName) {
+    try {
+        // Get current branch
+        const currentBranchResult = await getCurrentBranch(remoteName);
+        if (!currentBranchResult) {
+            return [];
+        }
+        // If we're already on the default branch, return empty
+        if (currentBranchResult.defaultBranch) {
+            return [];
+        }
+        // Check if there's a merge-base (common ancestor) between default branch and current
+        // This means the branch was at some point checked out from the default branch
+        try {
+            await execAsync('git', ['merge-base', currentBranchResult.defaultBranchName, 'HEAD'], { encoding: 'utf8', windowsHide: true });
+            // If merge-base exists, the branch shares history with default branch
+            return [currentBranchResult.defaultBranchName];
+        }
+        catch {
+            // No common ancestor found
+            return [];
+        }
+    }
+    catch {
+        return [];
+    }
+}

package/dist/hooks/postProcess.d.ts

@@ -0,0 +1,4 @@
+type Formatter = 'prettier' | 'biome' | 'eslint';
+export declare function detectFormatter(): Promise<Formatter | null>;
+export declare function formatFiles(filesUpdated: string[], formatter?: Formatter): Promise<void>;
+export {};

package/dist/hooks/postProcess.js

@@ -0,0 +1,110 @@
+import fs from 'node:fs';
+import { spawn } from 'node:child_process';
+import chalk from 'chalk';
+import { logger } from '../console/logger.js';
+export async function detectFormatter() {
+    // Try Prettier
+    try {
+        await import('prettier');
+        return 'prettier';
+    }
+    catch { }
+    // Try ESLint
+    try {
+        await import('eslint');
+        return 'eslint';
+    }
+    catch { }
+    // Try Biome
+    try {
+        return await new Promise((resolve, reject) => {
+            const child = spawn('npx', ['@biomejs/biome', '--version'], {
+                stdio: 'ignore',
+            });
+            child.on('error', () => {
+                resolve(null);
+            });
+            child.on('close', (code) => {
+                if (code === 0) {
+                    resolve('biome');
+                }
+                else {
+                    resolve(null);
+                }
+            });
+        });
+    }
+    catch { }
+    return null;
+}
+export async function formatFiles(filesUpdated, formatter) {
+    if (filesUpdated.length === 0)
+        return;
+    try {
+        const detectedFormatter = formatter || (await detectFormatter());
+        if (!detectedFormatter) {
+            logger.warn(chalk.yellow('No supported formatter detected'));
+            return;
+        }
+        if (detectedFormatter === 'prettier') {
+            logger.message(chalk.dim('Cleaning up with prettier...'));
+            const prettier = await import('prettier');
+            for (const file of filesUpdated) {
+                const config = await prettier.resolveConfig(file);
+                const content = await fs.promises.readFile(file, 'utf-8');
+                const formatted = await prettier.format(content, {
+                    ...config,
+                    filepath: file,
+                });
+                await fs.promises.writeFile(file, formatted);
+            }
+            return;
+        }
+        if (detectedFormatter === 'biome') {
+            logger.message(chalk.dim('Cleaning up with biome...'));
+            try {
+                await new Promise((resolve, reject) => {
+                    const args = [
+                        '@biomejs/biome',
+                        'format',
+                        '--write',
+                        ...filesUpdated.map((file) => file),
+                    ];
+                    const child = spawn('npx', args, {
+                        stdio: ['ignore', 'inherit', 'inherit'],
+                    });
+                    child.on('error', (error) => {
+                        logger.warn(chalk.yellow('Biome formatting failed: ' + error.message));
+                        resolve();
+                    });
+                    child.on('close', (code) => {
+                        if (code !== 0) {
+                            logger.warn(chalk.yellow(`Biome formatting failed with exit code ${code}`));
+                        }
+                        resolve();
+                    });
+                });
+            }
+            catch (error) {
+                logger.warn(chalk.yellow('Biome formatting failed: ' + String(error)));
+            }
+            return;
+        }
+        if (detectedFormatter === 'eslint') {
+            logger.message(chalk.dim('Cleaning up with eslint...'));
+            const { ESLint } = await import('eslint');
+            const eslint = new ESLint({
+                fix: true,
+                overrideConfigFile: undefined, // Will use project's .eslintrc
+            });
+            for (const file of filesUpdated) {
+                const results = await eslint.lintFiles([file]);
+                await ESLint.outputFixes(results);
+            }
+            return;
+        }
+    }
+    catch (e) {
+        logger.warn(chalk.yellow('Unable to run code formatter: ' + String(e)));
+    }
+}

package/dist/index.d.ts

@@ -0,0 +1,4 @@
+import { BaseCLI } from './cli/base.js';
+import { Command } from 'commander';
+export declare function main(program: Command): void;
+export { BaseCLI };

package/dist/index.js

@@ -0,0 +1,27 @@
+import { BaseCLI } from './cli/base.js';
+import { NextCLI } from './cli/next.js';
+import { ReactCLI } from './cli/react.js';
+import { determineLibrary } from './fs/determineFramework.js';
+import { NodeCLI } from './cli/node.js';
+import { Libraries } from './types/libraries.js';
+export function main(program) {
+    program.name('gt');
+    const { library, additionalModules } = determineLibrary();
+    let cli;
+    if (library === Libraries.GT_NEXT) {
+        cli = new NextCLI(program, library, additionalModules);
+    }
+    else if (library === Libraries.GT_REACT ||
+        library === Libraries.GT_REACT_NATIVE) {
+        cli = new ReactCLI(program, library, additionalModules);
+    }
+    else if (library === Libraries.GT_NODE) {
+        cli = new NodeCLI(program, library, additionalModules);
+    }
+    else {
+        cli = new BaseCLI(program, library, additionalModules);
+    }
+    cli.init();
+    cli.execute();
+}
+export { BaseCLI };

package/dist/locadex/setupFlow.d.ts

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

package/dist/locadex/setupFlow.js

@@ -0,0 +1,9 @@
+import { logger } from '../console/logger.js';
+import chalk from 'chalk';
+export async function setupLocadex(settings) {
+    const urlToOpen = `${settings.dashboardUrl}/api/integrations/github/start?returnTo=%2Fproject%2Flocadex`;
+    await import('open').then((open) => open.default(urlToOpen, {
+        wait: false,
+    }));
+    logger.message(`${chalk.dim(`If the browser window didn't open automatically, please open the following link:`)}\n\n${chalk.cyan(urlToOpen)}`);
+}

package/dist/main.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/main.js

@@ -0,0 +1,10 @@
+#!/usr/bin/env node
+// Non-binary router - directly runs main.ts
+import { main } from './index.js';
+import dotenv from 'dotenv';
+import { program } from 'commander';
+dotenv.config({ path: '.env' });
+dotenv.config({ path: '.env.local', override: true });
+dotenv.config({ path: '.env.production', override: true });
+main(program);
+program.parse();

package/dist/next/config/parseNextConfig.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Extracts projectId, defaultLocale, and locales from a next.config.js file.
+ * @param {string} filePath - The path to the next.config.js file.
+ * @returns {object|null} - An object containing the extracted values or null if none found or incorrect types.
+ */
+export declare function parseNextConfig(filePath: string): Promise<{
+    projectId?: string;
+    defaultLocale?: string;
+    locales?: string[];
+}>;

package/dist/next/config/parseNextConfig.js

@@ -0,0 +1,53 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { gt } from '../../utils/gt.js';
+/**
+ * Extracts projectId, defaultLocale, and locales from a next.config.js file.
+ * @param {string} filePath - The path to the next.config.js file.
+ * @returns {object|null} - An object containing the extracted values or null if none found or incorrect types.
+ */
+export async function parseNextConfig(filePath) {
+    // Resolve the absolute path
+    const absoluteFilePath = path.resolve(filePath);
+    // Check if the file exists
+    if (!fs.existsSync(absoluteFilePath)) {
+        return {};
+    }
+    // Read the file content
+    const fileContent = await fs.promises.readFile(absoluteFilePath, 'utf8');
+    // Regular expressions to extract the values
+    const defaultLocaleRegex = /defaultLocale:\s*['"]([^'"]+)['"]/;
+    const projectIdRegex = /projectId:\s*['"]([^'"]+)['"]/;
+    const localesRegex = /locales:\s*\[([^\]]+)\]/;
+    // Extract the values
+    const defaultLocaleMatch = fileContent.match(defaultLocaleRegex);
+    const projectIdMatch = fileContent.match(projectIdRegex);
+    const localesMatch = fileContent.match(localesRegex);
+    const defaultLocale = defaultLocaleMatch && typeof defaultLocaleMatch[1] === 'string'
+        ? defaultLocaleMatch[1]
+        : undefined;
+    const projectId = projectIdMatch && typeof projectIdMatch[1] === 'string'
+        ? projectIdMatch[1]
+        : undefined;
+    const locales = localesMatch
+        ? localesMatch[1]
+            .split(',')
+            .map((locale) => locale.trim().replace(/['"]/g, ''))
+            .filter((locale) => typeof locale === 'string')
+        : undefined;
+    // Ensure approvedLocales is an array of strings
+    const validLocales = locales && locales.every((locale) => gt.isValidLocale(locale))
+        ? locales
+        : undefined;
+    // Return the extracted values if they pass type checks or return null
+    if (defaultLocale || projectId || validLocales) {
+        return {
+            ...(defaultLocale && { defaultLocale }),
+            ...(projectId && { projectId }),
+            ...(validLocales && { locales: validLocales }),
+        };
+    }
+    else {
+        return {};
+    }
+}

package/dist/next/jsx/utils.d.ts

@@ -0,0 +1,7 @@
+import * as t from '@babel/types';
+import { NodePath } from '@babel/traverse';
+export declare function isHtmlElement(element: t.JSXOpeningElement): boolean;
+export declare function isBodyElement(element: t.JSXOpeningElement): boolean;
+export declare function hasGTProviderChild(element: t.JSXElement): boolean;
+export declare function addDynamicLangAttribute(element: t.JSXOpeningElement): void;
+export declare function makeParentFunctionAsync(path: NodePath): boolean;

package/dist/next/jsx/utils.js

@@ -0,0 +1,42 @@
+import * as t from '@babel/types';
+// Helper function to check if is the <html> fragment
+export function isHtmlElement(element) {
+    return (t.isJSXIdentifier(element.name) &&
+        element.name.name.toLowerCase() === 'html');
+}
+// Helper function to check if is the <body> fragment
+export function isBodyElement(element) {
+    return (t.isJSXIdentifier(element.name) &&
+        element.name.name.toLowerCase() === 'body');
+}
+// Helper function to check if the <body> element has a <GTProvider> child
+export function hasGTProviderChild(element) {
+    return element.children.some((child) => t.isJSXElement(child) &&
+        t.isJSXIdentifier(child.openingElement.name) &&
+        child.openingElement.name.name === 'GTProvider');
+}
+export function addDynamicLangAttribute(element) {
+    // Remove existing lang attribute if present
+    const langAttrIndex = element.attributes.findIndex((attr) => t.isJSXAttribute(attr) &&
+        t.isJSXIdentifier(attr.name) &&
+        attr.name.name === 'lang');
+    if (langAttrIndex !== -1) {
+        element.attributes.splice(langAttrIndex, 1);
+    }
+    // Add lang={await getLocale()} attribute
+    element.attributes.push(t.jsxAttribute(t.jsxIdentifier('lang'), t.jsxExpressionContainer(t.awaitExpression(t.callExpression(t.identifier('getLocale'), [])))));
+}
+export function makeParentFunctionAsync(path) {
+    const functionParent = path.getFunctionParent();
+    if (!functionParent)
+        return false;
+    const node = functionParent.node;
+    if ((t.isFunctionDeclaration(node) ||
+        t.isFunctionExpression(node) ||
+        t.isArrowFunctionExpression(node)) &&
+        !node.async) {
+        node.async = true;
+        return true;
+    }
+    return false;
+}

package/dist/next/parse/handleInitGT.d.ts

@@ -0,0 +1,7 @@
+export declare function handleInitGT(filepath: string, errors: string[], warnings: string[], filesUpdated: string[], packageJson?: {
+    type?: string;
+}, tsconfigJson?: {
+    compilerOptions?: {
+        module?: string;
+    };
+}): Promise<void>;

package/dist/next/parse/handleInitGT.js

@@ -0,0 +1,157 @@
+import fs from 'node:fs';
+import { parse } from '@babel/parser';
+import generateModule from '@babel/generator';
+import traverseModule from '@babel/traverse';
+// Handle CommonJS/ESM interop
+const traverse = traverseModule.default || traverseModule;
+const generate = generateModule.default || generateModule;
+import * as t from '@babel/types';
+import { logger } from '../../console/logger.js';
+import { needsCJS } from '../../utils/parse/needsCJS.js';
+export async function handleInitGT(filepath, errors, warnings, filesUpdated, packageJson, tsconfigJson) {
+    const code = await fs.promises.readFile(filepath, 'utf8');
+    let ast;
+    try {
+        ast = parse(code, {
+            sourceType: 'module',
+            plugins: ['jsx', 'typescript'],
+            tokens: true,
+            createParenthesizedExpressions: true,
+        });
+        // Get cjs or esm
+        const cjsEnabled = needsCJS({
+            ast,
+            warnings,
+            filepath,
+            packageJson,
+            tsconfigJson,
+        });
+        // Check if withGTConfig or initGT is already imported/required
+        let hasGTConfig = false;
+        let hasInitGT = false;
+        traverse(ast, {
+            ImportDeclaration(path) {
+                if (path.node.source.value === 'gt-next/config') {
+                    path.node.specifiers.forEach((spec) => {
+                        if (t.isImportSpecifier(spec)) {
+                            if (spec.local.name === 'withGTConfig')
+                                hasGTConfig = true;
+                            if (spec.local.name === 'initGT')
+                                hasInitGT = true;
+                        }
+                    });
+                }
+            },
+            VariableDeclaration(path) {
+                path.node.declarations.forEach((dec) => {
+                    if (t.isVariableDeclarator(dec)) {
+                        // Handle destructuring: const { withGTConfig } = require('gt-next/config')
+                        if (t.isCallExpression(dec.init) &&
+                            t.isIdentifier(dec.init.callee, { name: 'require' }) &&
+                            t.isStringLiteral(dec.init.arguments[0], {
+                                value: 'gt-next/config',
+                            })) {
+                            // Handle simple assignment: const withGTConfig = require(...)
+                            if (t.isIdentifier(dec.id, { name: 'withGTConfig' }))
+                                hasGTConfig = true;
+                            if (t.isIdentifier(dec.id, { name: 'initGT' }))
+                                hasInitGT = true;
+                            // Handle destructuring: const { withGTConfig } = require(...)
+                            if (t.isObjectPattern(dec.id)) {
+                                dec.id.properties.forEach((prop) => {
+                                    if (t.isObjectProperty(prop) &&
+                                        t.isIdentifier(prop.key) &&
+                                        t.isIdentifier(prop.value)) {
+                                        if (prop.key.name === 'withGTConfig')
+                                            hasGTConfig = true;
+                                        if (prop.key.name === 'initGT')
+                                            hasInitGT = true;
+                                    }
+                                });
+                            }
+                        }
+                        // Handle member access: const withGTConfig = require('gt-next/config').withGTConfig
+                        else if (t.isMemberExpression(dec.init) &&
+                            t.isCallExpression(dec.init.object) &&
+                            t.isIdentifier(dec.init.object.callee, { name: 'require' }) &&
+                            t.isStringLiteral(dec.init.object.arguments[0], {
+                                value: 'gt-next/config',
+                            })) {
+                            if (t.isIdentifier(dec.id, { name: 'withGTConfig' }) &&
+                                t.isIdentifier(dec.init.property, { name: 'withGTConfig' })) {
+                                hasGTConfig = true;
+                            }
+                            if (t.isIdentifier(dec.id, { name: 'initGT' }) &&
+                                t.isIdentifier(dec.init.property, { name: 'initGT' })) {
+                                hasInitGT = true;
+                            }
+                        }
+                    }
+                });
+            },
+        });
+        // Return early if either withGTConfig or initGT is already present
+        if (hasGTConfig || hasInitGT) {
+            return;
+        }
+        ast.program.body.unshift(cjsEnabled
+            ? t.variableDeclaration('const', [
+                t.variableDeclarator(t.identifier('withGTConfig'), t.memberExpression(t.callExpression(t.identifier('require'), [
+                    t.stringLiteral('gt-next/config'),
+                ]), t.identifier('withGTConfig'))),
+            ])
+            : t.importDeclaration([
+                t.importSpecifier(t.identifier('withGTConfig'), t.identifier('withGTConfig')),
+            ], t.stringLiteral('gt-next/config')));
+        // Find and transform the default export
+        traverse(ast, {
+            ExportDefaultDeclaration(path) {
+                const oldExport = path.node.declaration;
+                let exportExpression;
+                if (t.isFunctionDeclaration(oldExport)) {
+                    exportExpression = t.functionExpression(oldExport.id, oldExport.params, oldExport.body, oldExport.generator, oldExport.async);
+                }
+                else if (t.isClassDeclaration(oldExport)) {
+                    exportExpression = t.classExpression(oldExport.id, oldExport.superClass, oldExport.body, oldExport.decorators);
+                }
+                else if (t.isTSDeclareFunction(oldExport)) {
+                    // For TypeScript declare functions, create an empty function expression
+                    // since declare functions don't have a runtime implementation
+                    warnings.push(`Found TypeScript declare function in ${filepath}. Converting to empty function.`);
+                    exportExpression = t.functionExpression(oldExport.id, oldExport.params, t.blockStatement([]), false, false);
+                }
+                else {
+                    exportExpression = oldExport;
+                }
+                // Validate that we have a valid Next.js config export
+                if (!t.isObjectExpression(exportExpression) &&
+                    !t.isFunctionExpression(exportExpression) &&
+                    !t.isArrowFunctionExpression(exportExpression)) {
+                    warnings.push(`Unexpected export type in ${filepath}. Next.js config should export an object or a function returning an object.`);
+                }
+                path.node.declaration = t.callExpression(t.identifier('withGTConfig'), [
+                    exportExpression,
+                    t.objectExpression([]),
+                ]);
+            },
+        });
+        // Generate the modified code
+        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;
+        // Add newline after the comment only
+        processedCode = processedCode.replace(/((?:import\s*{\s*withGTConfig\s*}\s*from|const\s*{\s*withGTConfig\s*}\s*=\s*require)\s*['"]gt-next\/config['"];?)/, '$1\n');
+        // Write the modified code back to the file
+        await fs.promises.writeFile(filepath, processedCode);
+        filesUpdated.push(filepath);
+    }
+    catch (error) {
+        logger.error(`Error parsing file ${filepath}: ${error}`);
+        errors.push(`Failed to parse ${filepath}: ${error}`);
+    }
+}

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

@@ -0,0 +1,12 @@
+import { WrapOptions } from '../../types/index.js';
+import { Libraries } from '../../types/libraries.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 wrapContentNext(options: WrapOptions, pkg: `${typeof Libraries.GT_NEXT}`, errors: string[], warnings: string[]): Promise<{
+    filesUpdated: string[];
+}>;