gtx-cli 1.2.4 → 1.2.5-alpha.2

package/dist/next/parse/handleInitGT.js

@@ -32,15 +32,6 @@ var __importStar = (this && this.__importStar) || (function () {
         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 };
 };
@@ -52,113 +43,111 @@ const generator_1 = __importDefault(require("@babel/generator"));
 const traverse_1 = __importDefault(require("@babel/traverse"));
 const t = __importStar(require("@babel/types"));
 const console_1 = require("../../console");
-function handleInitGT(filepath, errors, warnings, filesUpdated) {
-    return __awaiter(this, void 0, void 0, function* () {
-        const code = yield node_fs_1.default.promises.readFile(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' }))
+async function handleInitGT(filepath, errors, warnings, filesUpdated) {
+    const code = await node_fs_1.default.promises.readFile(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 (t.isIdentifier(dec.id, { name: 'initGT' }))
+                            if (spec.local.name === 'initGT')
                                 hasInitGT = true;
                         }
                     });
-                },
-            });
-            // Return early if either withGTConfig or initGT is already present
-            if (hasGTConfig || hasInitGT) {
-                return;
-            }
-            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;
+                }
+            },
+            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;
                     }
-                    // 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
-            yield node_fs_1.default.promises.writeFile(filepath, processedCode);
-            filesUpdated.push(filepath);
-        }
-        catch (error) {
-            (0, console_1.logError)(`Error parsing file ${filepath}: ${error}`);
-            errors.push(`Failed to parse ${filepath}: ${error}`);
+                });
+            },
+        });
+        // Return early if either withGTConfig or initGT is already present
+        if (hasGTConfig || hasInitGT) {
+            return;
         }
-    });
+        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
+        await node_fs_1.default.promises.writeFile(filepath, processedCode);
+        filesUpdated.push(filepath);
+    }
+    catch (error) {
+        (0, console_1.logError)(`Error parsing file ${filepath}: ${error}`);
+        errors.push(`Failed to parse ${filepath}: ${error}`);
+    }
 }

package/dist/next/parse/wrapContent.js

@@ -32,15 +32,6 @@ var __importStar = (this && this.__importStar) || (function () {
         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 };
 };
@@ -72,114 +63,119 @@ const IMPORT_MAP = {
  * @param options - The options object
  * @returns An object containing the updates and errors
  */
-function wrapContentNext(options, pkg, errors, warnings) {
-    return __awaiter(this, void 0, void 0, function* () {
-        const srcDirectory = options.src || ['./'];
-        const files = srcDirectory.flatMap((dir) => (0, findJsxFilepath_1.getFiles)(dir));
-        const filesUpdated = [];
-        for (const file of files) {
-            const code = yield node_fs_1.default.promises.readFile(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) {
-                errors.push(`Error: 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();
+async function wrapContentNext(options, pkg, errors, warnings) {
+    const srcDirectory = options.src || ['./'];
+    const files = srcDirectory.flatMap((dir) => (0, findJsxFilepath_1.getFiles)(dir));
+    const filesUpdated = [];
+    for (const file of files) {
+        const code = await node_fs_1.default.promises.readFile(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) {
+            errors.push(`Error: 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) {
+                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;
                     }
-                    // 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
+                    // Skip if body already has GTProvider
+                    if ((0, utils_1.hasGTProviderChild)(bodyElement)) {
                         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');
+                    // 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;
                 }
-                // Write the modified code back to the file
-                yield node_fs_1.default.promises.writeFile(file, processedCode);
-                filesUpdated.push(file);
-            }
-            catch (error) {
-                errors.push(`Error: Failed to write ${file}: ${error}`);
+                // Check if this JSX element has any JSX element ancestors
+                let currentPath = path;
+                if (t.isJSXElement(currentPath.parentPath?.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 = {
+                    ...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
+            await node_fs_1.default.promises.writeFile(file, processedCode);
+            filesUpdated.push(file);
         }
-        return { filesUpdated };
-    });
+        catch (error) {
+            errors.push(`Error: Failed to write ${file}: ${error}`);
+        }
+    }
+    return { filesUpdated };
 }

package/dist/react/config/createESBuildConfig.js

@@ -1,13 +1,4 @@
 "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 };
 };
@@ -62,15 +53,15 @@ function createESBuildConfig(config = {}) {
                     namespace: 'css-module',
                 };
             });
-            build.onLoad({ filter: /\.css$/, namespace: 'css-module' }, (args) => __awaiter(this, void 0, void 0, function* () {
-                const css = yield node_fs_1.default.promises.readFile(args.path, 'utf8');
+            build.onLoad({ filter: /\.css$/, namespace: 'css-module' }, async (args) => {
+                const css = await node_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) {

package/dist/react/data-_gt/addGTIdentifierToSyntaxTree.js

@@ -1,15 +1,4 @@
 "use strict";
-var __rest = (this && this.__rest) || function (s, e) {
-    var t = {};
-    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
-        t[p] = s[p];
-    if (s != null && typeof Object.getOwnPropertySymbols === "function")
-        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
-            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
-                t[p[i]] = s[p[i]];
-        }
-    return t;
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.default = addGTIdentifierToSyntaxTree;
 const getVariableName_1 = require("../utils/getVariableName");
@@ -27,28 +16,28 @@ function addGTIdentifierToSyntaxTree(tree, startingIndex = 0) {
                 return {
                     variable: 'variable',
                     id: indexObject.index,
-                    key: (0, getVariableName_1.getVariableName)(Object.assign(Object.assign({}, props), { 'data-_gt': generaltranslation }), 'variable'),
+                    key: (0, getVariableName_1.getVariableName)({ ...props, 'data-_gt': generaltranslation }, 'variable'),
                 };
             }
             else if (type === 'Num') {
                 return {
                     variable: 'number',
                     id: indexObject.index,
-                    key: (0, getVariableName_1.getVariableName)(Object.assign(Object.assign({}, props), { 'data-_gt': generaltranslation }), 'number'),
+                    key: (0, getVariableName_1.getVariableName)({ ...props, 'data-_gt': generaltranslation }, 'number'),
                 };
             }
             else if (type === 'Currency') {
                 return {
                     variable: 'currency',
                     id: indexObject.index,
-                    key: (0, getVariableName_1.getVariableName)(Object.assign(Object.assign({}, props), { 'data-_gt': generaltranslation }), 'currency'),
+                    key: (0, getVariableName_1.getVariableName)({ ...props, 'data-_gt': generaltranslation }, 'currency'),
                 };
             }
             else if (type === 'DateTime') {
                 return {
                     variable: 'datetime',
                     id: indexObject.index,
-                    key: (0, getVariableName_1.getVariableName)(Object.assign(Object.assign({}, props), { 'data-_gt': generaltranslation }), 'datetime'),
+                    key: (0, getVariableName_1.getVariableName)({ ...props, 'data-_gt': generaltranslation }, 'datetime'),
                 };
             }
             if (type === 'Plural') {
@@ -65,7 +54,7 @@ function addGTIdentifierToSyntaxTree(tree, startingIndex = 0) {
             }
             else if (type === 'Branch') {
                 generaltranslation.transformation = 'branch';
-                const { children, branch } = props, branches = __rest(props, ["children", "branch"]);
+                const { children, branch, ...branches } = props;
                 const resultBranches = Object.entries(branches).reduce((acc, [branchName, branch]) => {
                     acc[branchName] =
                         addGTIdentifierToSyntaxTree(branch, indexObject.index);
@@ -76,9 +65,12 @@ function addGTIdentifierToSyntaxTree(tree, startingIndex = 0) {
             }
             return {
                 type: type || `C${generaltranslation.id}`,
-                props: Object.assign({ 'data-_gt': generaltranslation }, (typeof props.children !== 'undefined' && {
-                    children: handleChildren(props.children),
-                })),
+                props: {
+                    'data-_gt': generaltranslation,
+                    ...(typeof props.children !== 'undefined' && {
+                        children: handleChildren(props.children),
+                    }),
+                },
             };
         }
         return child.toString();

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

@@ -53,15 +53,13 @@ exports.attributes = ['id', 'context'];
  * of the subsequent tx() calls, and append the content and metadata to the updates array.
  */
 function parseStrings(importName, path, updates, errors, file) {
-    var _a;
-    (_a = path.scope.bindings[importName]) === null || _a === void 0 ? void 0 : _a.referencePaths.forEach((refPath) => {
-        var _a;
+    path.scope.bindings[importName]?.referencePaths.forEach((refPath) => {
         // Find call expressions of useGT() / await getGT()
         const callExpr = refPath.findParent((p) => p.isCallExpression());
         if (callExpr) {
             // Get the parent, handling both await and non-await cases
             const parentPath = callExpr.parentPath;
-            const effectiveParent = (parentPath === null || parentPath === void 0 ? void 0 : parentPath.node.type) === 'AwaitExpression'
+            const effectiveParent = parentPath?.node.type === 'AwaitExpression'
                 ? parentPath.parentPath
                 : parentPath;
             if (effectiveParent &&
@@ -70,7 +68,7 @@ function parseStrings(importName, path, updates, errors, file) {
                 const tFuncName = effectiveParent.node.id.name;
                 // Get the scope from the variable declaration
                 const variableScope = effectiveParent.scope;
-                (_a = variableScope.bindings[tFuncName]) === null || _a === void 0 ? void 0 : _a.referencePaths.forEach((tPath) => {
+                variableScope.bindings[tFuncName]?.referencePaths.forEach((tPath) => {
                     if (tPath.parent.type === 'CallExpression' &&
                         tPath.parent.arguments.length > 0) {
                         const arg = tPath.parent.arguments[0];

package/dist/react/jsx/trimJsxStringChildren.js

@@ -65,7 +65,7 @@ const handleChildrenWhitespace = (currentTree) => {
         });
         return newChildren.length === 1 ? newChildren[0] : newChildren;
     }
-    else if (currentTree === null || currentTree === void 0 ? void 0 : currentTree.props) {
+    else if (currentTree?.props) {
         // Process all props recursively
         const elementIsPlural = currentTree.type === 'Plural';
         const elementIsBranch = currentTree.type === 'Branch';
@@ -83,7 +83,10 @@ const handleChildrenWhitespace = (currentTree) => {
             }
             return [key, value];
         }));
-        return Object.assign(Object.assign({}, currentTree), { props: processedProps });
+        return {
+            ...currentTree,
+            props: processedProps,
+        };
     }
     else if (typeof currentTree === 'object' &&
         'expression' in currentTree === true) {