gtx-cli 2.3.5 → 2.3.6-alpha.2

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

@@ -1,244 +0,0 @@
-import generateModule from '@babel/generator';
-// Handle CommonJS/ESM interop
-const generate = generateModule.default || generateModule;
-import * as t from '@babel/types';
-import addGTIdentifierToSyntaxTree from '../../data-_gt/addGTIdentifierToSyntaxTree.js';
-import { warnHasUnwrappedExpressionSync, warnVariablePropSync, warnNestedTComponent, } from '../../../console/index.js';
-import { isAcceptedPluralForm } from 'generaltranslation/internal';
-import { handleChildrenWhitespace } from '../trimJsxStringChildren.js';
-import { isStaticExpression } from '../evaluateJsx.js';
-import { GT_ATTRIBUTES, mapAttributeName, VARIABLE_COMPONENTS, } from './constants.js';
-/**
- * Builds a JSX tree from a given node, recursively handling children.
- * @param node - The node to build the tree from
- * @param unwrappedExpressions - An array to store unwrapped expressions
- * @param updates - The updates array
- * @param errors - The errors array
- * @param file - The file name
- * @param insideT - Whether the current node is inside a <T> component
- * @returns The built JSX tree
- */
-export function buildJSXTree(importAliases, node, unwrappedExpressions, updates, errors, warnings, file, insideT) {
-    if (t.isJSXExpressionContainer(node)) {
-        // Skip JSX comments
-        if (t.isJSXEmptyExpression(node.expression)) {
-            return null;
-        }
-        const expr = node.expression;
-        if (t.isJSXElement(expr)) {
-            return buildJSXTree(importAliases, expr, unwrappedExpressions, updates, errors, warnings, file, insideT);
-        }
-        const staticAnalysis = isStaticExpression(expr);
-        if (staticAnalysis.isStatic && staticAnalysis.value !== undefined) {
-            // Preserve the exact whitespace for static string expressions
-            return {
-                expression: true,
-                result: staticAnalysis.value,
-            };
-        }
-        // Keep existing behavior for non-static expressions
-        const code = generate(node).code;
-        unwrappedExpressions.push(code); // Keep track of unwrapped expressions for error reporting
-        return code;
-    }
-    else if (t.isJSXText(node)) {
-        // Updated JSX Text handling
-        // JSX Text handling following React's rules
-        const text = node.value;
-        return text;
-    }
-    else if (t.isJSXElement(node)) {
-        const element = node;
-        const elementName = element.openingElement.name;
-        let typeName;
-        if (t.isJSXIdentifier(elementName)) {
-            typeName = elementName.name;
-        }
-        else if (t.isJSXMemberExpression(elementName)) {
-            typeName = generate(elementName).code;
-        }
-        else {
-            typeName = null;
-        }
-        // Convert from alias to original name
-        const componentType = importAliases[typeName ?? ''];
-        if (componentType === 'T' && insideT) {
-            // Add warning: Nested <T> components are allowed, but they are advised against
-            warnings.add(warnNestedTComponent(file, `${element.loc?.start?.line}:${element.loc?.start?.column}`));
-        }
-        // If this JSXElement is one of the recognized variable components,
-        const elementIsVariable = VARIABLE_COMPONENTS.includes(componentType);
-        const props = {};
-        const elementIsPlural = componentType === 'Plural';
-        const elementIsBranch = componentType === 'Branch';
-        element.openingElement.attributes.forEach((attr) => {
-            if (t.isJSXAttribute(attr)) {
-                const attrName = attr.name.name;
-                let attrValue = null;
-                if (attr.value) {
-                    if (t.isStringLiteral(attr.value)) {
-                        attrValue = attr.value.value;
-                    }
-                    else if (t.isJSXExpressionContainer(attr.value)) {
-                        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).isStatic) {
-                                unwrappedExpressions.push(generate(attr.value).code);
-                            }
-                        }
-                        attrValue = buildJSXTree(importAliases, attr.value.expression, unwrappedExpressions, updates, errors, warnings, file, true);
-                    }
-                }
-                props[attrName] = attrValue;
-            }
-        });
-        if (elementIsVariable) {
-            parseJSXElement(importAliases, element, updates, errors, warnings, file);
-            return {
-                // if componentType is undefined, use typeName
-                // Basically, if componentType is not a GT component, use typeName such as <div>
-                type: componentType ?? typeName,
-                props,
-            };
-        }
-        const children = element.children
-            .map((child) => buildJSXTree(importAliases, child, unwrappedExpressions, updates, errors, warnings, file, true))
-            .filter((child) => child !== null && child !== '');
-        if (children.length === 1) {
-            props.children = children[0];
-        }
-        else if (children.length > 1) {
-            props.children = children;
-        }
-        return {
-            // if componentType is undefined, use typeName
-            // Basically, if componentType is not a GT component, use typeName such as <div>
-            type: componentType ?? typeName,
-            props,
-        };
-    }
-    // If it's a JSX fragment
-    else if (t.isJSXFragment(node)) {
-        const children = node.children
-            .map((child) => buildJSXTree(importAliases, child, unwrappedExpressions, updates, errors, warnings, file, true))
-            .filter((child) => child !== null && child !== '');
-        const props = {};
-        if (children.length === 1) {
-            props.children = children[0];
-        }
-        else if (children.length > 1) {
-            props.children = children;
-        }
-        return {
-            type: '',
-            props,
-        };
-    }
-    // If it's a string literal (standalone)
-    else if (t.isStringLiteral(node)) {
-        return node.value;
-    }
-    // If it's some other JS expression
-    else if (t.isIdentifier(node) ||
-        t.isMemberExpression(node) ||
-        t.isCallExpression(node) ||
-        t.isBinaryExpression(node) ||
-        t.isLogicalExpression(node) ||
-        t.isConditionalExpression(node)) {
-        return generate(node).code;
-    }
-    else {
-        return generate(node).code;
-    }
-}
-// end buildJSXTree
-// Parses a JSX element and adds it to the updates array
-export function parseJSXElement(importAliases, node, updates, errors, warnings, file) {
-    const openingElement = node.openingElement;
-    const name = openingElement.name;
-    // Only proceed if it's <T> ...
-    if (!(name.type === 'JSXIdentifier' && importAliases[name.name] === 'T')) {
-        return;
-    }
-    const componentErrors = [];
-    const componentWarnings = new Set();
-    const metadata = {};
-    // We'll track this flag to know if any unwrapped {variable} is found in children
-    const unwrappedExpressions = [];
-    // Gather <T>'s props
-    openingElement.attributes.forEach((attr) => {
-        if (!t.isJSXAttribute(attr))
-            return;
-        const attrName = attr.name.name;
-        if (typeof attrName !== 'string')
-            return;
-        if (attr.value) {
-            // If it's a plain string literal like id="hello"
-            if (t.isStringLiteral(attr.value)) {
-                metadata[attrName] = attr.value.value;
-            }
-            // If it's an expression container like id={"hello"}, id={someVar}, etc.
-            else if (t.isJSXExpressionContainer(attr.value)) {
-                const expr = attr.value.expression;
-                const code = generate(expr).code;
-                // Only check for static expressions on id and context props
-                if (GT_ATTRIBUTES.includes(attrName)) {
-                    const staticAnalysis = isStaticExpression(expr);
-                    if (!staticAnalysis.isStatic) {
-                        componentErrors.push(warnVariablePropSync(file, attrName, code, `${expr.loc?.start?.line}:${expr.loc?.start?.column}`));
-                    }
-                    // Use the static value if available
-                    if (staticAnalysis.isStatic && staticAnalysis.value !== undefined) {
-                        metadata[mapAttributeName(attrName)] = staticAnalysis.value;
-                    }
-                    else {
-                        // Only store the code if we couldn't extract a static value
-                        metadata[attrName] = code;
-                    }
-                }
-                else {
-                    // For other attributes that aren't id or context
-                    metadata[attrName] = code;
-                }
-            }
-        }
-    });
-    // Build the JSX tree for this component
-    const treeResult = buildJSXTree(importAliases, node, unwrappedExpressions, updates, componentErrors, componentWarnings, file, false);
-    let jsxTree = undefined;
-    if (treeResult && typeof treeResult === 'object') {
-        jsxTree = treeResult.props?.children;
-    }
-    else {
-        jsxTree = treeResult;
-    }
-    if (componentWarnings.size > 0) {
-        componentWarnings.forEach((warning) => warnings.add(warning));
-    }
-    if (componentErrors.length > 0) {
-        errors.push(...componentErrors);
-        return;
-    }
-    // Handle whitespace in children
-    const whitespaceHandledTree = handleChildrenWhitespace(jsxTree);
-    // Add GT identifiers to the tree
-    let minifiedTree = addGTIdentifierToSyntaxTree(whitespaceHandledTree);
-    minifiedTree =
-        Array.isArray(minifiedTree) && minifiedTree.length === 1
-            ? minifiedTree[0]
-            : minifiedTree;
-    const id = metadata.id;
-    // If we found an unwrapped expression, skip
-    if (unwrappedExpressions.length > 0) {
-        errors.push(warnHasUnwrappedExpressionSync(file, unwrappedExpressions, id, `${node.loc?.start?.line}:${node.loc?.start?.column}`));
-        return;
-    }
-    // <T> is valid here
-    updates.push({
-        dataFormat: 'JSX',
-        source: minifiedTree,
-        metadata,
-    });
-}

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

@@ -1,16 +0,0 @@
-import { NodePath } from '@babel/traverse';
-import { Updates } from '../../../types/index.js';
-/**
- * Main entry point for parsing translation strings from useGT() and getGT() calls.
- *
- * Supports complex patterns including:
- * 1. Direct calls: const t = useGT(); t('hello');
- * 2. Translation callback prop drilling: const t = useGT(); getInfo(t); where getInfo uses t() internally
- * 3. Cross-file function calls: imported functions that receive the translation callback as a parameter
- *
- * Example flow:
- * - const t = useGT();
- * - const { home } = getInfo(t); // getInfo is imported from './constants'
- * - This will parse constants.ts to find translation calls within getInfo function
- */
-export declare function parseStrings(importName: string, originalName: string, path: NodePath, updates: Updates, errors: string[], file: string): void;

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

@@ -1,411 +0,0 @@
-import * as t from '@babel/types';
-import { isStaticExpression } from '../evaluateJsx.js';
-import { GT_ATTRIBUTES_WITH_SUGAR, MSG_TRANSLATION_HOOK, INLINE_TRANSLATION_HOOK, INLINE_TRANSLATION_HOOK_ASYNC, mapAttributeName, INLINE_MESSAGE_HOOK, INLINE_MESSAGE_HOOK_ASYNC, } from './constants.js';
-import { warnNonStaticExpressionSync, warnNonStringSync, warnTemplateLiteralSync, warnAsyncUseGT, warnSyncGetGT, } from '../../../console/index.js';
-import generateModule from '@babel/generator';
-import traverseModule from '@babel/traverse';
-// Handle CommonJS/ESM interop
-const generate = generateModule.default || generateModule;
-const traverse = traverseModule.default || traverseModule;
-import fs from 'node:fs';
-import path from 'node:path';
-import { parse } from '@babel/parser';
-import { createMatchPath, loadConfig } from 'tsconfig-paths';
-import resolve from 'resolve';
-/**
- * Processes a single translation function call (e.g., t('hello world', { id: 'greeting' })).
- * Extracts the translatable string content and metadata, then adds it to the updates array.
- *
- * Handles:
- * - String literals: t('hello')
- * - Template literals without expressions: t(`hello`)
- * - Metadata extraction from options object
- * - Error reporting for non-static expressions and template literals with expressions
- */
-function processTranslationCall(tPath, updates, errors, file, ignoreAdditionalData, ignoreDynamicContent) {
-    if (tPath.parent.type === 'CallExpression' &&
-        tPath.parent.arguments.length > 0) {
-        const arg = tPath.parent.arguments[0];
-        if (arg.type === 'StringLiteral' ||
-            (t.isTemplateLiteral(arg) && arg.expressions.length === 0)) {
-            const source = arg.type === 'StringLiteral' ? arg.value : arg.quasis[0].value.raw;
-            // get metadata and id from options
-            const options = tPath.parent.arguments[1];
-            const metadata = {};
-            if (options && options.type === 'ObjectExpression') {
-                options.properties.forEach((prop) => {
-                    if (prop.type === 'ObjectProperty' &&
-                        prop.key.type === 'Identifier') {
-                        const attribute = prop.key.name;
-                        if (GT_ATTRIBUTES_WITH_SUGAR.includes(attribute) &&
-                            t.isExpression(prop.value)) {
-                            const result = isStaticExpression(prop.value);
-                            if (!result.isStatic) {
-                                errors.push(warnNonStaticExpressionSync(file, attribute, generate(prop.value).code, `${prop.loc?.start?.line}:${prop.loc?.start?.column}`));
-                            }
-                            if (result.isStatic && result.value && !ignoreAdditionalData) {
-                                // Map $id and $context to id and context
-                                metadata[mapAttributeName(attribute)] = result.value;
-                            }
-                        }
-                    }
-                });
-            }
-            updates.push({
-                dataFormat: 'ICU',
-                source,
-                metadata,
-            });
-        }
-        else if (t.isTemplateLiteral(arg)) {
-            // warn if template literal
-            if (!ignoreDynamicContent) {
-                errors.push(warnTemplateLiteralSync(file, generate(arg).code, `${arg.loc?.start?.line}:${arg.loc?.start?.column}`));
-            }
-        }
-        else {
-            if (!ignoreDynamicContent) {
-                errors.push(warnNonStringSync(file, generate(arg).code, `${arg.loc?.start?.line}:${arg.loc?.start?.column}`));
-            }
-        }
-    }
-}
-/**
- * Extracts the parameter name from a function parameter node, handling TypeScript annotations.
- */
-function extractParameterName(param) {
-    if (t.isIdentifier(param)) {
-        return param.name;
-    }
-    return null;
-}
-/**
- * Builds a map of imported function names to their import paths from a given program path.
- * Handles both named imports and default imports.
- *
- * Example: import { getInfo } from './constants' -> Map { 'getInfo' => './constants' }
- * Example: import utils from './utils' -> Map { 'utils' => './utils' }
- */
-function buildImportMap(programPath) {
-    const importMap = new Map();
-    programPath.traverse({
-        ImportDeclaration(importPath) {
-            if (t.isStringLiteral(importPath.node.source)) {
-                const importSource = importPath.node.source.value;
-                importPath.node.specifiers.forEach((spec) => {
-                    if (t.isImportSpecifier(spec) &&
-                        t.isIdentifier(spec.imported) &&
-                        t.isIdentifier(spec.local)) {
-                        importMap.set(spec.local.name, importSource);
-                    }
-                    else if (t.isImportDefaultSpecifier(spec) &&
-                        t.isIdentifier(spec.local)) {
-                        importMap.set(spec.local.name, importSource);
-                    }
-                });
-            }
-        },
-    });
-    return importMap;
-}
-/**
- * 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
- */
-function resolveVariableAliases(scope, variableName, visited = new Set()) {
-    if (visited.has(variableName)) {
-        return []; // Prevent infinite loops
-    }
-    visited.add(variableName);
-    const aliases = [variableName];
-    const binding = scope.bindings[variableName];
-    if (binding) {
-        // Look for variable declarations that assign this variable to another name
-        // Example: const t = translate; or const a = t;
-        for (const [otherVarName, otherBinding] of Object.entries(scope.bindings)) {
-            if (otherVarName === variableName || visited.has(otherVarName))
-                continue;
-            const otherBindingTyped = otherBinding;
-            if (otherBindingTyped.path &&
-                otherBindingTyped.path.isVariableDeclarator() &&
-                otherBindingTyped.path.node.init &&
-                t.isIdentifier(otherBindingTyped.path.node.init) &&
-                otherBindingTyped.path.node.init.name === variableName) {
-                // Found an alias: const otherVarName = variableName;
-                const nestedAliases = resolveVariableAliases(scope, otherVarName, visited);
-                aliases.push(...nestedAliases);
-            }
-        }
-    }
-    return aliases;
-}
-/**
- * Handles how translation callbacks are used within code.
- * This covers both direct translation calls (t('hello')) and prop drilling
- * where the translation callback is passed to other functions (getData(t)).
- */
-function handleFunctionCall(tPath, updates, errors, file, importMap, ignoreAdditionalData, ignoreDynamicContent) {
-    if (tPath.parent.type === 'CallExpression' &&
-        tPath.parent.callee === tPath.node) {
-        // Direct translation call: t('hello')
-        processTranslationCall(tPath, updates, errors, file, ignoreAdditionalData, ignoreDynamicContent);
-    }
-    else if (tPath.parent.type === 'CallExpression' &&
-        t.isExpression(tPath.node) &&
-        tPath.parent.arguments.includes(tPath.node)) {
-        // Parameter passed to another function: getData(t)
-        const argIndex = tPath.parent.arguments.indexOf(tPath.node);
-        const callee = tPath.parent.callee;
-        if (t.isIdentifier(callee)) {
-            const calleeBinding = tPath.scope.getBinding(callee.name);
-            if (calleeBinding && calleeBinding.path.isFunction()) {
-                const functionPath = calleeBinding.path;
-                processFunctionIfMatches(callee.name, argIndex, functionPath.node, functionPath, updates, errors, file, ignoreAdditionalData, ignoreDynamicContent);
-            }
-            // Handle arrow functions assigned to variables: const getData = (t) => {...}
-            else if (calleeBinding &&
-                calleeBinding.path.isVariableDeclarator() &&
-                calleeBinding.path.node.init &&
-                (t.isArrowFunctionExpression(calleeBinding.path.node.init) ||
-                    t.isFunctionExpression(calleeBinding.path.node.init))) {
-                const initPath = calleeBinding.path.get('init');
-                processFunctionIfMatches(callee.name, argIndex, calleeBinding.path.node.init, initPath, updates, errors, file, ignoreAdditionalData, ignoreDynamicContent);
-            }
-            // If not found locally, check if it's an imported function
-            else if (importMap.has(callee.name)) {
-                const importPath = importMap.get(callee.name);
-                const resolvedPath = resolveImportPath(file, importPath);
-                if (resolvedPath) {
-                    findFunctionInFile(resolvedPath, callee.name, argIndex, updates, errors, ignoreAdditionalData, ignoreDynamicContent);
-                }
-            }
-        }
-    }
-}
-/**
- * Processes a user-defined function that receives a translation callback as a parameter.
- * Validates the function has enough parameters and traces how the translation callback
- * is used within that function's body.
- */
-function processFunctionIfMatches(_functionName, argIndex, functionNode, functionPath, updates, errors, filePath, ignoreAdditionalData, ignoreDynamicContent) {
-    if (functionNode.params.length > argIndex) {
-        const param = functionNode.params[argIndex];
-        const paramName = extractParameterName(param);
-        if (paramName) {
-            findFunctionParameterUsage(functionPath, paramName, updates, errors, filePath, ignoreAdditionalData, ignoreDynamicContent);
-        }
-    }
-}
-/**
- * Finds all usages of a translation callback parameter within a user-defined function's scope.
- * Processes both direct translation calls and cases where the translation callback is passed
- * to other functions (prop drilling).
- *
- * Example: In function getInfo(t) { return t('hello'); }, this finds the t('hello') call.
- * Example: In function getData(t) { return getFooter(t); }, this finds and traces into getFooter.
- */
-function findFunctionParameterUsage(functionPath, parameterName, updates, errors, file, ignoreAdditionalData, ignoreDynamicContent) {
-    // Look for the function body and find all usages of the parameter
-    if (functionPath.isFunction()) {
-        const functionScope = functionPath.scope;
-        // Resolve all aliases of the translation callback parameter
-        // Example: translate -> [translate, t, a, b] for const t = translate; const a = t; const b = a;
-        const allParameterNames = resolveVariableAliases(functionScope, parameterName);
-        // Build import map for this function's scope to handle cross-file calls
-        const programPath = functionPath.scope.getProgramParent().path;
-        const importMap = buildImportMap(programPath);
-        // Process references for all parameter names and their aliases
-        allParameterNames.forEach((name) => {
-            const binding = functionScope.bindings[name];
-            if (binding) {
-                binding.referencePaths.forEach((refPath) => {
-                    handleFunctionCall(refPath, updates, errors, file, importMap, ignoreAdditionalData, ignoreDynamicContent);
-                });
-            }
-        });
-    }
-}
-/**
- * Resolves import paths to absolute file paths using battle-tested libraries.
- * Handles relative paths, TypeScript paths, and node module resolution.
- *
- * Examples:
- * - './constants' -> '/full/path/to/constants.ts'
- * - '@/components/ui/button' -> '/full/path/to/src/components/ui/button.tsx'
- * - '@shared/utils' -> '/full/path/to/packages/utils/index.ts'
- */
-function resolveImportPath(currentFile, importPath) {
-    const basedir = path.dirname(currentFile);
-    const extensions = ['.tsx', '.ts', '.jsx', '.js'];
-    // 1. Try tsconfig-paths resolution first (handles TypeScript path mapping)
-    const tsConfigResult = loadConfig(basedir);
-    if (tsConfigResult.resultType === 'success') {
-        const matchPath = createMatchPath(tsConfigResult.absoluteBaseUrl, tsConfigResult.paths, ['main', 'module', 'browser']);
-        // First try without any extension
-        let tsResolved = matchPath(importPath);
-        if (tsResolved && fs.existsSync(tsResolved)) {
-            return tsResolved;
-        }
-        // Then try with each extension
-        for (const ext of extensions) {
-            tsResolved = matchPath(importPath + ext);
-            if (tsResolved && fs.existsSync(tsResolved)) {
-                return tsResolved;
-            }
-            // Also try the resolved path with extension
-            tsResolved = matchPath(importPath);
-            if (tsResolved) {
-                const resolvedWithExt = tsResolved + ext;
-                if (fs.existsSync(resolvedWithExt)) {
-                    return resolvedWithExt;
-                }
-            }
-        }
-    }
-    // 2. Fallback to Node.js resolution (handles relative paths and node_modules)
-    try {
-        return resolve.sync(importPath, { basedir, extensions });
-    }
-    catch {
-        // If resolution fails, try to manually replace .js/.jsx with .ts/.tsx for source files
-        if (importPath.endsWith('.js')) {
-            const tsPath = importPath.replace(/\.js$/, '.ts');
-            try {
-                return resolve.sync(tsPath, { basedir, extensions });
-            }
-            catch {
-                // Continue to return null
-            }
-        }
-        else if (importPath.endsWith('.jsx')) {
-            const tsxPath = importPath.replace(/\.jsx$/, '.tsx');
-            try {
-                return resolve.sync(tsxPath, { basedir, extensions });
-            }
-            catch {
-                // Continue to return null
-            }
-        }
-        return null;
-    }
-}
-/**
- * Searches for a specific user-defined function in a file and analyzes how a translation callback
- * parameter (at argIndex position) is used within that function.
- *
- * Handles multiple function declaration patterns:
- * - function getInfo(t) { ... }
- * - export function getInfo(t) { ... }
- * - const getInfo = (t) => { ... }
- */
-function findFunctionInFile(filePath, functionName, argIndex, updates, errors, ignoreAdditionalData, ignoreDynamicContent) {
-    try {
-        const code = fs.readFileSync(filePath, 'utf8');
-        const ast = parse(code, {
-            sourceType: 'module',
-            plugins: ['jsx', 'typescript'],
-        });
-        traverse(ast, {
-            // Handle function declarations: function getInfo(t) { ... }
-            FunctionDeclaration(path) {
-                if (path.node.id?.name === functionName) {
-                    processFunctionIfMatches(functionName, argIndex, path.node, path, updates, errors, filePath, ignoreAdditionalData, ignoreDynamicContent);
-                }
-            },
-            // Handle variable declarations: const getInfo = (t) => { ... }
-            VariableDeclarator(path) {
-                if (t.isIdentifier(path.node.id) &&
-                    path.node.id.name === functionName &&
-                    path.node.init &&
-                    (t.isArrowFunctionExpression(path.node.init) ||
-                        t.isFunctionExpression(path.node.init))) {
-                    const initPath = path.get('init');
-                    processFunctionIfMatches(functionName, argIndex, path.node.init, initPath, updates, errors, filePath, ignoreAdditionalData, ignoreDynamicContent);
-                }
-            },
-        });
-    }
-    catch {
-        // Silently skip files that can't be parsed or accessed
-    }
-}
-/**
- * Main entry point for parsing translation strings from useGT() and getGT() calls.
- *
- * Supports complex patterns including:
- * 1. Direct calls: const t = useGT(); t('hello');
- * 2. Translation callback prop drilling: const t = useGT(); getInfo(t); where getInfo uses t() internally
- * 3. Cross-file function calls: imported functions that receive the translation callback as a parameter
- *
- * Example flow:
- * - const t = useGT();
- * - const { home } = getInfo(t); // getInfo is imported from './constants'
- * - This will parse constants.ts to find translation calls within getInfo function
- */
-export function parseStrings(importName, originalName, path, updates, errors, file) {
-    // First, collect all imports in this file to track cross-file function calls
-    const importMap = buildImportMap(path.scope.getProgramParent().path);
-    const referencePaths = path.scope.bindings[importName]?.referencePaths || [];
-    for (const refPath of referencePaths) {
-        // Handle msg() calls directly without variable assignment
-        if (originalName === MSG_TRANSLATION_HOOK) {
-            const ignoreAdditionalData = false;
-            const ignoreDynamicContent = false;
-            // Check if this is a direct call to msg('string')
-            if (refPath.parent.type === 'CallExpression' &&
-                refPath.parent.callee === refPath.node) {
-                processTranslationCall(refPath, updates, errors, file, ignoreAdditionalData, ignoreDynamicContent);
-            }
-            continue;
-        }
-        // Handle useGT(), getGT(), useMessages(), and getMessages() calls that need variable assignment
-        const callExpr = refPath.findParent((p) => p.isCallExpression());
-        if (callExpr) {
-            // Get the parent, handling both await and non-await cases
-            const parentPath = callExpr.parentPath;
-            const parentFunction = refPath.getFunctionParent();
-            const asyncScope = parentFunction?.node.async;
-            if (asyncScope &&
-                (originalName === INLINE_TRANSLATION_HOOK ||
-                    originalName === INLINE_MESSAGE_HOOK)) {
-                errors.push(warnAsyncUseGT(file, `${refPath.node.loc?.start?.line}:${refPath.node.loc?.start?.column}`));
-                return;
-            }
-            else if (!asyncScope &&
-                (originalName === INLINE_TRANSLATION_HOOK_ASYNC ||
-                    originalName === INLINE_MESSAGE_HOOK_ASYNC)) {
-                errors.push(warnSyncGetGT(file, `${refPath.node.loc?.start?.line}:${refPath.node.loc?.start?.column}`));
-                return;
-            }
-            const isMessageHook = originalName === INLINE_MESSAGE_HOOK ||
-                originalName === INLINE_MESSAGE_HOOK_ASYNC;
-            const ignoreAdditionalData = isMessageHook;
-            const ignoreDynamicContent = isMessageHook;
-            const effectiveParent = parentPath?.node.type === 'AwaitExpression'
-                ? parentPath.parentPath
-                : parentPath;
-            if (effectiveParent &&
-                effectiveParent.node.type === 'VariableDeclarator' &&
-                effectiveParent.node.id.type === 'Identifier') {
-                const tFuncName = effectiveParent.node.id.name;
-                // Get the scope from the variable declaration
-                const variableScope = effectiveParent.scope;
-                // Resolve all aliases of the translation function
-                // Example: translate -> [translate, t, a, b] for const t = translate; const a = t; const b = a;
-                const allTranslationNames = resolveVariableAliases(variableScope, tFuncName);
-                // Process references for all translation function names and their aliases
-                allTranslationNames.forEach((name) => {
-                    const tReferencePaths = variableScope.bindings[name]?.referencePaths || [];
-                    for (const tPath of tReferencePaths) {
-                        handleFunctionCall(tPath, updates, errors, file, importMap, ignoreAdditionalData, ignoreDynamicContent);
-                    }
-                });
-            }
-        }
-    }
-}

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

@@ -1,7 +0,0 @@
-import { NodePath } from '@babel/traverse';
-import { Updates } from '../../../types/index.js';
-/**
- * Validate useGT() / await getGT() calls
- * 1. Validates that the call does not violate the rules of React (no hooks in async functions)
- */
-export declare function validateStringFunction(localImportName: string, path: NodePath, updates: Updates, errors: string[], file: string, originalImportName: string): void;