gtx-cli 1.0.0-alpha.2 → 1.0.0

package/dist/cli/next.js

@@ -19,8 +19,8 @@ const prompts_1 = require("@inquirer/prompts");
 const postProcess_1 = require("../hooks/postProcess");
 const findFilepath_1 = __importDefault(require("../fs/findFilepath"));
 const scanForContent_1 = __importDefault(require("../next/parse/scanForContent"));
-const createDictionaryUpdates_1 = __importDefault(require("../react/updates/createDictionaryUpdates"));
-const createInlineUpdates_1 = __importDefault(require("../react/updates/createInlineUpdates"));
+const createDictionaryUpdates_1 = __importDefault(require("../react/parse/createDictionaryUpdates"));
+const createInlineUpdates_1 = __importDefault(require("../react/parse/createInlineUpdates"));
 const handleInitGT_1 = __importDefault(require("../next/parse/handleInitGT"));
 const react_1 = require("./react");
 const generateSettings_1 = require("../config/generateSettings");

package/dist/cli/react.js

@@ -121,14 +121,7 @@ class ReactCLI extends base_1.BaseCLI {
             .description('Generate a translation file for the source locale. The -t flag must be provided. This command should be used if you are handling your own translations.')
             .option('--src <paths...>', "Filepath to directory containing the app's source code, by default ./src || ./app || ./pages || ./components", (0, findFilepath_1.findFilepaths)(['./src', './app', './pages', './components']))
             .option('--tsconfig, --jsconfig <path>', 'Path to jsconfig or tsconfig file', (0, findFilepath_1.default)(['./tsconfig.json', './jsconfig.json']))
-            .option('--dictionary <path>', 'Path to dictionary file', (0, findFilepath_1.default)([
-            './dictionary.js',
-            './src/dictionary.js',
-            './dictionary.json',
-            './src/dictionary.json',
-            './dictionary.ts',
-            './src/dictionary.ts',
-        ]))
+            .option('--dictionary <path>', 'Path to dictionary file')
             .option('--default-language, --default-locale <locale>', 'Source locale (e.g., en)', 'en')
             .option('--inline', 'Include inline <T> tags in addition to dictionary file', true)
             .option('--ignore-errors', 'Ignore errors encountered while scanning for <T> tags', false)
@@ -157,8 +150,19 @@ class ReactCLI extends base_1.BaseCLI {
         return __awaiter(this, void 0, void 0, function* () {
             (0, console_1.displayAsciiTitle)();
             (0, console_1.displayInitializingText)();
-            const { updates, errors } = yield this.createUpdates(options);
             const settings = (0, generateSettings_1.generateSettings)(options);
+            options = Object.assign(Object.assign({}, options), settings);
+            if (!options.dictionary) {
+                options.dictionary = (0, findFilepath_1.default)([
+                    './dictionary.js',
+                    './src/dictionary.js',
+                    './dictionary.json',
+                    './src/dictionary.json',
+                    './dictionary.ts',
+                    './src/dictionary.ts',
+                ]);
+            }
+            const { updates, errors } = yield this.createUpdates(options);
             if (errors.length > 0) {
                 if (options.ignoreErrors) {
                     console.log(chalk_1.default.red(`CLI tool encountered errors while scanning for ${chalk_1.default.green('<T>')} tags.\n`));
@@ -438,11 +442,13 @@ class ReactCLI extends base_1.BaseCLI {
                 // {defaultLocale}.json file exists in the translationsDir, and use that as a source
                 // instead
                 const sourceFile = (0, findFilepath_1.findFileInDir)(options.translationsDir, `${options.defaultLocale}.json`);
-                options.dictionary = sourceFile;
-                updates = [
-                    ...updates,
-                    ...(yield this.createDictionaryUpdates(options, (0, createESBuildConfig_1.default)({}))),
-                ];
+                if (sourceFile) {
+                    options.dictionary = sourceFile;
+                    updates = [
+                        ...updates,
+                        ...(yield this.createDictionaryUpdates(options, (0, createESBuildConfig_1.default)({}))),
+                    ];
+                }
             }
             // Scan through project for <T> tags
             if (options.inline) {

package/dist/formats/json/translate.js

@@ -41,7 +41,7 @@ function translateJson(sourceJson, settings, dataFormat, fileExtension) {
                 id,
             };
             updates.push({
-                type: dataFormat,
+                dataFormat,
                 source,
                 metadata,
             });

package/dist/fs/findFilepath.js

@@ -58,7 +58,7 @@ function getRelativePath(file, srcDirectory) {
 function findFile(filePattern, file) {
     // Handle wildcard pattern by replacing the wildcard with the file parameter
     const resolvedPath = filePattern.replace(/\*/, file);
-    if (fs_1.default.existsSync(resolvedPath)) {
+    if (fs_1.default.existsSync(resolvedPath) && fs_1.default.statSync(resolvedPath).isFile()) {
         return fs_1.default.readFileSync(resolvedPath, 'utf8');
     }
     return '';
@@ -71,8 +71,13 @@ function findFile(filePattern, file) {
  */
 function findFileInDir(dir, file) {
     const resolvedPath = path_1.default.join(dir, file);
-    if (fs_1.default.existsSync(resolvedPath)) {
-        return fs_1.default.readFileSync(resolvedPath, 'utf8');
+    try {
+        if (fs_1.default.existsSync(resolvedPath)) {
+            return fs_1.default.readFileSync(resolvedPath, 'utf8');
+        }
+    }
+    catch (error) {
+        console.error(error);
     }
     return '';
 }

package/dist/react/jsx/parse/parseStringFunction.js

@@ -103,7 +103,7 @@ function parseStrings(importName, path, updates, errors, file) {
                                 });
                             }
                             updates.push({
-                                type: 'JSX',
+                                dataFormat: 'JSX',
                                 source: content,
                                 metadata,
                             });

package/dist/react/jsx/utils/parseJsx.js

@@ -228,7 +228,7 @@ function parseJSXElement(importAliases, node, updates, errors, file) {
         // <T> is valid here
         // displayFoundTMessage(file, id);
         updates.push({
-            type: 'JSX',
+            dataFormat: 'JSX',
             source: componentObj.tree,
             metadata: componentObj.props,
         });

package/dist/react/jsx/utils/parseStringFunction.js

@@ -103,7 +103,7 @@ function parseStrings(importName, path, updates, errors, file) {
                                 });
                             }
                             updates.push({
-                                type: 'JSX',
+                                dataFormat: 'JSX',
                                 source: content,
                                 metadata,
                             });

package/dist/react/parse/createDictionaryUpdates.js

@@ -65,9 +65,9 @@ function createDictionaryUpdates(options, esbuildConfig) {
             const context = props === null || props === void 0 ? void 0 : props.context;
             const metadata = Object.assign(Object.assign({ id }, (context && { context })), { 
                 // This hash isn't actually used by the GT API, just for consistency sake
-                hash: (0, id_1.hashJsxChildren)(Object.assign(Object.assign({ source }, (context && { context })), (id && { id }))) });
+                hash: (0, id_1.hashJsxChildren)(Object.assign(Object.assign(Object.assign({ source }, (context && { context })), (id && { id })), { dataFormat: 'JSX' })) });
             updates.push({
-                type: 'JSX',
+                dataFormat: 'JSX',
                 source,
                 metadata,
             });

package/dist/react/parse/createInlineUpdates.js

@@ -133,7 +133,7 @@ function createInlineUpdates(options, pkg) {
         // Post-process to add a hash to each update
         yield Promise.all(updates.map((update) => __awaiter(this, void 0, void 0, function* () {
             const context = update.metadata.context;
-            const hash = (0, id_1.hashJsxChildren)(Object.assign(Object.assign({ source: update.source }, (context && { context })), (update.metadata.id && { id: update.metadata.id })));
+            const hash = (0, id_1.hashJsxChildren)(Object.assign(Object.assign(Object.assign({ source: update.source }, (context && { context })), (update.metadata.id && { id: update.metadata.id })), { dataFormat: 'JSX' }));
             update.metadata.hash = hash;
         })));
         return { updates, errors };

package/dist/types/index.d.ts

@@ -2,13 +2,13 @@ import { JsxChildren } from 'generaltranslation/internal';
 export type Updates = ({
     metadata: Record<string, any>;
 } & ({
-    type: 'JSX';
+    dataFormat: 'JSX';
     source: JsxChildren;
 } | {
-    type: 'ICU';
+    dataFormat: 'ICU';
     source: string;
 } | {
-    type: 'I18NEXT';
+    dataFormat: 'I18NEXT';
     source: string;
 }))[];
 export type Options = {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gtx-cli",
-  "version": "1.0.0-alpha.2",
+  "version": "1.0.0",
   "main": "dist/index.js",
   "bin": "dist/main.js",
   "scripts": {
@@ -52,9 +52,9 @@
     "commander": "^12.1.0",
     "dotenv": "^16.4.5",
     "esbuild": "^0.23.1",
-    "generaltranslation": "^6.2.1-alpha.1",
-    "js-yaml": "^4.1.0",
-    "ora": "^8.2.0"
+    "generaltranslation": "^6.2.1",
+    "ora": "^8.2.0",
+    "yaml": "^2.7.0"
   },
   "devDependencies": {
     "@biomejs/biome": "1.9.4",

package/dist/react/updates/createDictionaryUpdates.d.ts

@@ -1,5 +0,0 @@
-import { BuildOptions } from 'esbuild';
-import { Options, Updates } from '../../types';
-export default function createDictionaryUpdates(options: Options & {
-    dictionary: string;
-}, esbuildConfig: BuildOptions): Promise<Updates>;

package/dist/react/updates/createDictionaryUpdates.js

@@ -1,76 +0,0 @@
-"use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.default = createDictionaryUpdates;
-const react_1 = __importDefault(require("react"));
-const fs_1 = __importDefault(require("fs"));
-const path_1 = __importDefault(require("path"));
-const os_1 = __importDefault(require("os"));
-const esbuild_1 = require("esbuild");
-const internal_1 = require("gt-react/internal");
-const generaltranslation_1 = require("generaltranslation");
-const loadJSON_1 = __importDefault(require("../../fs/loadJSON"));
-const id_1 = require("generaltranslation/id");
-function createDictionaryUpdates(options, esbuildConfig) {
-    return __awaiter(this, void 0, void 0, function* () {
-        let dictionary;
-        // ---- HANDLE JSON STRING DICTIONARY ----- //
-        if (options.dictionary.endsWith('.json')) {
-            dictionary = (0, internal_1.flattenDictionary)((0, loadJSON_1.default)(options.dictionary) || {});
-        }
-        // ----- HANDLE REACT DICTIONARY ---- //
-        else {
-            const result = yield (0, esbuild_1.build)(Object.assign(Object.assign({}, esbuildConfig), { entryPoints: [options.dictionary], write: false }));
-            const bundledCode = result.outputFiles[0].text;
-            const tempFilePath = path_1.default.join(os_1.default.tmpdir(), 'bundled-dictionary.js');
-            fs_1.default.writeFileSync(tempFilePath, bundledCode);
-            globalThis.React = react_1.default;
-            // Load the module using require
-            let dictionaryModule;
-            try {
-                dictionaryModule = require(tempFilePath);
-            }
-            catch (error) {
-                console.error(`Failed to load the bundled dictionary code:`, error);
-                process.exit(1);
-            }
-            finally {
-                // Clean up the temporary file
-                fs_1.default.unlinkSync(tempFilePath);
-            }
-            dictionary = (0, internal_1.flattenDictionary)(dictionaryModule.default ||
-                dictionaryModule.dictionary ||
-                dictionaryModule);
-        }
-        if (!Object.keys(dictionary).length)
-            throw new Error(`Dictionary filepath provided: "${options.dictionary}", but no entries found.`);
-        // ----- CREATE PARTIAL UPDATES ----- //
-        let updates = [];
-        for (const id of Object.keys(dictionary)) {
-            let { entry, metadata: props, // context, etc.
-             } = (0, internal_1.getEntryAndMetadata)(dictionary[id]);
-            const source = (0, generaltranslation_1.splitStringToContent)(entry);
-            const context = props === null || props === void 0 ? void 0 : props.context;
-            const metadata = Object.assign(Object.assign({ id }, (context && { context })), { 
-                // This hash isn't actually used by the GT API, just for consistency sake
-                hash: (0, id_1.hashJsxChildren)(Object.assign(Object.assign({ source }, (context && { context })), (id && { id }))) });
-            updates.push({
-                type: 'JSX',
-                source,
-                metadata,
-            });
-        }
-        return updates;
-    });
-}

package/dist/react/updates/createInlineUpdates.d.ts

@@ -1,5 +0,0 @@
-import { Options, Updates } from '../../types';
-export default function createInlineUpdates(options: Options, pkg: 'gt-react' | 'gt-next'): Promise<{
-    updates: Updates;
-    errors: string[];
-}>;

package/dist/react/updates/createInlineUpdates.js

@@ -1,141 +0,0 @@
-"use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.default = createInlineUpdates;
-const fs_1 = __importDefault(require("fs"));
-const path_1 = __importDefault(require("path"));
-const parser_1 = require("@babel/parser");
-const traverse_1 = __importDefault(require("@babel/traverse"));
-const id_1 = require("generaltranslation/id");
-const parseJsx_1 = require("../jsx/utils/parseJsx");
-const parseStringFunction_1 = require("../jsx/utils/parseStringFunction");
-const parseAst_1 = require("../jsx/utils/parseAst");
-function createInlineUpdates(options, pkg) {
-    return __awaiter(this, void 0, void 0, function* () {
-        const updates = [];
-        const errors = [];
-        // Use the provided app directory or default to the current directory
-        const srcDirectory = options.src || ['./'];
-        // Define the file extensions to look for
-        const extensions = ['.js', '.jsx', '.tsx'];
-        /**
-         * Recursively scan the directory and collect all files with the specified extensions,
-         * excluding files or directories that start with a dot (.)
-         * @param dir - The directory to scan
-         * @returns An array of file paths
-         */
-        function getFiles(dir) {
-            let files = [];
-            const items = fs_1.default.readdirSync(dir);
-            for (const item of items) {
-                // Skip hidden files and directories
-                if (item.startsWith('.'))
-                    continue;
-                const fullPath = path_1.default.join(dir, item);
-                const stat = fs_1.default.statSync(fullPath);
-                if (stat.isDirectory()) {
-                    // Recursively scan subdirectories
-                    files = files.concat(getFiles(fullPath));
-                }
-                else if (extensions.includes(path_1.default.extname(item))) {
-                    // Add files with the specified extensions
-                    files.push(fullPath);
-                }
-            }
-            return files;
-        }
-        const files = srcDirectory.flatMap((dir) => getFiles(dir));
-        for (const file of files) {
-            const code = fs_1.default.readFileSync(file, 'utf8');
-            let ast;
-            try {
-                ast = (0, parser_1.parse)(code, {
-                    sourceType: 'module',
-                    plugins: ['jsx', 'typescript'],
-                });
-            }
-            catch (error) {
-                console.error(`Error parsing file ${file}:`, error);
-                continue;
-            }
-            const translationFuncs = [
-                'useGT',
-                'getGT',
-                'T',
-                'Var',
-                'DateTime',
-                'Currency',
-                'Num',
-                'Branch',
-                'Plural',
-            ];
-            const importAliases = {};
-            // handle imports & alias & handle string functions
-            (0, traverse_1.default)(ast, {
-                ImportDeclaration(path) {
-                    if (path.node.source.value.startsWith(pkg)) {
-                        const importName = (0, parseAst_1.extractImportName)(path.node, pkg, translationFuncs);
-                        for (const name of importName) {
-                            if (name.original === 'useGT' || name.original === 'getGT') {
-                                (0, parseStringFunction_1.parseStrings)(name.local, path, updates, errors, file);
-                            }
-                            else {
-                                importAliases[name.local] = name.original;
-                            }
-                        }
-                    }
-                },
-                VariableDeclarator(path) {
-                    var _a;
-                    // Check if the init is a require call
-                    if (((_a = path.node.init) === null || _a === void 0 ? void 0 : _a.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 = (0, parseAst_1.extractImportName)(parentPath.node, pkg, translationFuncs);
-                                for (const name of importName) {
-                                    if (name.original === 'useGT' || name.original === 'getGT') {
-                                        (0, parseStringFunction_1.parseStrings)(name.local, parentPath, updates, errors, file);
-                                    }
-                                    else {
-                                        importAliases[name.local] = name.original;
-                                    }
-                                }
-                            }
-                        }
-                    }
-                },
-            });
-            // Parse <T> components
-            (0, traverse_1.default)(ast, {
-                JSXElement(path) {
-                    (0, parseJsx_1.parseJSXElement)(importAliases, path.node, updates, errors, file);
-                },
-            });
-        }
-        // Post-process to add a hash to each update
-        yield Promise.all(updates.map((update) => __awaiter(this, void 0, void 0, function* () {
-            const context = update.metadata.context;
-            const hash = (0, id_1.hashJsxChildren)(Object.assign(Object.assign({ source: update.source }, (context && { context })), (update.metadata.id && { id: update.metadata.id })));
-            update.metadata.hash = hash;
-        })));
-        return { updates, errors };
-    });
-}

package/dist/react/updates/scanForContent.d.ts

@@ -1,13 +0,0 @@
-import { SupportedFrameworks, WrapOptions } from '../../types';
-/**
- * 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 default function scanForContent(options: WrapOptions, pkg: 'gt-next' | 'gt-react', framework: SupportedFrameworks): Promise<{
-    errors: string[];
-    filesUpdated: string[];
-    warnings: string[];
-}>;

package/dist/react/updates/scanForContent.js

@@ -1,200 +0,0 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || (function () {
-    var ownKeys = function(o) {
-        ownKeys = Object.getOwnPropertyNames || function (o) {
-            var ar = [];
-            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
-            return ar;
-        };
-        return ownKeys(o);
-    };
-    return function (mod) {
-        if (mod && mod.__esModule) return mod;
-        var result = {};
-        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
-        __setModuleDefault(result, mod);
-        return result;
-    };
-})();
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.default = scanForContent;
-const fs_1 = __importDefault(require("fs"));
-const path_1 = __importDefault(require("path"));
-const t = __importStar(require("@babel/types"));
-const parser_1 = require("@babel/parser");
-const traverse_1 = __importDefault(require("@babel/traverse"));
-const generator_1 = __importDefault(require("@babel/generator"));
-const findJsxFilepath_1 = require("../../fs/findJsxFilepath");
-const evaluateJsx_1 = require("../jsx/evaluateJsx");
-const wrapJsx_1 = require("../jsx/wrapJsx");
-const findFilepath_1 = require("../../fs/findFilepath");
-const parseAst_1 = require("../jsx/utils/parseAst");
-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
- */
-function scanForContent(options, pkg, framework) {
-    return __awaiter(this, void 0, void 0, function* () {
-        const errors = [];
-        const warnings = [];
-        const srcDirectory = options.src || ['./'];
-        const files = srcDirectory.flatMap((dir) => (0, findJsxFilepath_1.getFiles)(dir));
-        const filesUpdated = [];
-        for (const file of files) {
-            const baseFileName = path_1.default.basename(file);
-            const configPath = path_1.default.relative(path_1.default.dirname(file), path_1.default.resolve(process.cwd(), options.config));
-            // Ensure the path starts with ./ or ../
-            const normalizedConfigPath = configPath.startsWith('.')
-                ? configPath
-                : './' + configPath;
-            const code = fs_1.default.readFileSync(file, 'utf8');
-            // Create relative path from src directory and remove extension
-            const relativePath = (0, findFilepath_1.getRelativePath)(file, srcDirectory[0]);
-            let ast;
-            try {
-                ast = (0, parser_1.parse)(code, {
-                    sourceType: 'module',
-                    plugins: ['jsx', 'typescript'],
-                    tokens: true,
-                    createParenthesizedExpressions: true,
-                });
-            }
-            catch (error) {
-                console.error(`Error parsing file ${file}:`, error);
-                errors.push(`Failed to parse ${file}: ${error}`);
-                continue;
-            }
-            let modified = false;
-            let usedImports = [];
-            let { importAlias, initialImports } = (0, parseAst_1.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;
-            (0, traverse_1.default)(ast, {
-                JSXElement(path) {
-                    var _a;
-                    if (framework === 'next-pages' &&
-                        options.addGTProvider &&
-                        (baseFileName === '_app.tsx' || baseFileName === '_app.jsx')) {
-                        // Check if this is the top-level JSX element in the default export
-                        let isDefaultExport = false;
-                        let currentPath = path;
-                        // Check if GTProvider already exists in the ancestors
-                        let hasGTProvider = false;
-                        while (currentPath.parentPath) {
-                            if (t.isJSXElement(currentPath.node) &&
-                                t.isJSXIdentifier(currentPath.node.openingElement.name) &&
-                                currentPath.node.openingElement.name.name === 'GTProvider') {
-                                hasGTProvider = true;
-                                break;
-                            }
-                            if (t.isExportDefaultDeclaration(currentPath.parentPath.node)) {
-                                isDefaultExport = true;
-                            }
-                            currentPath = currentPath.parentPath;
-                        }
-                        if (isDefaultExport && !hasGTProvider) {
-                            // Wrap the JSX 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
-                    let currentPath = path;
-                    if (t.isJSXElement((_a = currentPath.parentPath) === null || _a === void 0 ? void 0 : _a.node)) {
-                        // If we found a JSX parent, skip processing this node
-                        return;
-                    }
-                    // At this point, we're only processing top-level JSX elements
-                    const opts = Object.assign(Object.assign({}, importAlias), { idPrefix: relativePath, idCount: globalId, usedImports, modified: false, createIds: !options.disableIds, warnings,
-                        file });
-                    const wrapped = (0, wrapJsx_1.handleJsxElement)(path.node, opts, evaluateJsx_1.isMeaningful);
-                    path.replaceWith(wrapped.node);
-                    // Update global counters
-                    modified = modified || opts.modified;
-                    globalId = opts.idCount;
-                },
-            });
-            if (!modified)
-                continue;
-            let needsImport = usedImports.filter((imp) => typeof imp === 'string'
-                ? !initialImports.includes(imp)
-                : !initialImports.includes(imp.local));
-            if (needsImport.length > 0) {
-                (0, parseAst_1.createImports)(ast, needsImport, IMPORT_MAP);
-            }
-            try {
-                const output = (0, generator_1.default)(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
-                fs_1.default.writeFileSync(file, processedCode);
-                filesUpdated.push(file);
-            }
-            catch (error) {
-                console.error(`Error writing file ${file}:`, error);
-                errors.push(`Failed to write ${file}: ${error}`);
-            }
-        }
-        return { errors, filesUpdated, warnings };
-    });
-}