gtx-cli 1.2.19 → 1.2.20

package/CHANGELOG.md

@@ -1,5 +1,11 @@
 # gtx-cli
 
+## 1.2.20
+
+### Patch Changes
+
+- [#318](https://github.com/generaltranslation/gt/pull/318) [`5e6fabd`](https://github.com/generaltranslation/gt/commit/5e6fabdecd692ea26b1e709cc9a3dc5d22387410) Thanks [@brian-lou](https://github.com/brian-lou)! - Fix wrapping behavior for JSX fragments
+
 ## 1.2.19
 
 ### Patch Changes

package/dist/cli/react.js

@@ -236,8 +236,8 @@ class ReactCLI extends base_1.BaseCLI {
             defaultValue: true,
         });
         options.disableIds = !includeTId;
-        let errors = [];
-        let warnings = [];
+        const errors = [];
+        const warnings = [];
         // Wrap all JSX elements in the src directory with a <T> tag, with unique ids
         const { filesUpdated } = await this.wrapContent(options, 'react', errors, warnings);
         if (errors.length > 0) {

package/dist/fs/determineFramework.js

@@ -10,7 +10,7 @@ const node_fs_1 = __importDefault(require("node:fs"));
 const console_1 = require("../console");
 function determineLibrary() {
     let library = 'base';
-    let additionalModules = [];
+    const additionalModules = [];
     try {
         // Get the current working directory (where the CLI is being run)
         const cwd = process.cwd();

package/dist/next/parse/wrapContent.js

@@ -85,8 +85,8 @@ async function wrapContentNext(options, pkg, errors, warnings) {
             continue;
         }
         let modified = false;
-        let usedImports = [];
-        let { importAlias, initialImports } = (0, parseAst_1.generateImportMap)(ast, pkg);
+        const usedImports = [];
+        const { 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;
@@ -127,8 +127,8 @@ async function wrapContentNext(options, pkg, errors, warnings) {
                     return;
                 }
                 // Check if this JSX element has any JSX element ancestors
-                let currentPath = path;
-                if (t.isJSXElement(currentPath.parentPath?.node)) {
+                if (t.isJSXElement(path.parentPath?.node) ||
+                    t.isJSXExpressionContainer(path.parentPath?.node)) {
                     // If we found a JSX parent, skip processing this node
                     return;
                 }
@@ -152,7 +152,7 @@ async function wrapContentNext(options, pkg, errors, warnings) {
         });
         if (!modified)
             continue;
-        let needsImport = usedImports.filter((imp) => !initialImports.includes(imp));
+        const needsImport = usedImports.filter((imp) => !initialImports.includes(imp));
         if (needsImport.length > 0) {
             (0, parseAst_1.createImports)(ast, needsImport, IMPORT_MAP);
         }

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

@@ -81,7 +81,7 @@ function parseStrings(importName, path, updates, errors, file) {
                             const content = (0, generaltranslation_1.splitStringToContent)(source);
                             // get metadata and id from options
                             const options = tPath.parent.arguments[1];
-                            let metadata = {};
+                            const metadata = {};
                             if (options && options.type === 'ObjectExpression') {
                                 options.properties.forEach((prop) => {
                                     if (prop.type === 'ObjectProperty' &&

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

@@ -104,7 +104,7 @@ function generateImports(needsImport, isESM, importMap) {
  * It also records the import aliases for the T and Var components. (in case of conflicts)
  */
 function generateImportMap(ast, pkg) {
-    let importAlias = { TComponent: 'T', VarComponent: 'Var' };
+    const importAlias = { TComponent: 'T', VarComponent: 'Var' };
     // Check existing imports
     let initialImports = [];
     (0, traverse_1.default)(ast, {

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

@@ -79,7 +79,7 @@ function buildJSXTree(importAliases, node, unwrappedExpressions, updates, errors
     else if (t.isJSXText(node)) {
         // Updated JSX Text handling
         // JSX Text handling following React's rules
-        let text = node.value;
+        const text = node.value;
         return text;
     }
     else if (t.isJSXElement(node)) {

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

@@ -81,7 +81,7 @@ function parseStrings(importName, path, updates, errors, file) {
                             const content = (0, generaltranslation_1.splitStringToContent)(source);
                             // get metadata and id from options
                             const options = tPath.parent.arguments[1];
-                            let metadata = {};
+                            const metadata = {};
                             if (options && options.type === 'ObjectExpression') {
                                 options.properties.forEach((prop) => {
                                     if (prop.type === 'ObjectProperty' &&

package/dist/react/jsx/wrapJsx.js

@@ -42,7 +42,7 @@ function wrapJsxExpression(node, options, isMeaningful, mark) {
     const expression = t.isParenthesizedExpression(node.expression)
         ? node.expression.expression
         : node.expression;
-    // Ignore all template literals - they should not be counted as meaningful
+    // Ignore template literals containing quasis - they should not be counted as meaningful
     if (t.isTemplateLiteral(expression) && expression.expressions.length > 0) {
         return {
             node,
@@ -51,19 +51,30 @@ function wrapJsxExpression(node, options, isMeaningful, mark) {
         };
     }
     // Handle both JSX Elements and Fragments
-    if (t.isJSXElement(expression) || t.isJSXFragment(expression)) {
-        const result = wrapJsxElement(expression, options, isMeaningful, mark);
-        // re-wrap the result in a JSXExpressionContainer
-        if (t.isParenthesizedExpression(node.expression)) {
-            node.expression.expression = result.node;
-        }
-        else {
-            node.expression = result.node;
+    if (t.isJSXElement(expression) ||
+        t.isJSXFragment(expression) ||
+        t.isStringLiteral(expression) ||
+        t.isJSXText(expression) ||
+        t.isTemplateLiteral(expression)) {
+        if (t.isJSXElement(expression) || t.isJSXFragment(expression)) {
+            const result = wrapJsxElement(expression, options, isMeaningful, mark);
+            // re-wrap the result in a JSXExpressionContainer
+            if (t.isParenthesizedExpression(node.expression)) {
+                node.expression.expression = result.node;
+            }
+            else {
+                node.expression = result.node;
+            }
+            return {
+                node,
+                hasMeaningfulContent: result.hasMeaningfulContent,
+                wrappedInT: result.wrappedInT,
+            };
         }
         return {
             node,
-            hasMeaningfulContent: result.hasMeaningfulContent,
-            wrappedInT: result.wrappedInT,
+            hasMeaningfulContent: isMeaningful(expression),
+            wrappedInT: false,
         };
     }
     // Handle conditional expressions (ternary)
@@ -316,6 +327,8 @@ function wrapJsxElement(node, options, isMeaningful, mark) {
             if (t.isJSXExpressionContainer(child)) {
                 const result = wrapJsxExpression(child, options, isMeaningful, mark);
                 wrappedInT = wrappedInT || result.wrappedInT;
+                hasMeaningfulContent =
+                    hasMeaningfulContent || result.hasMeaningfulContent;
                 // Expressions are never meaningful because they will either:
                 // 1. be sub-wrapped in a T (if they contain meaningful content)
                 // 2. be wrapped in a Var (if they are not static)

package/dist/react/parse/createDictionaryUpdates.js

@@ -51,9 +51,9 @@ async function createDictionaryUpdates(options, dictionaryPath, esbuildConfig) {
         (0, console_1.logErrorAndExit)(`Dictionary filepath provided: "${options.dictionary}", but no entries found.`);
     }
     // ----- CREATE PARTIAL UPDATES ----- //
-    let updates = [];
+    const updates = [];
     for (const id of Object.keys(dictionary)) {
-        let { entry, metadata: props, // context, etc.
+        const { entry, metadata: props, // context, etc.
          } = (0, getEntryAndMetadata_1.default)(dictionary[id]);
         const source = (0, generaltranslation_1.splitStringToContent)(entry);
         const context = props?.context;

package/dist/react/parse/wrapContent.js

@@ -91,8 +91,8 @@ async function wrapContentReact(options, pkg, framework, errors, warnings) {
             continue;
         }
         let modified = false;
-        let usedImports = [];
-        let { importAlias, initialImports } = (0, parseAst_1.generateImportMap)(ast, pkg);
+        const usedImports = [];
+        const { 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;
@@ -141,9 +141,9 @@ async function wrapContentReact(options, pkg, framework, errors, warnings) {
                     }
                 }
                 // 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
+                if (t.isJSXElement(path.parentPath?.node) ||
+                    t.isJSXExpressionContainer(path.parentPath?.node)) {
+                    // If we're nested inside JSX, skip processing this node
                     return;
                 }
                 // At this point, we're only processing top-level JSX elements
@@ -166,7 +166,7 @@ async function wrapContentReact(options, pkg, framework, errors, warnings) {
         });
         if (!modified)
             continue;
-        let needsImport = usedImports.filter((imp) => typeof imp === 'string'
+        const needsImport = usedImports.filter((imp) => typeof imp === 'string'
             ? !initialImports.includes(imp)
             : !initialImports.includes(imp.local));
         if (needsImport.length > 0) {

package/dist/setup/wizard.js

@@ -72,8 +72,8 @@ Please let us know what you would like to see supported at https://github.com/ge
         await (0, installPackage_1.installPackage)('gt-react', packageManager);
         spinner.stop(chalk_1.default.green('Automatically installed gt-react.'));
     }
-    let errors = [];
-    let warnings = [];
+    const errors = [];
+    const warnings = [];
     let filesUpdated = [];
     if (frameworkType === 'next-app') {
         // Check if they have a next.config.js file

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gtx-cli",
-  "version": "1.2.19",
+  "version": "1.2.20",
   "main": "dist/index.js",
   "bin": "dist/main.js",
   "files": [
@@ -10,6 +10,10 @@
   "scripts": {
     "build": "tsc",
     "build:clean": "rm -rf dist; npm run build",
+    "lint": "eslint \"src/**/*.{js,ts}\" \"__tests__/**/*.{js,ts}\"",
+    "lint:fix": "eslint \"src/**/*.{js,ts}\" \"__tests__/**/*.{js,ts}\" --fix",
+    "test": "vitest run",
+    "test:watch": "vitest",
     "release": "npm run build:clean && npm publish",
     "release:alpha": "npm run build:clean && npm publish --tag alpha",
     "release:beta": "npm run build:clean && npm publish --tag beta",