gtx-cli 2.5.34-alpha.0 → 2.5.35

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

@@ -5,7 +5,7 @@ import * as t from '@babel/types';
 import fs from 'node:fs';
 import { parse } from '@babel/parser';
 import addGTIdentifierToSyntaxTree from './addGTIdentifierToSyntaxTree.js';
-import { warnHasUnwrappedExpressionSync, warnNestedTComponent, warnFunctionNotFoundSync, warnMissingReturnSync, warnDuplicateFunctionDefinitionSync, warnInvalidStaticInitSync, warnRecursiveFunctionCallSync, } from '../../../../console/index.js';
+import { warnHasUnwrappedExpressionSync, warnNestedTComponent, warnInvalidStaticChildSync, warnFunctionNotFoundSync, warnMissingReturnSync, warnDuplicateFunctionDefinitionSync, warnInvalidStaticInitSync, warnRecursiveFunctionCallSync, } from '../../../../console/index.js';
 import { isAcceptedPluralForm } from 'generaltranslation/internal';
 import { isStaticExpression } from '../../evaluateJsx.js';
 import { STATIC_COMPONENT, TRANSLATION_COMPONENT, VARIABLE_COMPONENTS, } from '../constants.js';
@@ -16,7 +16,7 @@ import { buildImportMap } from '../buildImportMap.js';
 import { getPathsAndAliases } from '../getPathsAndAliases.js';
 import { parseTProps } from './parseTProps.js';
 import { handleChildrenWhitespace } from './handleChildrenWhitespace.js';
-import { isElementNode } from './types.js';
+import { isElementNode, } from './types.js';
 import { multiplyJsxTree } from './multiplication/multiplyJsxTree.js';
 import { removeNullChildrenFields } from './removeNullChildrenFields.js';
 import path from 'node:path';
@@ -77,31 +77,14 @@ export function parseTranslationComponent({ originalName, importAliases, localNa
  * @param insideT - Whether the current node is inside a <T> component
  * @returns The built JSX tree
  */
-export function buildJSXTree({ importAliases, node, unwrappedExpressions, inStatic, visited, callStack, updates, errors, warnings, file, insideT, parsingOptions, scopeNode, importedFunctionsMap, pkgs, helperPath, }) {
+export function buildJSXTree({ importAliases, node, unwrappedExpressions, visited, callStack, updates, errors, warnings, file, insideT, parsingOptions, scopeNode, importedFunctionsMap, pkgs, }) {
     if (t.isJSXExpressionContainer(node)) {
         // Skip JSX comments
         if (t.isJSXEmptyExpression(node.expression)) {
             return null;
         }
-        if (inStatic) {
-            return processStaticExpression({
-                unwrappedExpressions,
-                scopeNode,
-                expressionNodePath: helperPath.get('expression'),
-                importAliases,
-                visited: visited,
-                callStack,
-                updates,
-                errors,
-                warnings,
-                file,
-                parsingOptions,
-                importedFunctionsMap,
-                pkgs,
-            });
-        }
         const expr = node.expression;
-        if (t.isJSXElement(expr) || t.isJSXFragment(expr)) {
+        if (t.isJSXElement(expr)) {
             return buildJSXTree({
                 importAliases,
                 node: expr,
@@ -109,16 +92,14 @@ export function buildJSXTree({ importAliases, node, unwrappedExpressions, inStat
                 visited,
                 callStack,
                 updates,
-                errors,
-                warnings,
+                errors: errors,
+                warnings: warnings,
                 file,
                 insideT,
                 parsingOptions,
                 scopeNode,
                 importedFunctionsMap,
                 pkgs,
-                inStatic,
-                helperPath: helperPath.get('expression'),
             });
         }
         const staticAnalysis = isStaticExpression(expr, true);
@@ -164,10 +145,7 @@ export function buildJSXTree({ importAliases, node, unwrappedExpressions, inStat
         const props = {};
         const elementIsPlural = componentType === 'Plural';
         const elementIsBranch = componentType === 'Branch';
-        element.openingElement.attributes.forEach((attr, index) => {
-            const helperAttribute = helperPath
-                .get('openingElement')
-                .get('attributes')[index];
+        element.openingElement.attributes.forEach((attr) => {
             if (t.isJSXAttribute(attr)) {
                 const attrName = attr.name.name;
                 let attrValue = null;
@@ -176,24 +154,34 @@ export function buildJSXTree({ importAliases, node, unwrappedExpressions, inStat
                         attrValue = attr.value.value;
                     }
                     else if (t.isJSXExpressionContainer(attr.value)) {
-                        const helperValue = helperAttribute.get('value');
                         // Check if this is an HTML content prop (title, placeholder, alt, etc.)
                         const isHtmlContentProp = Object.values(HTML_CONTENT_PROPS).includes(attrName);
-                        // If its a plural or branch prop
-                        if ((elementIsPlural && isAcceptedPluralForm(attrName)) ||
-                            (elementIsBranch && attrName !== 'branch')) {
-                            // Make sure that variable strings like {`I have ${count} book`} are invalid!
-                            if (t.isTemplateLiteral(attr.value.expression) &&
-                                !isStaticExpression(attr.value.expression, true).isStatic) {
-                                unwrappedExpressions.push(generate(attr.value).code);
+                        if (isHtmlContentProp) {
+                            // For HTML content props, only accept static string expressions
+                            const staticAnalysis = isStaticExpression(attr.value.expression, true);
+                            if (staticAnalysis.isStatic &&
+                                staticAnalysis.value !== undefined) {
+                                attrValue = staticAnalysis.value;
                             }
-                            // If it's an array, flag as an unwrapped expression
-                            if (t.isArrayExpression(attr.value.expression)) {
-                                unwrappedExpressions.push(generate(attr.value.expression).code);
+                            // Otherwise attrValue stays null and won't be included
+                        }
+                        else {
+                            // For non-HTML-content props, validate plural/branch then build tree
+                            if ((elementIsPlural && isAcceptedPluralForm(attrName)) ||
+                                (elementIsBranch && attrName !== 'branch')) {
+                                // Make sure that variable strings like {`I have ${count} book`} are invalid!
+                                if (t.isTemplateLiteral(attr.value.expression) &&
+                                    !isStaticExpression(attr.value.expression, true).isStatic) {
+                                    unwrappedExpressions.push(generate(attr.value).code);
+                                }
+                                // If it's an array, flag as an unwrapped expression
+                                if (t.isArrayExpression(attr.value.expression)) {
+                                    unwrappedExpressions.push(generate(attr.value.expression).code);
+                                }
                             }
                             attrValue = buildJSXTree({
                                 importAliases,
-                                node: attr.value,
+                                node: attr.value.expression,
                                 unwrappedExpressions,
                                 visited,
                                 callStack,
@@ -206,19 +194,8 @@ export function buildJSXTree({ importAliases, node, unwrappedExpressions, inStat
                                 scopeNode,
                                 importedFunctionsMap,
                                 pkgs,
-                                inStatic,
-                                helperPath: helperValue,
                             });
                         }
-                        // For HTML content props, only accept static string expressions
-                        else if (isHtmlContentProp) {
-                            const staticAnalysis = isStaticExpression(attr.value.expression, true);
-                            if (staticAnalysis.isStatic &&
-                                staticAnalysis.value !== undefined) {
-                                attrValue = staticAnalysis.value;
-                            }
-                            // Otherwise attrValue stays null and won't be included
-                        }
                     }
                 }
                 props[attrName] = attrValue;
@@ -226,43 +203,36 @@ export function buildJSXTree({ importAliases, node, unwrappedExpressions, inStat
         });
         if (elementIsVariable) {
             if (componentType === STATIC_COMPONENT) {
-                const helperElement = helperPath.get('children');
-                const results = {
-                    nodeType: 'element',
-                    type: STATIC_COMPONENT,
-                    props,
-                };
-                // Create children array if necessary
-                if (element.children.length) {
-                    results.props.children = [];
-                }
                 if (visited === null) {
                     visited = new Set();
                 }
-                for (let index = 0; index < element.children.length; index++) {
-                    const helperChild = helperElement[index];
-                    const result = buildJSXTree({
-                        importAliases,
-                        node: helperChild.node,
-                        unwrappedExpressions,
-                        visited,
-                        callStack,
-                        updates,
-                        errors,
-                        warnings,
-                        file,
-                        insideT: true,
-                        parsingOptions,
-                        scopeNode,
-                        importedFunctionsMap,
-                        pkgs,
-                        inStatic: true,
-                        helperPath: helperChild,
-                    });
-                    results.props.children.push(result);
-                }
-                return results;
+                return resolveStaticComponentChildren({
+                    importAliases,
+                    scopeNode,
+                    children: element.children,
+                    unwrappedExpressions,
+                    visited,
+                    updates,
+                    errors,
+                    warnings,
+                    file,
+                    callStack,
+                    parsingOptions,
+                    importedFunctionsMap,
+                    pkgs,
+                    props,
+                });
             }
+            // I do not see why this is being called, i am disabling this for now:
+            // parseJSXElement({
+            //   importAliases,
+            //   node: element,
+            //   updates,
+            //   errors,
+            //   warnings,
+            //   file,
+            //   parsingOptions,
+            // });
             return {
                 nodeType: 'element',
                 // if componentType is undefined, use typeName
@@ -272,7 +242,7 @@ export function buildJSXTree({ importAliases, node, unwrappedExpressions, inStat
             };
         }
         const children = element.children
-            .map((child, index) => buildJSXTree({
+            .map((child) => buildJSXTree({
             importAliases,
             node: child,
             unwrappedExpressions,
@@ -287,8 +257,6 @@ export function buildJSXTree({ importAliases, node, unwrappedExpressions, inStat
             scopeNode,
             importedFunctionsMap,
             pkgs,
-            inStatic,
-            helperPath: helperPath.get('children')[index],
         }))
             .filter((child) => child !== null && child !== '');
         if (children.length === 1) {
@@ -308,7 +276,7 @@ export function buildJSXTree({ importAliases, node, unwrappedExpressions, inStat
     // If it's a JSX fragment
     else if (t.isJSXFragment(node)) {
         const children = node.children
-            .map((child, index) => buildJSXTree({
+            .map((child) => buildJSXTree({
             importAliases,
             node: child,
             unwrappedExpressions,
@@ -323,8 +291,6 @@ export function buildJSXTree({ importAliases, node, unwrappedExpressions, inStat
             scopeNode,
             importedFunctionsMap,
             pkgs,
-            inStatic,
-            helperPath: helperPath.get('children')[index],
         }))
             .filter((child) => child !== null && child !== '');
         const props = {};
@@ -374,59 +340,6 @@ export function buildJSXTree({ importAliases, node, unwrappedExpressions, inStat
         }
         return generate(node).code;
     }
-    else if ((t.isCallExpression(node) && t.isIdentifier(node.callee)) ||
-        (t.isAwaitExpression(node) &&
-            t.isCallExpression(node.argument) &&
-            t.isIdentifier(node.argument.callee))) {
-        if (inStatic) {
-            const callExpression = (node.type === 'AwaitExpression' ? node.argument : node);
-            const callee = callExpression.callee;
-            const calleeBinding = scopeNode.scope.getBinding(callee.name);
-            if (!calleeBinding) {
-                warnings.add(warnFunctionNotFoundSync(file, callee.name, `${callee.loc?.start?.line}:${callee.loc?.start?.column}`));
-                return null;
-            }
-            return resolveStaticFunctionInvocationFromBinding({
-                importAliases,
-                calleeBinding,
-                callee,
-                visited: visited, // we know this is true bc of inStatic
-                callStack,
-                file,
-                updates,
-                errors,
-                warnings,
-                unwrappedExpressions,
-                pkgs,
-                parsingOptions,
-                importedFunctionsMap,
-            });
-        }
-        else {
-            unwrappedExpressions.push(generate(node).code);
-        }
-    }
-    else if (t.isParenthesizedExpression(node)) {
-        const child = node.expression;
-        return buildJSXTree({
-            importAliases,
-            node: child,
-            unwrappedExpressions,
-            visited,
-            callStack,
-            updates,
-            errors,
-            warnings,
-            file,
-            insideT,
-            parsingOptions,
-            scopeNode,
-            importedFunctionsMap,
-            pkgs,
-            inStatic,
-            helperPath: helperPath.get('expression'),
-        });
-    }
     // If it's some other JS expression
     else if (t.isIdentifier(node) ||
         t.isMemberExpression(node) ||
@@ -434,17 +347,11 @@ export function buildJSXTree({ importAliases, node, unwrappedExpressions, inStat
         t.isBinaryExpression(node) ||
         t.isLogicalExpression(node) ||
         t.isConditionalExpression(node)) {
-        unwrappedExpressions.push(generate(node).code);
+        return generate(node).code;
     }
     else {
-        if (node === undefined) {
-            unwrappedExpressions.push(node);
-        }
-        else {
-            unwrappedExpressions.push(generate(node).code);
-        }
+        return generate(node).code;
     }
-    return null;
 }
 // end buildJSXTree
 // Parses a JSX element and adds it to the updates array
@@ -486,8 +393,6 @@ export function parseJSXElement({ importAliases, node, originalName, pkgs, updat
         insideT: false,
         parsingOptions,
         importedFunctionsMap,
-        inStatic: false,
-        helperPath: scopeNode,
     });
     // Strip the outer <T> component if necessary
     const jsxTree = isElementNode(treeResult) && treeResult.props?.children
@@ -533,6 +438,86 @@ export function parseJSXElement({ importAliases, node, originalName, pkgs, updat
         });
     }
 }
+/**
+ * Resolves an invocation inside of a <Static> component. It will resolve the function, and build
+ * a jsx tree for each return inside of the function definition.
+ *
+ * function getOtherSubject() {
+ *   return <div>Jane</div>;
+ * }
+ *
+ * function getSubject() {
+ *   if (condition) return getOtherSubject();
+ *   return <div>John</div>;
+ * }
+ * ...
+ * <Static>
+ *   {getSubject()}
+ * </Static>
+ */
+function resolveStaticComponentChildren({ importAliases, scopeNode, children, unwrappedExpressions, visited, updates, errors, warnings, file, callStack, parsingOptions, importedFunctionsMap, pkgs, props, }) {
+    const result = {
+        nodeType: 'element',
+        type: STATIC_COMPONENT,
+        props,
+    };
+    let found = false;
+    // Create children array if necessary
+    if (children.length) {
+        result.props.children = [];
+    }
+    for (const child of children) {
+        // Ignore whitespace outside of jsx container
+        if (t.isJSXText(child) && child.value.trim() === '') {
+            result.props.children.push(child.value);
+            continue;
+        }
+        // Must be an expression container with a function invocation
+        if (!t.isJSXExpressionContainer(child) ||
+            !((t.isCallExpression(child.expression) &&
+                t.isIdentifier(child.expression.callee)) ||
+                (t.isAwaitExpression(child.expression) &&
+                    t.isCallExpression(child.expression.argument) &&
+                    t.isIdentifier(child.expression.argument.callee))) ||
+            found // There can only be one invocation inside of a <Static> component
+        ) {
+            errors.push(warnInvalidStaticChildSync(file, `${child.loc?.start?.line}:${child.loc?.start?.column}`));
+            continue;
+        }
+        // Set found to true
+        found = true;
+        // Get callee and binding from scope
+        const callee = (t.isAwaitExpression(child.expression)
+            ? child.expression.argument.callee
+            : child.expression.callee);
+        const calleeBinding = scopeNode.scope.getBinding(callee.name);
+        if (!calleeBinding) {
+            warnings.add(warnFunctionNotFoundSync(file, callee.name, `${callee.loc?.start?.line}:${callee.loc?.start?.column}`));
+            continue;
+        }
+        // Function is found locally, return wrapped in an expression
+        const staticFunctionInvocation = resolveStaticFunctionInvocationFromBinding({
+            importAliases,
+            calleeBinding,
+            callee,
+            visited,
+            callStack,
+            file,
+            updates,
+            errors,
+            warnings,
+            unwrappedExpressions,
+            pkgs,
+            parsingOptions,
+            importedFunctionsMap,
+        });
+        result.props.children.push({
+            nodeType: 'expression',
+            result: staticFunctionInvocation,
+        });
+    }
+    return result;
+}
 function resolveStaticFunctionInvocationFromBinding({ importAliases, calleeBinding, callee, unwrappedExpressions, visited, callStack, file, updates, errors, warnings, parsingOptions, importedFunctionsMap, pkgs, }) {
     function withRecusionGuard({ cb, filename, functionName, }) {
         const cacheKey = `${filename}::${functionName}`;
@@ -672,7 +657,7 @@ function processFunctionInFile({ filePath, functionName, visited, callStack, par
         });
         const { importAliases } = getPathsAndAliases(ast, pkgs);
         // Collect all imports in this file to track cross-file function calls
-        let importedFunctionsMap = new Map();
+        let importedFunctionsMap;
         traverse(ast, {
             Program(path) {
                 importedFunctionsMap = buildImportMap(path);
@@ -809,8 +794,9 @@ function processFunctionDeclarationNodePath({ functionName, path, importAliases,
             if (!returnNodePath.isExpression()) {
                 return;
             }
-            result.branches.push(processStaticExpression({
+            result.branches.push(processReturnExpression({
                 unwrappedExpressions,
+                functionName,
                 pkgs,
                 callStack,
                 scopeNode: returnNodePath,
@@ -851,8 +837,9 @@ function processVariableDeclarationNodePath({ functionName, path, importAliases,
     const bodyNodePath = arrowFunctionPath.get('body');
     if (bodyNodePath.isExpression()) {
         // process expression return
-        result.branches.push(processStaticExpression({
+        result.branches.push(processReturnExpression({
             unwrappedExpressions,
+            functionName,
             pkgs,
             scopeNode: arrowFunctionPath,
             expressionNodePath: bodyNodePath,
@@ -878,8 +865,9 @@ function processVariableDeclarationNodePath({ functionName, path, importAliases,
                 if (!returnNodePath.isExpression()) {
                     return;
                 }
-                result.branches.push(processStaticExpression({
+                result.branches.push(processReturnExpression({
                     unwrappedExpressions,
+                    functionName,
                     pkgs,
                     scopeNode: returnPath,
                     expressionNodePath: returnNodePath,
@@ -903,15 +891,15 @@ function processVariableDeclarationNodePath({ functionName, path, importAliases,
     return result;
 }
 /**
- * Process a <Static> expression
+ * Process a expression being returned from a function
  */
-function processStaticExpression({ unwrappedExpressions, scopeNode, expressionNodePath, importAliases, visited, callStack, updates, errors, warnings, file, parsingOptions, importedFunctionsMap, pkgs, }) {
+function processReturnExpression({ unwrappedExpressions, scopeNode, expressionNodePath, importAliases, visited, callStack, updates, errors, warnings, file, parsingOptions, importedFunctionsMap, functionName, pkgs, }) {
     // // If the node is null, return
     // if (expressionNodePath == null) return null;
     // Remove parentheses if they exist
     if (t.isParenthesizedExpression(expressionNodePath.node)) {
         // ex: return (value)
-        return processStaticExpression({
+        return processReturnExpression({
             unwrappedExpressions,
             importAliases,
             scopeNode,
@@ -923,6 +911,7 @@ function processStaticExpression({ unwrappedExpressions, scopeNode, expressionNo
             warnings,
             file,
             parsingOptions,
+            functionName,
             importedFunctionsMap,
             pkgs,
         });
@@ -936,7 +925,7 @@ function processStaticExpression({ unwrappedExpressions, scopeNode, expressionNo
             warnings.add(warnFunctionNotFoundSync(file, callee.name, `${callee.loc?.start?.line}:${callee.loc?.start?.column}`));
             return null;
         }
-        // Function is found
+        // Function is found locally
         return resolveStaticFunctionInvocationFromBinding({
             importAliases,
             calleeBinding,
@@ -963,7 +952,7 @@ function processStaticExpression({ unwrappedExpressions, scopeNode, expressionNo
             warnings.add(warnFunctionNotFoundSync(file, callee.name, `${callee.loc?.start?.line}:${callee.loc?.start?.column}`));
             return null;
         }
-        // Function is found
+        // Function is found locally
         return resolveStaticFunctionInvocationFromBinding({
             importAliases,
             calleeBinding,
@@ -998,8 +987,6 @@ function processStaticExpression({ unwrappedExpressions, scopeNode, expressionNo
             scopeNode,
             importedFunctionsMap,
             pkgs,
-            inStatic: true,
-            helperPath: expressionNodePath,
         });
     }
     else if (t.isConditionalExpression(expressionNodePath.node)) {
@@ -1009,7 +996,7 @@ function processStaticExpression({ unwrappedExpressions, scopeNode, expressionNo
         const alternateNodePath = expressionNodePath.get('alternate');
         const result = {
             nodeType: 'multiplication',
-            branches: [consequentNodePath, alternateNodePath].map((expressionNodePath) => processStaticExpression({
+            branches: [consequentNodePath, alternateNodePath].map((expressionNodePath) => processReturnExpression({
                 unwrappedExpressions,
                 importAliases,
                 scopeNode,
@@ -1021,6 +1008,7 @@ function processStaticExpression({ unwrappedExpressions, scopeNode, expressionNo
                 warnings,
                 file,
                 parsingOptions,
+                functionName,
                 importedFunctionsMap,
                 pkgs,
             })),
@@ -1043,8 +1031,6 @@ function processStaticExpression({ unwrappedExpressions, scopeNode, expressionNo
             scopeNode,
             importedFunctionsMap,
             pkgs,
-            inStatic: true,
-            helperPath: expressionNodePath,
         });
     }
 }

package/dist/react/jsx/utils/parseStringFunction.d.ts

@@ -5,16 +5,6 @@ import type { ParsingConfigOptions } from '../../../types/parsing.js';
  * Clears all caches. Useful for testing or when file system changes.
  */
 export declare function clearParsingCaches(): void;
-/**
- * Recursively resolves variable assignments to find all aliases of a translation callback parameter.
- * Handles cases like: const t = translate; const a = translate; const b = a; const c = b;
- *
- * @param scope The scope to search within
- * @param variableName The variable name to resolve
- * @param visited Set to track already visited variables to prevent infinite loops
- * @returns Array of all variable names that reference the original translation callback
- */
-export declare function resolveVariableAliases(scope: any, variableName: string, visited?: Set<string>): string[];
 /**
  * Main entry point for parsing translation strings from useGT() and getGT() calls.
  *