gtx-cli 2.6.31 → 2.7.0

package/README.md

@@ -14,12 +14,21 @@
 
 # gtx-cli
 
+> **Deprecated:** This package has been renamed to [`gt`](https://www.npmjs.com/package/gt). Please use `gt` instead. This package is a backward-compatibility wrapper and will continue to work, but all future development happens in `gt`.
+
 Command-line tool for General Translation's i18n platform.
 
+## Migration
+
+```bash
+npm uninstall gtx-cli
+npm install gt --save-dev
+```
+
 ## Installation
 
 ```bash
-npm install gtx-cli --save-dev
+npm install gt --save-dev
 ```
 
 ## Quick Start
@@ -27,13 +36,13 @@ npm install gtx-cli --save-dev
 Set up your project:
 
 ```bash
-npx gtx-cli init
+npx gt init
 ```
 
 Generate translations:
 
 ```bash
-npx gtx-cli translate
+npx gt translate
 ```
 
 See the [full documentation](https://generaltranslation.com/docs/cli) for guides and API reference.

package/dist/bin/bin-entry.js

@@ -1,9 +1,10 @@
 // Entry point for binaries
-import { main } from '../index.js';
+import { main } from 'gt';
 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.name('gtx-cli');
 program.parse();

package/dist/config/generateSettings.d.ts

@@ -1,9 +1 @@
-import { Settings } from '../types/index.js';
-export declare const DEFAULT_SRC_PATTERNS: string[];
-/**
- * Generates settings from any
- * @param flags - The CLI flags to generate settings from
- * @param cwd - The current working directory
- * @returns The generated settings
- */
-export declare function generateSettings(flags: Record<string, any>, cwd?: string): Promise<Settings>;
+export * from 'gt/config/generateSettings';

package/dist/config/generateSettings.js

@@ -1,214 +1 @@
-import { displayProjectId, exitSync, logErrorAndExit, warnApiKeyInConfig, } from '../console/logging.js';
-import { loadConfig } from '../fs/config/loadConfig.js';
-import { defaultBaseUrl, libraryDefaultLocale, } from 'generaltranslation/internal';
-import fs from 'node:fs';
-import { createOrUpdateConfig } from '../fs/config/setupConfig.js';
-import { resolveFiles } from '../fs/config/parseFilesConfig.js';
-import { validateSettings } from './validateSettings.js';
-import { DEFAULT_GIT_REMOTE_NAME, GT_DASHBOARD_URL, } from '../utils/constants.js';
-import { resolveProjectId } from '../fs/utils.js';
-import path from 'node:path';
-import chalk from 'chalk';
-import { resolveConfig } from './resolveConfig.js';
-import { gt } from '../utils/gt.js';
-import { generatePreset } from './optionPresets.js';
-export const DEFAULT_SRC_PATTERNS = [
-    'src/**/*.{js,jsx,ts,tsx}',
-    'app/**/*.{js,jsx,ts,tsx}',
-    'pages/**/*.{js,jsx,ts,tsx}',
-    'components/**/*.{js,jsx,ts,tsx}',
-];
-/**
- * Generates settings from any
- * @param flags - The CLI flags to generate settings from
- * @param cwd - The current working directory
- * @returns The generated settings
- */
-export async function generateSettings(flags, cwd = process.cwd()) {
-    // Load config file
-    let gtConfig = {};
-    if (flags.config && !flags.config.endsWith('.json')) {
-        flags.config = `${flags.config}.json`;
-    }
-    if (flags.config) {
-        gtConfig = loadConfig(flags.config);
-    }
-    else {
-        const config = resolveConfig(cwd);
-        if (config) {
-            gtConfig = config.config;
-            flags.config = config.path;
-        }
-        else {
-            gtConfig = {};
-        }
-    }
-    // Warn if apiKey is present in gt.config.json
-    if (gtConfig.apiKey) {
-        warnApiKeyInConfig(flags.config);
-        exitSync(1);
-    }
-    const projectIdEnv = resolveProjectId();
-    // Resolve mismatched projectIds
-    if (gtConfig.projectId &&
-        flags.projectId &&
-        gtConfig.projectId !== flags.projectId) {
-        logErrorAndExit(`Project ID mismatch between ${chalk.green(gtConfig.projectId)} and ${chalk.green(flags.projectId)}! Please use the same projectId in all configs.`);
-    }
-    else if (gtConfig.projectId &&
-        projectIdEnv &&
-        gtConfig.projectId !== projectIdEnv) {
-        logErrorAndExit(`Project ID mismatch between ${chalk.green(gtConfig.projectId)} and ${chalk.green(projectIdEnv)}! Please use the same projectId in all configs.`);
-    }
-    if (flags.options?.docsUrlPattern &&
-        !flags.options?.docsUrlPattern.includes('[locale]')) {
-        logErrorAndExit('Failed to localize static urls: URL pattern must include "[locale]" to denote the location of the locale');
-    }
-    if (flags.options?.docsImportPattern &&
-        !flags.options?.docsImportPattern.includes('[locale]')) {
-        logErrorAndExit('Failed to localize static imports: Import pattern must include "[locale]" to denote the location of the locale');
-    }
-    if (flags.options?.copyFiles) {
-        for (const file of flags.options.copyFiles) {
-            if (!file.includes('[locale]')) {
-                logErrorAndExit('Failed to copy files: File path must include "[locale]" to denote the location of the locale');
-            }
-        }
-    }
-    // merge options
-    const mergedOptions = { ...gtConfig, ...flags };
-    // Add defaultLocale if not provided
-    mergedOptions.defaultLocale =
-        mergedOptions.defaultLocale || libraryDefaultLocale;
-    // merge locales
-    mergedOptions.locales = Array.from(new Set([...(gtConfig.locales || []), ...(flags.locales || [])]));
-    // Separate defaultLocale from locales
-    mergedOptions.locales = mergedOptions.locales.filter((locale) => locale !== mergedOptions.defaultLocale);
-    // Add apiKey if not provided
-    mergedOptions.apiKey = mergedOptions.apiKey || process.env.GT_API_KEY;
-    // Add projectId if not provided
-    mergedOptions.projectId = mergedOptions.projectId || resolveProjectId();
-    // Add baseUrl if not provided
-    mergedOptions.baseUrl = mergedOptions.baseUrl || defaultBaseUrl;
-    // Add dashboardUrl if not provided
-    mergedOptions.dashboardUrl = mergedOptions.dashboardUrl || GT_DASHBOARD_URL;
-    // Add locales if not provided
-    mergedOptions.locales = mergedOptions.locales || [];
-    // Add default config file name if not provided
-    mergedOptions.config =
-        mergedOptions.config || path.join(cwd, 'gt.config.json');
-    // Display projectId if present
-    if (mergedOptions.projectId)
-        displayProjectId(mergedOptions.projectId);
-    // Add stageTranslations if not provided
-    // For human review, always stage the project
-    mergedOptions.stageTranslations = mergedOptions.stageTranslations ?? false;
-    // Add publish if not provided
-    mergedOptions.publish = (gtConfig.publish || flags.publish) ?? false;
-    // Populate src if not provided
-    mergedOptions.src = mergedOptions.src || DEFAULT_SRC_PATTERNS;
-    // Resolve all glob patterns in the files object
-    const compositePatterns = [
-        ...Object.entries(mergedOptions.options?.jsonSchema || {}),
-    ]
-        .filter(([, schema]) => schema.composite)
-        .map(([key]) => key);
-    mergedOptions.files = mergedOptions.files
-        ? resolveFiles(mergedOptions.files, mergedOptions.defaultLocale, mergedOptions.locales, cwd, compositePatterns)
-        : { resolvedPaths: {}, placeholderPaths: {}, transformPaths: {} };
-    mergedOptions.options = {
-        ...(mergedOptions.options || {}),
-        mintlify: {
-            ...(mergedOptions.options?.mintlify || {}),
-            inferTitleFromFilename: gtConfig.options?.mintlify?.inferTitleFromFilename ||
-                mergedOptions.options?.mintlify?.inferTitleFromFilename,
-        },
-        experimentalLocalizeStaticImports: gtConfig.options?.experimentalLocalizeStaticImports ||
-            flags.experimentalLocalizeStaticImports,
-        experimentalLocalizeStaticUrls: gtConfig.options?.experimentalLocalizeStaticUrls ||
-            flags.experimentalLocalizeStaticUrls,
-        experimentalLocalizeRelativeAssets: gtConfig.options?.experimentalLocalizeRelativeAssets ||
-            flags.experimentalLocalizeRelativeAssets,
-        experimentalHideDefaultLocale: gtConfig.options?.experimentalHideDefaultLocale ||
-            flags.experimentalHideDefaultLocale,
-        experimentalFlattenJsonFiles: gtConfig.options?.experimentalFlattenJsonFiles ||
-            flags.experimentalFlattenJsonFiles,
-        experimentalClearLocaleDirs: gtConfig.options?.experimentalClearLocaleDirs ||
-            flags.experimentalClearLocaleDirs,
-        clearLocaleDirsExclude: gtConfig.options?.clearLocaleDirsExclude || flags.clearLocaleDirsExclude,
-    };
-    // Add additional options if provided
-    if (mergedOptions.options) {
-        if (mergedOptions.options.jsonSchema) {
-            for (const fileGlob of Object.keys(mergedOptions.options.jsonSchema)) {
-                const jsonSchema = mergedOptions.options.jsonSchema[fileGlob];
-                if (jsonSchema.preset) {
-                    mergedOptions.options.jsonSchema[fileGlob] = {
-                        ...generatePreset(jsonSchema.preset, 'json'),
-                        ...jsonSchema,
-                    };
-                }
-            }
-        }
-        if (mergedOptions.options.yamlSchema) {
-            for (const fileGlob of Object.keys(mergedOptions.options.yamlSchema)) {
-                const yamlSchema = mergedOptions.options.yamlSchema[fileGlob];
-                if (yamlSchema.preset) {
-                    mergedOptions.options.yamlSchema[fileGlob] = {
-                        ...generatePreset(yamlSchema.preset, 'yaml'),
-                        ...yamlSchema,
-                    };
-                }
-            }
-        }
-    }
-    // Add parsing options if not provided
-    mergedOptions.parsingOptions = mergedOptions.parsingOptions || {};
-    mergedOptions.parsingOptions.conditionNames = mergedOptions.parsingOptions
-        .conditionNames || [
-        'development',
-        'browser',
-        'module',
-        'import',
-        'require',
-        'default',
-    ];
-    // Add branch options if not provided
-    const branchOptions = mergedOptions.branchOptions || {};
-    // If --branch is set, enable branching
-    branchOptions.enabled =
-        flags.enableBranching ??
-            gtConfig.branchOptions?.enabled ??
-            (flags.branch ? true : false);
-    branchOptions.currentBranch =
-        flags.branch ?? gtConfig.branchOptions?.currentBranch ?? undefined;
-    branchOptions.autoDetectBranches = flags.disableBranchDetection
-        ? false
-        : (gtConfig.branchOptions?.autoDetectBranches ?? true);
-    branchOptions.remoteName =
-        flags.remoteName ??
-            gtConfig.branchOptions?.remoteName ??
-            DEFAULT_GIT_REMOTE_NAME;
-    mergedOptions.branchOptions = branchOptions;
-    // if there's no existing config file, creates one
-    // does not include the API key to avoid exposing it
-    if (!fs.existsSync(mergedOptions.config)) {
-        await createOrUpdateConfig(mergedOptions.config, {
-            projectId: mergedOptions.projectId,
-            defaultLocale: mergedOptions.defaultLocale,
-            locales: mergedOptions.locales?.length > 0 ? mergedOptions.locales : undefined,
-            framework: mergedOptions.framework,
-        });
-    }
-    mergedOptions.configDirectory = path.join(cwd, '.gt');
-    validateSettings(mergedOptions);
-    // Set up GT instance
-    gt.setConfig({
-        projectId: mergedOptions.projectId,
-        apiKey: mergedOptions.apiKey,
-        baseUrl: mergedOptions.baseUrl,
-        sourceLocale: mergedOptions.defaultLocale,
-        customMapping: mergedOptions.customMapping,
-    });
-    return mergedOptions;
-}
+export * from 'gt/config/generateSettings';

package/dist/config/resolveConfig.d.ts

@@ -1,4 +1 @@
-export declare function resolveConfig(cwd: string): {
-    path: string;
-    config: Record<string, any>;
-} | null;
+export * from 'gt/config/resolveConfig';

package/dist/config/resolveConfig.js

@@ -1,33 +1 @@
-import fs from 'node:fs';
-import path from 'node:path';
-import { loadConfig } from '../fs/config/loadConfig.js';
-export function resolveConfig(cwd) {
-    const configFilepath = 'gt.config.json';
-    if (fs.existsSync(path.join(cwd, configFilepath))) {
-        return {
-            path: path.join(cwd, configFilepath),
-            config: loadConfig(path.join(cwd, configFilepath)),
-        };
-    }
-    if (fs.existsSync(path.join(cwd, 'src/gt.config.json'))) {
-        return {
-            path: path.join(cwd, 'src/gt.config.json'),
-            config: loadConfig(path.join(cwd, 'src/gt.config.json')),
-        };
-    }
-    // Support config under .gt for parity with .locadex
-    if (fs.existsSync(path.join(cwd, '.gt/gt.config.json'))) {
-        return {
-            path: path.join(cwd, '.gt/gt.config.json'),
-            config: loadConfig(path.join(cwd, '.gt/gt.config.json')),
-        };
-    }
-    // Backward compatibility: support legacy .locadex directory
-    if (fs.existsSync(path.join(cwd, '.locadex/gt.config.json'))) {
-        return {
-            path: path.join(cwd, '.locadex/gt.config.json'),
-            config: loadConfig(path.join(cwd, '.locadex/gt.config.json')),
-        };
-    }
-    return null;
-}
+export * from 'gt/config/resolveConfig';

package/dist/fs/config/setupConfig.d.ts

@@ -1,17 +1 @@
-import { FilesOptions, SupportedFrameworks } from '../../types/index.js';
-/**
- * Checks if the config file exists.
- * If yes, make sure make sure projectId is correct
- * If not, creates a new JSON file at the given filepath and writes the provided config object to it.
- * @param {string} configFilepath - The path to the config file.
- * @param {Record<string, any>} configObject - The config object to write if the file does not exist.
- */
-export declare function createOrUpdateConfig(configFilepath: string, options: {
-    projectId?: string;
-    defaultLocale?: string;
-    locales?: string[];
-    files?: FilesOptions;
-    framework?: SupportedFrameworks;
-    baseUrl?: string;
-    publish?: boolean;
-}): Promise<string>;
+export * from 'gt/fs/config/setupConfig';

package/dist/fs/config/setupConfig.js

@@ -1,50 +1 @@
-import fs from 'node:fs';
-import { displayCreatedConfigFile } from '../../console/logging.js';
-import { logger } from '../../console/logger.js';
-import { GT_CONFIG_SCHEMA_URL } from '../../utils/constants.js';
-/**
- * Checks if the config file exists.
- * If yes, make sure make sure projectId is correct
- * If not, creates a new JSON file at the given filepath and writes the provided config object to it.
- * @param {string} configFilepath - The path to the config file.
- * @param {Record<string, any>} configObject - The config object to write if the file does not exist.
- */
-export async function createOrUpdateConfig(configFilepath, options) {
-    // Filter out empty string values from the config object
-    const newContent = {
-        ...(options.projectId && { projectId: options.projectId }),
-        ...(options.defaultLocale && { defaultLocale: options.defaultLocale }),
-        ...(options.files && { files: options.files }),
-        ...(options.framework && { framework: options.framework }),
-        ...(options.baseUrl && { baseUrl: options.baseUrl }),
-        ...(options.publish && { publish: options.publish }),
-    };
-    try {
-        // if file exists
-        let oldContent = {};
-        if (fs.existsSync(configFilepath)) {
-            oldContent = JSON.parse(await fs.promises.readFile(configFilepath, 'utf-8'));
-        }
-        // merge old and new content
-        const mergedContent = {
-            $schema: GT_CONFIG_SCHEMA_URL,
-            ...oldContent,
-            ...newContent,
-        };
-        // Add locales to mergedContent if they exist
-        if (options.locales) {
-            mergedContent.locales = mergedContent.locales
-                ? [...new Set([...mergedContent.locales, ...options.locales])]
-                : options.locales;
-        }
-        // write to file
-        const mergedJsonContent = JSON.stringify(mergedContent, null, 2);
-        await fs.promises.writeFile(configFilepath, mergedJsonContent, 'utf-8');
-        // show update in console
-        displayCreatedConfigFile(configFilepath);
-    }
-    catch (error) {
-        logger.error(`An error occurred while updating ${configFilepath}: ${error}`);
-    }
-    return configFilepath;
-}
+export * from 'gt/fs/config/setupConfig';

package/dist/fs/matchFiles.d.ts

@@ -1 +1 @@
-export declare function matchFiles(cwd: string, patterns: string[]): string[];
+export * from 'gt/fs/matchFiles';

package/dist/fs/matchFiles.js

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

package/dist/functions.d.ts

@@ -1,7 +1 @@
-/**
- * This file serves as an entrypoint for programmatically invoking CLI commands.
- * Import from 'gtx-cli/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';
+export * from 'gt/functions';

package/dist/functions.js

@@ -1,6 +1 @@
-/**
- * This file serves as an entrypoint for programmatically invoking CLI commands.
- * Import from 'gtx-cli/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';
+export * from 'gt/functions';

package/dist/index.d.ts

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

package/dist/index.js

@@ -1,27 +1 @@
-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('gtx-cli');
-    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 };
+export * from 'gt';

package/dist/main.js

@@ -1,10 +1,10 @@
 #!/usr/bin/env node
-// Non-binary router - directly runs main.ts
-import { main } from './index.js';
+import { main } from 'gt';
 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.name('gtx-cli');
 program.parse();

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

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

package/dist/next/parse/handleInitGT.js

@@ -1,157 +1 @@
-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}`);
-    }
-}
+export * from 'gt/next/parse/handleInitGT';

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

@@ -1,12 +1 @@
-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[];
-}>;
+export * from 'gt/next/parse/wrapContent';