npm - gtx-cli - Versions diffs - 0.0.1 → 0.0.2 - Mend

gtx-cli 0.0.1 → 0.0.2

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (84) hide show

package/README.md +4 -7
package/dist/api/waitForUpdates.d.ts +1 -0
package/dist/api/waitForUpdates.js +89 -0
package/dist/cli/base.d.ts +3 -0
package/dist/cli/base.js +11 -0
package/dist/cli/next.d.ts +18 -0
package/dist/cli/next.js +162 -0
package/dist/cli/react.d.ts +29 -0
package/dist/cli/react.js +550 -0
package/dist/console/console.d.ts +8 -0
package/dist/console/console.js +65 -0
package/dist/console/errors.d.ts +1 -0
package/dist/console/errors.js +4 -0
package/dist/console/index.d.ts +1 -0
package/dist/console/index.js +2 -0
package/dist/console/warnings.d.ts +7 -0
package/dist/console/warnings.js +47 -0
package/dist/fs/config/loadConfig.d.ts +1 -0
package/dist/fs/config/loadConfig.js +15 -0
package/dist/fs/config/setupConfig.d.ts +8 -0
package/dist/fs/config/setupConfig.js +37 -0
package/dist/fs/config/updateConfig.d.ts +10 -0
package/dist/fs/config/updateConfig.js +33 -0
package/dist/fs/findFilepath.d.ts +15 -0
package/dist/fs/findFilepath.js +49 -0
package/dist/fs/findJsxFilepath.d.ts +7 -0
package/dist/fs/findJsxFilepath.js +36 -0
package/dist/fs/index.d.ts +1 -0
package/dist/fs/index.js +2 -0
package/dist/fs/loadJSON.d.ts +6 -0
package/dist/fs/loadJSON.js +23 -0
package/dist/fs/saveTranslations.d.ts +3 -0
package/dist/fs/saveTranslations.js +57 -0
package/dist/hooks/postProcess.d.ts +4 -0
package/dist/hooks/postProcess.js +101 -0
package/dist/index.d.ts +3 -0
package/dist/index.js +84 -0
package/dist/main.d.ts +2 -0
package/dist/main.js +11 -0
package/dist/next/config/parseNextConfig.d.ts +10 -0
package/dist/next/config/parseNextConfig.js +55 -0
package/dist/next/jsx/utils.d.ts +7 -0
package/dist/next/jsx/utils.js +82 -0
package/dist/next/parse/handleInitGT.d.ts +5 -0
package/dist/next/parse/handleInitGT.js +167 -0
package/dist/next/parse/index.d.ts +4 -0
package/dist/next/parse/index.js +14 -0
package/dist/next/parse/scanForContent.d.ts +13 -0
package/dist/next/parse/scanForContent.js +189 -0
package/dist/react/config/createESBuildConfig.d.ts +2 -0
package/dist/react/config/createESBuildConfig.js +134 -0
package/dist/react/data-_gt/addGTIdentifierToSyntaxTree.d.ts +1 -0
package/dist/react/data-_gt/addGTIdentifierToSyntaxTree.js +92 -0
package/dist/react/jsx/evaluateJsx.d.ts +17 -0
package/dist/react/jsx/evaluateJsx.js +133 -0
package/dist/react/jsx/trimJsxStringChildren.d.ts +7 -0
package/dist/react/jsx/trimJsxStringChildren.js +97 -0
package/dist/react/jsx/utils/parseAst.d.ts +30 -0
package/dist/react/jsx/utils/parseAst.js +320 -0
package/dist/react/jsx/utils/parseJsx.d.ts +13 -0
package/dist/react/jsx/utils/parseJsx.js +236 -0
package/dist/react/jsx/utils/parseStringFunction.d.ts +12 -0
package/dist/react/jsx/utils/parseStringFunction.js +120 -0
package/dist/react/jsx/wrapJsx.d.ts +51 -0
package/dist/react/jsx/wrapJsx.js +407 -0
package/dist/react/parse/createDictionaryUpdates.d.ts +5 -0
package/dist/react/parse/createDictionaryUpdates.js +77 -0
package/dist/react/parse/createInlineUpdates.d.ts +5 -0
package/dist/react/parse/createInlineUpdates.js +141 -0
package/dist/react/parse/index.d.ts +3 -0
package/dist/react/parse/index.js +12 -0
package/dist/react/parse/scanForContent.d.ts +13 -0
package/dist/react/parse/scanForContent.js +200 -0
package/dist/react/types.d.ts +13 -0
package/dist/react/types.js +2 -0
package/dist/react/utils/flattenDictionary.d.ts +10 -0
package/dist/react/utils/flattenDictionary.js +38 -0
package/dist/react/utils/getEntryAndMetadata.d.ts +5 -0
package/dist/react/utils/getEntryAndMetadata.js +14 -0
package/dist/react/utils/getVariableName.d.ts +2 -0
package/dist/react/utils/getVariableName.js +20 -0
package/dist/types.d.ts +58 -0
package/dist/types.js +2 -0
package/package.json +9 -2

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

@@ -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 ADDED Viewed

@@ -0,0 +1,82 @@
+"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;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isHtmlElement = isHtmlElement;
+exports.isBodyElement = isBodyElement;
+exports.hasGTProviderChild = hasGTProviderChild;
+exports.addDynamicLangAttribute = addDynamicLangAttribute;
+exports.makeParentFunctionAsync = makeParentFunctionAsync;
+const t = __importStar(require("@babel/types"));
+// Helper function to check if is the <html> fragment
+function isHtmlElement(element) {
+    return (t.isJSXIdentifier(element.name) &&
+        element.name.name.toLowerCase() === 'html');
+}
+// Helper function to check if is the <body> fragment
+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
+function hasGTProviderChild(element) {
+    return element.children.some((child) => t.isJSXElement(child) &&
+        t.isJSXIdentifier(child.openingElement.name) &&
+        child.openingElement.name.name === 'GTProvider');
+}
+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'), [])))));
+}
+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 ADDED Viewed

@@ -0,0 +1,5 @@
+export default function handleInitGT(filepath: string): Promise<{
+    errors: string[];
+    filesUpdated: string[];
+    warnings: string[];
+}>;

package/dist/next/parse/handleInitGT.js ADDED Viewed

@@ -0,0 +1,167 @@
+"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 = handleInitGT;
+const fs_1 = __importDefault(require("fs"));
+const parser_1 = require("@babel/parser");
+const generator_1 = __importDefault(require("@babel/generator"));
+const traverse_1 = __importDefault(require("@babel/traverse"));
+const t = __importStar(require("@babel/types"));
+function handleInitGT(filepath) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const errors = [];
+        const warnings = [];
+        const filesUpdated = [];
+        const code = fs_1.default.readFileSync(filepath, 'utf8');
+        let ast;
+        try {
+            ast = (0, parser_1.parse)(code, {
+                sourceType: 'module',
+                plugins: ['jsx', 'typescript'],
+                tokens: true,
+                createParenthesizedExpressions: true,
+            });
+            const needsCJS = filepath.endsWith('.js');
+            // Check if withGTConfig or initGT is already imported/required
+            let hasGTConfig = false;
+            let hasInitGT = false;
+            (0, traverse_1.default)(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) &&
+                            t.isCallExpression(dec.init) &&
+                            t.isIdentifier(dec.init.callee, { name: 'require' }) &&
+                            t.isStringLiteral(dec.init.arguments[0], {
+                                value: 'gt-next/config',
+                            })) {
+                            if (t.isIdentifier(dec.id, { name: 'withGTConfig' }))
+                                hasGTConfig = true;
+                            if (t.isIdentifier(dec.id, { name: 'initGT' }))
+                                hasInitGT = true;
+                        }
+                    });
+                },
+            });
+            // Return early if either withGTConfig or initGT is already present
+            if (hasGTConfig || hasInitGT) {
+                return { errors, filesUpdated, warnings };
+            }
+            ast.program.body.unshift(needsCJS
+                ? 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
+            (0, traverse_1.default)(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 = (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;
+            // 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
+            fs_1.default.writeFileSync(filepath, processedCode);
+            filesUpdated.push(filepath);
+        }
+        catch (error) {
+            console.error(`Error parsing file ${filepath}:`, error);
+            errors.push(`Failed to parse ${filepath}: ${error}`);
+        }
+        return { errors, filesUpdated, warnings };
+    });
+}

package/dist/next/parse/index.d.ts ADDED Viewed

@@ -0,0 +1,4 @@
+export { default as scanForContent } from './scanForContent';
+export { default as handleInitGT } from './handleInitGT';
+export { default as createDictionaryUpdates } from '../../react/parse/createDictionaryUpdates';
+export { default as createInlineUpdates } from '../../react/parse/createInlineUpdates';

package/dist/next/parse/index.js ADDED Viewed

@@ -0,0 +1,14 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createInlineUpdates = exports.createDictionaryUpdates = exports.handleInitGT = exports.scanForContent = void 0;
+var scanForContent_1 = require("./scanForContent");
+Object.defineProperty(exports, "scanForContent", { enumerable: true, get: function () { return __importDefault(scanForContent_1).default; } });
+var handleInitGT_1 = require("./handleInitGT");
+Object.defineProperty(exports, "handleInitGT", { enumerable: true, get: function () { return __importDefault(handleInitGT_1).default; } });
+var createDictionaryUpdates_1 = require("../../react/parse/createDictionaryUpdates");
+Object.defineProperty(exports, "createDictionaryUpdates", { enumerable: true, get: function () { return __importDefault(createDictionaryUpdates_1).default; } });
+var createInlineUpdates_1 = require("../../react/parse/createInlineUpdates");
+Object.defineProperty(exports, "createInlineUpdates", { enumerable: true, get: function () { return __importDefault(createInlineUpdates_1).default; } });

package/dist/next/parse/scanForContent.d.ts ADDED Viewed

@@ -0,0 +1,13 @@
+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/next/parse/scanForContent.js ADDED Viewed

@@ -0,0 +1,189 @@
+"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 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("../../react/jsx/evaluateJsx");
+const wrapJsx_1 = require("../../react/jsx/wrapJsx");
+const findFilepath_1 = require("../../fs/findFilepath");
+const utils_1 = require("../jsx/utils");
+const parseAst_1 = require("../../react/jsx/utils/parseAst");
+const IMPORT_MAP = {
+    T: { name: 'T', source: 'gt-next' },
+    Var: { name: 'Var', source: 'gt-next' },
+    GTT: { name: 'T', source: 'gt-next' },
+    GTVar: { name: 'Var', source: 'gt-next' },
+    GTProvider: { name: 'GTProvider', source: 'gt-next' },
+    getLocale: { name: 'getLocale', source: 'gt-next/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 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 (pkg === 'gt-next' &&
+                        options.addGTProvider &&
+                        (0, utils_1.isHtmlElement)(path.node.openingElement)) {
+                        // Find the body element in the HTML children
+                        const bodyElement = path.node.children.find((child) => t.isJSXElement(child) && (0, utils_1.isBodyElement)(child.openingElement));
+                        if (!bodyElement) {
+                            warnings.push(`File ${file} has a <html> tag without a <body> tag. Skipping GTProvider insertion.`);
+                            return;
+                        }
+                        // Skip if body already has GTProvider
+                        if ((0, utils_1.hasGTProviderChild)(bodyElement)) {
+                            return;
+                        }
+                        // Handle lang attribute for html tag
+                        const langAttr = path.node.openingElement.attributes.find((attr) => t.isJSXAttribute(attr) &&
+                            t.isJSXIdentifier(attr.name) &&
+                            t.isStringLiteral(attr.value) &&
+                            attr.name.name === 'lang');
+                        if (langAttr) {
+                            (0, utils_1.makeParentFunctionAsync)(path);
+                            (0, utils_1.addDynamicLangAttribute)(path.node.openingElement);
+                            usedImports.push('getLocale');
+                        }
+                        // Wrap body children with GTProvider
+                        const bodyChildren = bodyElement.children;
+                        const gtProviderElement = t.jsxElement(t.jsxOpeningElement(t.jsxIdentifier('GTProvider'), [], false), t.jsxClosingElement(t.jsxIdentifier('GTProvider')), bodyChildren, false);
+                        bodyElement.children = [gtProviderElement];
+                        usedImports.push('GTProvider');
+                        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) => !initialImports.includes(imp));
+            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 };
+    });
+}

package/dist/react/config/createESBuildConfig.d.ts ADDED Viewed

	@@ -0,0 +1,2 @@
1	+ import esbuild from 'esbuild';
2	+ export default function createESBuildConfig(config?: Record<string, any>): esbuild.BuildOptions;

package/dist/react/config/createESBuildConfig.js ADDED Viewed

@@ -0,0 +1,134 @@
+"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 = createESBuildConfig;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const console_1 = require("../../console/console");
+function createESBuildConfig(config = {}) {
+    const esbuildOptions = {
+        bundle: true,
+        format: 'cjs',
+        platform: 'node',
+        target: 'es2021',
+        loader: {
+            '.js': 'jsx',
+            '.ts': 'ts',
+            '.css': 'css', // Add CSS loader
+        },
+        sourcemap: 'inline',
+        external: ['server-only'],
+        define: {
+            React: 'global.React',
+        },
+        plugins: [],
+    };
+    // Add the custom plugin to handle 'server-only' imports
+    esbuildOptions.plugins.push({
+        name: 'ignore-server-only',
+        setup(build) {
+            build.onResolve({ filter: /^server-only$/ }, () => {
+                return {
+                    path: 'server-only',
+                    namespace: 'ignore-server-only',
+                };
+            });
+            build.onLoad({ filter: /^server-only$/, namespace: 'ignore-server-only' }, () => {
+                return {
+                    contents: 'module.exports = {};',
+                    loader: 'js',
+                };
+            });
+        },
+    });
+    // Add a plugin to handle CSS imports
+    esbuildOptions.plugins.push({
+        name: 'css-module',
+        setup(build) {
+            build.onResolve({ filter: /\.css$/ }, (args) => {
+                return {
+                    path: path_1.default.resolve(args.resolveDir, args.path),
+                    namespace: 'css-module',
+                };
+            });
+            build.onLoad({ filter: /\.css$/, namespace: 'css-module' }, (args) => __awaiter(this, void 0, void 0, function* () {
+                const css = yield fs_1.default.promises.readFile(args.path, 'utf8');
+                const contents = `
+                    const style = document.createElement('style');
+                    style.textContent = ${JSON.stringify(css)};
+                    document.head.appendChild(style);
+                `;
+                return { contents, loader: 'js' };
+            }));
+        },
+    });
+    if (config.compilerOptions) {
+        if (config.compilerOptions.paths) {
+            const aliases = {};
+            const resolvedPaths = [];
+            for (const [key, value] of Object.entries(config.compilerOptions.paths)) {
+                if (Array.isArray(value) && typeof value[0] === 'string') {
+                    const resolvedPath = path_1.default.resolve(process.cwd(), value[0].replace('/*', ''));
+                    aliases[key.replace('/*', '')] = resolvedPath;
+                    resolvedPaths.push([key, resolvedPath]);
+                }
+            }
+            if (resolvedPaths.length) {
+                (0, console_1.displayResolvedPaths)(resolvedPaths);
+            }
+            esbuildOptions.plugins = esbuildOptions.plugins || [];
+            esbuildOptions.plugins.push({
+                name: 'alias',
+                setup(build) {
+                    build.onResolve({ filter: /.*/ }, (args) => {
+                        for (const [aliasKey, aliasPath] of Object.entries(aliases)) {
+                            if (args.path.startsWith(`${aliasKey}/`)) {
+                                const resolvedPath = path_1.default.resolve(aliasPath, args.path.slice(aliasKey.length + 1));
+                                const extensions = ['.js', '.ts', '.css']; // Add .css to extensions
+                                function resolveWithExtensions(basePath) {
+                                    for (const ext of extensions) {
+                                        const fullPath = `${basePath}${ext}`;
+                                        try {
+                                            const realPath = fs_1.default.realpathSync(fullPath);
+                                            return realPath;
+                                        }
+                                        catch (_) {
+                                            continue;
+                                        }
+                                    }
+                                    return null;
+                                }
+                                try {
+                                    const realPath = fs_1.default.realpathSync(resolvedPath);
+                                    return { path: realPath };
+                                }
+                                catch (err) {
+                                    const hasExtension = extensions.some((ext) => resolvedPath.endsWith(ext));
+                                    if (!hasExtension) {
+                                        const resolvedWithExt = resolveWithExtensions(resolvedPath);
+                                        if (resolvedWithExt) {
+                                            return { path: resolvedWithExt };
+                                        }
+                                    }
+                                    throw new Error(`Unable to resolve path: ${resolvedPath}`);
+                                }
+                            }
+                        }
+                    });
+                },
+            });
+        }
+    }
+    return esbuildOptions;
+}

package/dist/react/data-_gt/addGTIdentifierToSyntaxTree.d.ts ADDED Viewed

	@@ -0,0 +1 @@
1	+ export default function addGTIdentifierToSyntaxTree(tree: any, startingIndex?: number): any;