gtx-cli 2.5.35 → 2.5.36

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, warnInvalidStaticChildSync, warnFunctionNotFoundSync, warnMissingReturnSync, warnDuplicateFunctionDefinitionSync, warnInvalidStaticInitSync, warnRecursiveFunctionCallSync, } from '../../../../console/index.js';
+import { warnHasUnwrappedExpressionSync, warnNestedTComponent, 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,14 +77,31 @@ 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, visited, callStack, updates, errors, warnings, file, insideT, parsingOptions, scopeNode, importedFunctionsMap, pkgs, }) {
+export function buildJSXTree({ importAliases, node, unwrappedExpressions, inStatic, visited, callStack, updates, errors, warnings, file, insideT, parsingOptions, scopeNode, importedFunctionsMap, pkgs, helperPath, }) {
     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)) {
+        if (t.isJSXElement(expr) || t.isJSXFragment(expr)) {
             return buildJSXTree({
                 importAliases,
                 node: expr,
@@ -92,14 +109,16 @@ export function buildJSXTree({ importAliases, node, unwrappedExpressions, visite
                 visited,
                 callStack,
                 updates,
-                errors: errors,
-                warnings: warnings,
+                errors,
+                warnings,
                 file,
                 insideT,
                 parsingOptions,
                 scopeNode,
                 importedFunctionsMap,
                 pkgs,
+                inStatic,
+                helperPath: helperPath.get('expression'),
             });
         }
         const staticAnalysis = isStaticExpression(expr, true);
@@ -145,7 +164,10 @@ export function buildJSXTree({ importAliases, node, unwrappedExpressions, visite
         const props = {};
         const elementIsPlural = componentType === 'Plural';
         const elementIsBranch = componentType === 'Branch';
-        element.openingElement.attributes.forEach((attr) => {
+        element.openingElement.attributes.forEach((attr, index) => {
+            const helperAttribute = helperPath
+                .get('openingElement')
+                .get('attributes')[index];
             if (t.isJSXAttribute(attr)) {
                 const attrName = attr.name.name;
                 let attrValue = null;
@@ -154,34 +176,24 @@ export function buildJSXTree({ importAliases, node, unwrappedExpressions, visite
                         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 (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 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);
                             }
-                            // 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);
-                                }
+                            // 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.expression,
+                                node: attr.value,
                                 unwrappedExpressions,
                                 visited,
                                 callStack,
@@ -194,8 +206,19 @@ export function buildJSXTree({ importAliases, node, unwrappedExpressions, visite
                                 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;
@@ -203,36 +226,43 @@ export function buildJSXTree({ importAliases, node, unwrappedExpressions, visite
         });
         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();
                 }
-                return resolveStaticComponentChildren({
-                    importAliases,
-                    scopeNode,
-                    children: element.children,
-                    unwrappedExpressions,
-                    visited,
-                    updates,
-                    errors,
-                    warnings,
-                    file,
-                    callStack,
-                    parsingOptions,
-                    importedFunctionsMap,
-                    pkgs,
-                    props,
-                });
+                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;
             }
-            // 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
@@ -242,7 +272,7 @@ export function buildJSXTree({ importAliases, node, unwrappedExpressions, visite
             };
         }
         const children = element.children
-            .map((child) => buildJSXTree({
+            .map((child, index) => buildJSXTree({
             importAliases,
             node: child,
             unwrappedExpressions,
@@ -257,6 +287,8 @@ export function buildJSXTree({ importAliases, node, unwrappedExpressions, visite
             scopeNode,
             importedFunctionsMap,
             pkgs,
+            inStatic,
+            helperPath: helperPath.get('children')[index],
         }))
             .filter((child) => child !== null && child !== '');
         if (children.length === 1) {
@@ -276,7 +308,7 @@ export function buildJSXTree({ importAliases, node, unwrappedExpressions, visite
     // If it's a JSX fragment
     else if (t.isJSXFragment(node)) {
         const children = node.children
-            .map((child) => buildJSXTree({
+            .map((child, index) => buildJSXTree({
             importAliases,
             node: child,
             unwrappedExpressions,
@@ -291,6 +323,8 @@ export function buildJSXTree({ importAliases, node, unwrappedExpressions, visite
             scopeNode,
             importedFunctionsMap,
             pkgs,
+            inStatic,
+            helperPath: helperPath.get('children')[index],
         }))
             .filter((child) => child !== null && child !== '');
         const props = {};
@@ -340,6 +374,59 @@ export function buildJSXTree({ importAliases, node, unwrappedExpressions, visite
         }
         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) ||
@@ -347,11 +434,17 @@ export function buildJSXTree({ importAliases, node, unwrappedExpressions, visite
         t.isBinaryExpression(node) ||
         t.isLogicalExpression(node) ||
         t.isConditionalExpression(node)) {
-        return generate(node).code;
+        unwrappedExpressions.push(generate(node).code);
     }
     else {
-        return generate(node).code;
+        if (node === undefined) {
+            unwrappedExpressions.push(node);
+        }
+        else {
+            unwrappedExpressions.push(generate(node).code);
+        }
     }
+    return null;
 }
 // end buildJSXTree
 // Parses a JSX element and adds it to the updates array
@@ -393,6 +486,8 @@ 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
@@ -438,86 +533,6 @@ 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}`;
@@ -657,7 +672,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;
+        let importedFunctionsMap = new Map();
         traverse(ast, {
             Program(path) {
                 importedFunctionsMap = buildImportMap(path);
@@ -794,9 +809,8 @@ function processFunctionDeclarationNodePath({ functionName, path, importAliases,
             if (!returnNodePath.isExpression()) {
                 return;
             }
-            result.branches.push(processReturnExpression({
+            result.branches.push(processStaticExpression({
                 unwrappedExpressions,
-                functionName,
                 pkgs,
                 callStack,
                 scopeNode: returnNodePath,
@@ -837,9 +851,8 @@ function processVariableDeclarationNodePath({ functionName, path, importAliases,
     const bodyNodePath = arrowFunctionPath.get('body');
     if (bodyNodePath.isExpression()) {
         // process expression return
-        result.branches.push(processReturnExpression({
+        result.branches.push(processStaticExpression({
             unwrappedExpressions,
-            functionName,
             pkgs,
             scopeNode: arrowFunctionPath,
             expressionNodePath: bodyNodePath,
@@ -865,9 +878,8 @@ function processVariableDeclarationNodePath({ functionName, path, importAliases,
                 if (!returnNodePath.isExpression()) {
                     return;
                 }
-                result.branches.push(processReturnExpression({
+                result.branches.push(processStaticExpression({
                     unwrappedExpressions,
-                    functionName,
                     pkgs,
                     scopeNode: returnPath,
                     expressionNodePath: returnNodePath,
@@ -891,15 +903,15 @@ function processVariableDeclarationNodePath({ functionName, path, importAliases,
     return result;
 }
 /**
- * Process a expression being returned from a function
+ * Process a <Static> expression
  */
-function processReturnExpression({ unwrappedExpressions, scopeNode, expressionNodePath, importAliases, visited, callStack, updates, errors, warnings, file, parsingOptions, importedFunctionsMap, functionName, pkgs, }) {
+function processStaticExpression({ unwrappedExpressions, scopeNode, expressionNodePath, importAliases, visited, callStack, updates, errors, warnings, file, parsingOptions, importedFunctionsMap, 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 processReturnExpression({
+        return processStaticExpression({
             unwrappedExpressions,
             importAliases,
             scopeNode,
@@ -911,7 +923,6 @@ function processReturnExpression({ unwrappedExpressions, scopeNode, expressionNo
             warnings,
             file,
             parsingOptions,
-            functionName,
             importedFunctionsMap,
             pkgs,
         });
@@ -925,7 +936,7 @@ function processReturnExpression({ unwrappedExpressions, scopeNode, expressionNo
             warnings.add(warnFunctionNotFoundSync(file, callee.name, `${callee.loc?.start?.line}:${callee.loc?.start?.column}`));
             return null;
         }
-        // Function is found locally
+        // Function is found
         return resolveStaticFunctionInvocationFromBinding({
             importAliases,
             calleeBinding,
@@ -952,7 +963,7 @@ function processReturnExpression({ unwrappedExpressions, scopeNode, expressionNo
             warnings.add(warnFunctionNotFoundSync(file, callee.name, `${callee.loc?.start?.line}:${callee.loc?.start?.column}`));
             return null;
         }
-        // Function is found locally
+        // Function is found
         return resolveStaticFunctionInvocationFromBinding({
             importAliases,
             calleeBinding,
@@ -987,6 +998,8 @@ function processReturnExpression({ unwrappedExpressions, scopeNode, expressionNo
             scopeNode,
             importedFunctionsMap,
             pkgs,
+            inStatic: true,
+            helperPath: expressionNodePath,
         });
     }
     else if (t.isConditionalExpression(expressionNodePath.node)) {
@@ -996,7 +1009,7 @@ function processReturnExpression({ unwrappedExpressions, scopeNode, expressionNo
         const alternateNodePath = expressionNodePath.get('alternate');
         const result = {
             nodeType: 'multiplication',
-            branches: [consequentNodePath, alternateNodePath].map((expressionNodePath) => processReturnExpression({
+            branches: [consequentNodePath, alternateNodePath].map((expressionNodePath) => processStaticExpression({
                 unwrappedExpressions,
                 importAliases,
                 scopeNode,
@@ -1008,7 +1021,6 @@ function processReturnExpression({ unwrappedExpressions, scopeNode, expressionNo
                 warnings,
                 file,
                 parsingOptions,
-                functionName,
                 importedFunctionsMap,
                 pkgs,
             })),
@@ -1031,6 +1043,8 @@ function processReturnExpression({ unwrappedExpressions, scopeNode, expressionNo
             scopeNode,
             importedFunctionsMap,
             pkgs,
+            inStatic: true,
+            helperPath: expressionNodePath,
         });
     }
 }

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

@@ -0,0 +1,15 @@
+import * as t from '@babel/types';
+import { NodePath } from '@babel/traverse';
+import { ParsingConfigOptions } from '../../../types/parsing.js';
+import { StringNode } from './types.js';
+export type StringTree = (string | StringTree)[];
+/**
+ * Checks if an expression is static or uses declareStatic
+ * Returns a Node representing the parsed expression
+ * @param expr - The expression to check
+ * @param tPath - NodePath for scope resolution
+ * @param file - Current file path
+ * @param parsingOptions - Parsing configuration
+ * @returns Node | null - The parsed node, or null if invalid
+ */
+export declare function handleStaticExpression(expr: t.Expression, tPath: NodePath, file: string, parsingOptions: ParsingConfigOptions, errors: string[]): StringNode | null;